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:gather_categories; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:imap; 5, identifier:header; 6, default_parameter; 6, 7; 6, 8; 7, identifier:categories; 8, None; 9, block; 9, 10; 9, 31; 9, 52; 9, 58; 9, 65; 9, 124; 9, 147; 9, 208; 9, 214; 9, 236; 9, 248; 9, 330; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:categories; 13, None; 14, block; 14, 15; 15, return_statement; 15, 16; 16, dictionary; 16, 17; 17, pair; 17, 18; 17, 19; 18, string:"default"; 19, call; 19, 20; 19, 21; 20, identifier:DataCategory; 21, argument_list; 21, 22; 21, 30; 22, call; 22, 23; 22, 24; 23, identifier:set; 24, argument_list; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:imap; 28, identifier:keys; 29, argument_list; 30, dictionary; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:cat_ids; 34, list_comprehension; 34, 35; 34, 41; 34, 44; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:header; 38, identifier:index; 39, argument_list; 39, 40; 40, identifier:cat; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:cat; 43, identifier:categories; 44, if_clause; 44, 45; 45, boolean_operator:and; 45, 46; 45, 49; 46, comparison_operator:in; 46, 47; 46, 48; 47, identifier:cat; 48, identifier:header; 49, comparison_operator:not; 49, 50; 49, 51; 50, string:"="; 51, identifier:cat; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:table; 55, call; 55, 56; 55, 57; 56, identifier:OrderedDict; 57, argument_list; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:conditions; 61, call; 61, 62; 61, 63; 62, identifier:defaultdict; 63, argument_list; 63, 64; 64, identifier:set; 65, for_statement; 65, 66; 65, 69; 65, 73; 66, pattern_list; 66, 67; 66, 68; 67, identifier:i; 68, identifier:cat; 69, call; 69, 70; 69, 71; 70, identifier:enumerate; 71, argument_list; 71, 72; 72, identifier:categories; 73, block; 73, 74; 74, if_statement; 74, 75; 74, 89; 75, boolean_operator:and; 75, 76; 75, 79; 76, comparison_operator:in; 76, 77; 76, 78; 77, string:"="; 78, identifier:cat; 79, comparison_operator:in; 79, 80; 79, 88; 80, subscript; 80, 81; 80, 87; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:cat; 84, identifier:split; 85, argument_list; 85, 86; 86, string:"="; 87, integer:0; 88, identifier:header; 89, block; 89, 90; 89, 108; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:cat_name; 93, subscript; 93, 94; 93, 95; 94, identifier:header; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:header; 98, identifier:index; 99, argument_list; 99, 100; 100, subscript; 100, 101; 100, 107; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:cat; 104, identifier:split; 105, argument_list; 105, 106; 106, string:"="; 107, integer:0; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 115; 110, attribute; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:conditions; 113, identifier:cat_name; 114, identifier:add; 115, argument_list; 115, 116; 116, subscript; 116, 117; 116, 123; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:cat; 120, identifier:split; 121, argument_list; 121, 122; 122, string:"="; 123, integer:1; 124, if_statement; 124, 125; 124, 130; 125, boolean_operator:and; 125, 126; 125, 128; 126, not_operator; 126, 127; 127, identifier:cat_ids; 128, not_operator; 128, 129; 129, identifier:conditions; 130, block; 130, 131; 131, return_statement; 131, 132; 132, dictionary; 132, 133; 133, pair; 133, 134; 133, 135; 134, string:"default"; 135, call; 135, 136; 135, 137; 136, identifier:DataCategory; 137, argument_list; 137, 138; 137, 146; 138, call; 138, 139; 138, 140; 139, identifier:set; 140, argument_list; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:imap; 144, identifier:keys; 145, argument_list; 146, dictionary; 147, if_statement; 147, 148; 147, 152; 148, boolean_operator:and; 148, 149; 148, 150; 149, identifier:cat_ids; 150, not_operator; 150, 151; 151, identifier:conditions; 152, block; 152, 153; 152, 206; 153, for_statement; 153, 154; 153, 157; 153, 162; 154, pattern_list; 154, 155; 154, 156; 155, identifier:sid; 156, identifier:row; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:imap; 160, identifier:items; 161, argument_list; 162, block; 162, 163; 162, 178; 162, 195; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:cat_name; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, string:"_"; 169, identifier:join; 170, argument_list; 170, 171; 171, list_comprehension; 171, 172; 171, 175; 172, subscript; 172, 173; 172, 174; 173, identifier:row; 174, identifier:cid; 175, for_in_clause; 175, 176; 175, 177; 176, identifier:cid; 177, identifier:cat_ids; 178, if_statement; 178, 179; 178, 182; 179, comparison_operator:not; 179, 180; 179, 181; 180, identifier:cat_name; 181, identifier:table; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 188; 185, subscript; 185, 186; 185, 187; 186, identifier:table; 187, identifier:cat_name; 188, call; 188, 189; 188, 190; 189, identifier:DataCategory; 190, argument_list; 190, 191; 190, 194; 191, call; 191, 192; 191, 193; 192, identifier:set; 193, argument_list; 194, dictionary; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 204; 197, attribute; 197, 198; 197, 203; 198, attribute; 198, 199; 198, 202; 199, subscript; 199, 200; 199, 201; 200, identifier:table; 201, identifier:cat_name; 202, identifier:sids; 203, identifier:add; 204, argument_list; 204, 205; 205, identifier:sid; 206, return_statement; 206, 207; 207, identifier:table; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:cond_ids; 211, call; 211, 212; 211, 213; 212, identifier:set; 213, argument_list; 214, for_statement; 214, 215; 214, 216; 214, 217; 215, identifier:k; 216, identifier:conditions; 217, block; 217, 218; 218, try_statement; 218, 219; 218, 232; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:cond_ids; 224, identifier:add; 225, argument_list; 225, 226; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:header; 229, identifier:index; 230, argument_list; 230, 231; 231, identifier:k; 232, except_clause; 232, 233; 232, 234; 233, identifier:ValueError; 234, block; 234, 235; 235, continue_statement; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:idx_to_test; 239, call; 239, 240; 239, 246; 240, attribute; 240, 241; 240, 245; 241, call; 241, 242; 241, 243; 242, identifier:set; 243, argument_list; 243, 244; 244, identifier:cat_ids; 245, identifier:union; 246, argument_list; 246, 247; 247, identifier:cond_ids; 248, for_statement; 248, 249; 248, 252; 248, 257; 249, pattern_list; 249, 250; 249, 251; 250, identifier:sid; 251, identifier:row; 252, call; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:imap; 255, identifier:items; 256, argument_list; 257, block; 257, 258; 258, if_statement; 258, 259; 258, 278; 259, call; 259, 260; 259, 261; 260, identifier:all; 261, argument_list; 261, 262; 262, list_comprehension; 262, 263; 262, 275; 263, comparison_operator:in; 263, 264; 263, 272; 264, subscript; 264, 265; 264, 266; 265, identifier:row; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:header; 269, identifier:index; 270, argument_list; 270, 271; 271, identifier:c; 272, subscript; 272, 273; 272, 274; 273, identifier:conditions; 274, identifier:c; 275, for_in_clause; 275, 276; 275, 277; 276, identifier:c; 277, identifier:conditions; 278, block; 278, 279; 278, 294; 278, 319; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:key; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, string:"_"; 285, identifier:join; 286, argument_list; 286, 287; 287, list_comprehension; 287, 288; 287, 291; 288, subscript; 288, 289; 288, 290; 289, identifier:row; 290, identifier:idx; 291, for_in_clause; 291, 292; 291, 293; 292, identifier:idx; 293, identifier:idx_to_test; 294, try_statement; 294, 295; 294, 304; 295, block; 295, 296; 296, assert_statement; 296, 297; 297, comparison_operator:in; 297, 298; 297, 299; 298, identifier:key; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:table; 302, identifier:keys; 303, argument_list; 304, except_clause; 304, 305; 304, 306; 305, identifier:AssertionError; 306, block; 306, 307; 307, expression_statement; 307, 308; 308, assignment; 308, 309; 308, 312; 309, subscript; 309, 310; 309, 311; 310, identifier:table; 311, identifier:key; 312, call; 312, 313; 312, 314; 313, identifier:DataCategory; 314, argument_list; 314, 315; 314, 318; 315, call; 315, 316; 315, 317; 316, identifier:set; 317, argument_list; 318, dictionary; 319, expression_statement; 319, 320; 320, call; 320, 321; 320, 328; 321, attribute; 321, 322; 321, 327; 322, attribute; 322, 323; 322, 326; 323, subscript; 323, 324; 323, 325; 324, identifier:table; 325, identifier:key; 326, identifier:sids; 327, identifier:add; 328, argument_list; 328, 329; 329, identifier:sid; 330, try_statement; 330, 331; 330, 339; 330, 358; 331, block; 331, 332; 332, assert_statement; 332, 333; 333, comparison_operator:>; 333, 334; 333, 338; 334, call; 334, 335; 334, 336; 335, identifier:len; 336, argument_list; 336, 337; 337, identifier:table; 338, integer:0; 339, except_clause; 339, 340; 339, 341; 340, identifier:AssertionError; 341, block; 341, 342; 342, return_statement; 342, 343; 343, dictionary; 343, 344; 344, pair; 344, 345; 344, 346; 345, string:"default"; 346, call; 346, 347; 346, 348; 347, identifier:DataCategory; 348, argument_list; 348, 349; 348, 357; 349, call; 349, 350; 349, 351; 350, identifier:set; 351, argument_list; 351, 352; 352, call; 352, 353; 352, 356; 353, attribute; 353, 354; 353, 355; 354, identifier:imap; 355, identifier:keys; 356, argument_list; 357, dictionary; 358, else_clause; 358, 359; 359, block; 359, 360; 360, return_statement; 360, 361; 361, identifier:table | def gather_categories(imap, header, categories=None):
if categories is None:
return {"default": DataCategory(set(imap.keys()), {})}
cat_ids = [header.index(cat)
for cat in categories if cat in header and "=" not in cat]
table = OrderedDict()
conditions = defaultdict(set)
for i, cat in enumerate(categories):
if "=" in cat and cat.split("=")[0] in header:
cat_name = header[header.index(cat.split("=")[0])]
conditions[cat_name].add(cat.split("=")[1])
if not cat_ids and not conditions:
return {"default": DataCategory(set(imap.keys()), {})}
if cat_ids and not conditions:
for sid, row in imap.items():
cat_name = "_".join([row[cid] for cid in cat_ids])
if cat_name not in table:
table[cat_name] = DataCategory(set(), {})
table[cat_name].sids.add(sid)
return table
cond_ids = set()
for k in conditions:
try:
cond_ids.add(header.index(k))
except ValueError:
continue
idx_to_test = set(cat_ids).union(cond_ids)
for sid, row in imap.items():
if all([row[header.index(c)] in conditions[c] for c in conditions]):
key = "_".join([row[idx] for idx in idx_to_test])
try:
assert key in table.keys()
except AssertionError:
table[key] = DataCategory(set(), {})
table[key].sids.add(sid)
try:
assert len(table) > 0
except AssertionError:
return {"default": DataCategory(set(imap.keys()), {})}
else:
return table |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:color_mapping; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:sample_map; 5, identifier:header; 6, identifier:group_column; 7, default_parameter; 7, 8; 7, 9; 8, identifier:color_column; 9, None; 10, block; 10, 11; 10, 17; 10, 27; 10, 99; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:group_colors; 14, call; 14, 15; 14, 16; 15, identifier:OrderedDict; 16, argument_list; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:group_gather; 20, call; 20, 21; 20, 22; 21, identifier:gather_categories; 22, argument_list; 22, 23; 22, 24; 22, 25; 23, identifier:sample_map; 24, identifier:header; 25, list:[group_column]; 25, 26; 26, identifier:group_column; 27, if_statement; 27, 28; 27, 31; 27, 72; 28, comparison_operator:is; 28, 29; 28, 30; 29, identifier:color_column; 30, None; 31, block; 31, 32; 31, 42; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:color_gather; 35, call; 35, 36; 35, 37; 36, identifier:gather_categories; 37, argument_list; 37, 38; 37, 39; 37, 40; 38, identifier:sample_map; 39, identifier:header; 40, list:[color_column]; 40, 41; 41, identifier:color_column; 42, for_statement; 42, 43; 42, 44; 42, 45; 43, identifier:group; 44, identifier:group_gather; 45, block; 45, 46; 46, for_statement; 46, 47; 46, 48; 46, 49; 47, identifier:color; 48, identifier:color_gather; 49, block; 49, 50; 50, if_statement; 50, 51; 50, 65; 51, call; 51, 52; 51, 59; 52, attribute; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, subscript; 54, 55; 54, 56; 55, identifier:group_gather; 56, identifier:group; 57, identifier:sids; 58, identifier:intersection; 59, argument_list; 59, 60; 60, attribute; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:color_gather; 63, identifier:color; 64, identifier:sids; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:group_colors; 70, identifier:group; 71, identifier:color; 72, else_clause; 72, 73; 73, block; 73, 74; 73, 85; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:bcolors; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:itertools; 80, identifier:cycle; 81, argument_list; 81, 82; 82, attribute; 82, 83; 82, 84; 83, identifier:Set3_12; 84, identifier:hex_colors; 85, for_statement; 85, 86; 85, 87; 85, 88; 86, identifier:group; 87, identifier:group_gather; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 94; 91, subscript; 91, 92; 91, 93; 92, identifier:group_colors; 93, identifier:group; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:bcolors; 97, identifier:next; 98, argument_list; 99, return_statement; 99, 100; 100, identifier:group_colors | def color_mapping(sample_map, header, group_column, color_column=None):
group_colors = OrderedDict()
group_gather = gather_categories(sample_map, header, [group_column])
if color_column is not None:
color_gather = gather_categories(sample_map, header, [color_column])
for group in group_gather:
for color in color_gather:
if group_gather[group].sids.intersection(color_gather[color].sids):
group_colors[group] = color
else:
bcolors = itertools.cycle(Set3_12.hex_colors)
for group in group_gather:
group_colors[group] = bcolors.next()
return group_colors |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 29; 2, function_name:shuffle_genome; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 12; 3, 15; 3, 16; 3, 19; 3, 22; 3, 23; 3, 26; 4, identifier:genome; 5, identifier:cat; 6, default_parameter; 6, 7; 6, 8; 7, identifier:fraction; 8, call; 8, 9; 8, 10; 9, identifier:float; 10, argument_list; 10, 11; 11, integer:100; 12, default_parameter; 12, 13; 12, 14; 13, identifier:plot; 14, True; 15, line_continuation:\; 16, default_parameter; 16, 17; 16, 18; 17, identifier:alpha; 18, float:0.1; 19, default_parameter; 19, 20; 19, 21; 20, identifier:beta; 21, integer:100000; 22, line_continuation:\; 23, default_parameter; 23, 24; 23, 25; 24, identifier:min_length; 25, integer:1000; 26, default_parameter; 26, 27; 26, 28; 27, identifier:max_length; 28, integer:200000; 29, block; 29, 30; 29, 39; 29, 60; 29, 67; 29, 71; 29, 152; 29, 159; 29, 242; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:header; 33, binary_operator:%; 33, 34; 33, 35; 34, string:'>randomized_%s'; 35, parenthesized_expression; 35, 36; 36, attribute; 36, 37; 36, 38; 37, identifier:genome; 38, identifier:name; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:sequence; 42, call; 42, 43; 42, 44; 43, identifier:list; 44, argument_list; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, string:''; 48, identifier:join; 49, argument_list; 49, 50; 50, list_comprehension; 50, 51; 50, 54; 51, subscript; 51, 52; 51, 53; 52, identifier:i; 53, integer:1; 54, for_in_clause; 54, 55; 54, 56; 55, identifier:i; 56, call; 56, 57; 56, 58; 57, identifier:parse_fasta; 58, argument_list; 58, 59; 59, identifier:genome; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:length; 63, call; 63, 64; 63, 65; 64, identifier:len; 65, argument_list; 65, 66; 66, identifier:sequence; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:shuffled; 70, list:[]; 71, while_statement; 71, 72; 71, 75; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:sequence; 74, False; 75, block; 75, 76; 75, 89; 75, 99; 75, 126; 75, 134; 75, 146; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:s; 79, call; 79, 80; 79, 81; 80, identifier:int; 81, argument_list; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:random; 85, identifier:gammavariate; 86, argument_list; 86, 87; 86, 88; 87, identifier:alpha; 88, identifier:beta; 89, if_statement; 89, 90; 89, 97; 90, boolean_operator:or; 90, 91; 90, 94; 91, comparison_operator:<=; 91, 92; 91, 93; 92, identifier:s; 93, identifier:min_length; 94, comparison_operator:>=; 94, 95; 94, 96; 95, identifier:s; 96, identifier:max_length; 97, block; 97, 98; 98, continue_statement; 99, if_statement; 99, 100; 99, 106; 99, 115; 100, comparison_operator:<; 100, 101; 100, 105; 101, call; 101, 102; 101, 103; 102, identifier:len; 103, argument_list; 103, 104; 104, identifier:sequence; 105, identifier:s; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:seq; 110, subscript; 110, 111; 110, 112; 111, identifier:sequence; 112, slice; 112, 113; 112, 114; 113, integer:0; 114, colon; 115, else_clause; 115, 116; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:seq; 120, subscript; 120, 121; 120, 122; 121, identifier:sequence; 122, slice; 122, 123; 122, 124; 122, 125; 123, integer:0; 124, colon; 125, identifier:s; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:sequence; 129, subscript; 129, 130; 129, 131; 130, identifier:sequence; 131, slice; 131, 132; 131, 133; 132, identifier:s; 133, colon; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:shuffled; 138, identifier:append; 139, argument_list; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, string:''; 143, identifier:join; 144, argument_list; 144, 145; 145, identifier:seq; 146, if_statement; 146, 147; 146, 150; 147, comparison_operator:==; 147, 148; 147, 149; 148, identifier:sequence; 149, list:[]; 150, block; 150, 151; 151, break_statement; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:random; 156, identifier:shuffle; 157, argument_list; 157, 158; 158, identifier:shuffled; 159, if_statement; 159, 160; 159, 166; 159, 171; 160, comparison_operator:==; 160, 161; 160, 162; 161, identifier:fraction; 162, call; 162, 163; 162, 164; 163, identifier:float; 164, argument_list; 164, 165; 165, integer:100; 166, block; 166, 167; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:subset; 170, identifier:shuffled; 171, else_clause; 171, 172; 172, block; 172, 173; 172, 184; 172, 192; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:max_pieces; 176, call; 176, 177; 176, 178; 177, identifier:int; 178, argument_list; 178, 179; 179, binary_operator:/; 179, 180; 179, 183; 180, binary_operator:*; 180, 181; 180, 182; 181, identifier:length; 182, identifier:fraction; 183, integer:100; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 189; 186, pattern_list; 186, 187; 186, 188; 187, identifier:subset; 188, identifier:total; 189, expression_list; 189, 190; 189, 191; 190, list:[]; 191, integer:0; 192, for_statement; 192, 193; 192, 194; 192, 195; 193, identifier:fragment; 194, identifier:shuffled; 195, block; 195, 196; 195, 203; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:length; 199, call; 199, 200; 199, 201; 200, identifier:len; 201, argument_list; 201, 202; 202, identifier:fragment; 203, if_statement; 203, 204; 203, 209; 203, 221; 204, comparison_operator:<=; 204, 205; 204, 208; 205, binary_operator:+; 205, 206; 205, 207; 206, identifier:total; 207, identifier:length; 208, identifier:max_pieces; 209, block; 209, 210; 209, 217; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:subset; 214, identifier:append; 215, argument_list; 215, 216; 216, identifier:fragment; 217, expression_statement; 217, 218; 218, augmented_assignment:+=; 218, 219; 218, 220; 219, identifier:total; 220, identifier:length; 221, else_clause; 221, 222; 222, block; 222, 223; 222, 229; 222, 241; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:diff; 226, binary_operator:-; 226, 227; 226, 228; 227, identifier:max_pieces; 228, identifier:total; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:subset; 233, identifier:append; 234, argument_list; 234, 235; 235, subscript; 235, 236; 235, 237; 236, identifier:fragment; 237, slice; 237, 238; 237, 239; 237, 240; 238, integer:0; 239, colon; 240, identifier:diff; 241, break_statement; 242, if_statement; 242, 243; 242, 246; 242, 257; 243, comparison_operator:is; 243, 244; 243, 245; 244, identifier:cat; 245, True; 246, block; 246, 247; 247, expression_statement; 247, 248; 248, yield; 248, 249; 249, list:[header, ''.join(subset)]; 249, 250; 249, 251; 250, identifier:header; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, string:''; 254, identifier:join; 255, argument_list; 255, 256; 256, identifier:subset; 257, else_clause; 257, 258; 258, block; 258, 259; 259, for_statement; 259, 260; 259, 263; 259, 267; 260, pattern_list; 260, 261; 260, 262; 261, identifier:i; 262, identifier:seq; 263, call; 263, 264; 263, 265; 264, identifier:enumerate; 265, argument_list; 265, 266; 266, identifier:subset; 267, block; 267, 268; 268, expression_statement; 268, 269; 269, yield; 269, 270; 270, list:['%s fragment:%s' % (header, i), seq]; 270, 271; 270, 276; 271, binary_operator:%; 271, 272; 271, 273; 272, string:'%s fragment:%s'; 273, tuple; 273, 274; 273, 275; 274, identifier:header; 275, identifier:i; 276, identifier:seq | def shuffle_genome(genome, cat, fraction = float(100), plot = True, \
alpha = 0.1, beta = 100000, \
min_length = 1000, max_length = 200000):
header = '>randomized_%s' % (genome.name)
sequence = list(''.join([i[1] for i in parse_fasta(genome)]))
length = len(sequence)
shuffled = []
while sequence is not False:
s = int(random.gammavariate(alpha, beta))
if s <= min_length or s >= max_length:
continue
if len(sequence) < s:
seq = sequence[0:]
else:
seq = sequence[0:s]
sequence = sequence[s:]
shuffled.append(''.join(seq))
if sequence == []:
break
random.shuffle(shuffled)
if fraction == float(100):
subset = shuffled
else:
max_pieces = int(length * fraction/100)
subset, total = [], 0
for fragment in shuffled:
length = len(fragment)
if total + length <= max_pieces:
subset.append(fragment)
total += length
else:
diff = max_pieces - total
subset.append(fragment[0:diff])
break
if cat is True:
yield [header, ''.join(subset)]
else:
for i, seq in enumerate(subset):
yield ['%s fragment:%s' % (header, i), seq] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sam2fastq; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:sam; 5, default_parameter; 5, 6; 5, 7; 6, identifier:singles; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:force; 10, False; 11, block; 11, 12; 11, 20; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 17; 14, pattern_list; 14, 15; 14, 16; 15, identifier:L; 16, identifier:R; 17, expression_list; 17, 18; 17, 19; 18, None; 19, None; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:line; 22, identifier:sam; 23, block; 23, 24; 23, 35; 23, 47; 23, 82; 23, 97; 23, 109; 23, 126; 23, 170; 23, 258; 24, if_statement; 24, 25; 24, 33; 25, comparison_operator:is; 25, 26; 25, 32; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:line; 29, identifier:startswith; 30, argument_list; 30, 31; 31, string:'@'; 32, True; 33, block; 33, 34; 34, continue_statement; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:line; 38, call; 38, 39; 38, 46; 39, attribute; 39, 40; 39, 45; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:line; 43, identifier:strip; 44, argument_list; 45, identifier:split; 46, argument_list; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:bit; 50, list_comprehension; 50, 51; 50, 57; 50, 58; 51, conditional_expression:if; 51, 52; 51, 53; 51, 56; 52, True; 53, comparison_operator:==; 53, 54; 53, 55; 54, identifier:i; 55, string:'1'; 56, False; 57, line_continuation:\; 58, for_in_clause; 58, 59; 58, 60; 59, identifier:i; 60, subscript; 60, 61; 60, 77; 61, subscript; 61, 62; 61, 76; 62, call; 62, 63; 62, 74; 63, attribute; 63, 64; 63, 73; 64, call; 64, 65; 64, 66; 65, identifier:bin; 66, argument_list; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:int; 69, argument_list; 69, 70; 70, subscript; 70, 71; 70, 72; 71, identifier:line; 72, integer:1; 73, identifier:split; 74, argument_list; 74, 75; 75, string:'b'; 76, integer:1; 77, slice; 77, 78; 77, 79; 77, 80; 78, colon; 79, colon; 80, unary_operator:-; 80, 81; 81, integer:1; 82, while_statement; 82, 83; 82, 89; 83, comparison_operator:<; 83, 84; 83, 88; 84, call; 84, 85; 84, 86; 85, identifier:len; 86, argument_list; 86, 87; 87, identifier:bit; 88, integer:8; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:bit; 94, identifier:append; 95, argument_list; 95, 96; 96, False; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 108; 99, pattern_list; 99, 100; 99, 101; 99, 102; 99, 103; 99, 104; 99, 105; 99, 106; 99, 107; 100, identifier:pair; 101, identifier:proper; 102, identifier:na; 103, identifier:nap; 104, identifier:rev; 105, identifier:mrev; 106, identifier:left; 107, identifier:right; 108, identifier:bit; 109, if_statement; 109, 110; 109, 113; 110, comparison_operator:is; 110, 111; 110, 112; 111, identifier:pair; 112, False; 113, block; 113, 114; 113, 125; 114, if_statement; 114, 115; 114, 118; 115, comparison_operator:is; 115, 116; 115, 117; 116, identifier:singles; 117, True; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:print_single; 122, argument_list; 122, 123; 122, 124; 123, identifier:line; 124, identifier:rev; 125, continue_statement; 126, if_statement; 126, 127; 126, 130; 126, 156; 127, comparison_operator:is; 127, 128; 127, 129; 128, identifier:rev; 129, True; 130, block; 130, 131; 130, 144; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:seq; 134, subscript; 134, 135; 134, 143; 135, call; 135, 136; 135, 137; 136, identifier:rc; 137, argument_list; 137, 138; 138, list:['', line[9]]; 138, 139; 138, 140; 139, string:''; 140, subscript; 140, 141; 140, 142; 141, identifier:line; 142, integer:9; 143, integer:1; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:qual; 147, subscript; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:line; 150, integer:10; 151, slice; 151, 152; 151, 153; 151, 154; 152, colon; 153, colon; 154, unary_operator:-; 154, 155; 155, integer:1; 156, else_clause; 156, 157; 157, block; 157, 158; 157, 164; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:seq; 161, subscript; 161, 162; 161, 163; 162, identifier:line; 163, integer:9; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:qual; 167, subscript; 167, 168; 167, 169; 168, identifier:line; 169, integer:10; 170, if_statement; 170, 171; 170, 174; 171, comparison_operator:is; 171, 172; 171, 173; 172, identifier:left; 173, True; 174, block; 174, 175; 174, 213; 174, 223; 174, 239; 175, if_statement; 175, 176; 175, 183; 176, boolean_operator:and; 176, 177; 176, 180; 177, comparison_operator:is; 177, 178; 177, 179; 178, identifier:L; 179, None; 180, comparison_operator:is; 180, 181; 180, 182; 181, identifier:force; 182, False; 183, block; 183, 184; 183, 194; 183, 209; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:print; 187, argument_list; 187, 188; 187, 189; 188, string:'sam file is not sorted'; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:file; 191, attribute; 191, 192; 191, 193; 192, identifier:sys; 193, identifier:stderr; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 197; 196, identifier:print; 197, argument_list; 197, 198; 197, 204; 198, binary_operator:%; 198, 199; 198, 200; 199, string:'\te.g.: %s'; 200, parenthesized_expression; 200, 201; 201, subscript; 201, 202; 201, 203; 202, identifier:line; 203, integer:0; 204, keyword_argument; 204, 205; 204, 206; 205, identifier:file; 206, attribute; 206, 207; 206, 208; 207, identifier:sys; 208, identifier:stderr; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 212; 211, identifier:exit; 212, argument_list; 213, if_statement; 213, 214; 213, 217; 214, comparison_operator:is; 214, 215; 214, 216; 215, identifier:L; 216, None; 217, block; 217, 218; 217, 222; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:L; 221, None; 222, continue_statement; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:L; 226, list:['@%s' % line[0], seq, '+%s' % line[0], qual]; 226, 227; 226, 232; 226, 233; 226, 238; 227, binary_operator:%; 227, 228; 227, 229; 228, string:'@%s'; 229, subscript; 229, 230; 229, 231; 230, identifier:line; 231, integer:0; 232, identifier:seq; 233, binary_operator:%; 233, 234; 233, 235; 234, string:'+%s'; 235, subscript; 235, 236; 235, 237; 236, identifier:line; 237, integer:0; 238, identifier:qual; 239, if_statement; 239, 240; 239, 243; 240, comparison_operator:is; 240, 241; 240, 242; 241, identifier:R; 242, None; 243, block; 243, 244; 243, 247; 243, 250; 244, expression_statement; 244, 245; 245, yield; 245, 246; 246, identifier:L; 247, expression_statement; 247, 248; 248, yield; 248, 249; 249, identifier:R; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 255; 252, pattern_list; 252, 253; 252, 254; 253, identifier:L; 254, identifier:R; 255, expression_list; 255, 256; 255, 257; 256, None; 257, None; 258, if_statement; 258, 259; 258, 262; 259, comparison_operator:is; 259, 260; 259, 261; 260, identifier:right; 261, True; 262, block; 262, 263; 262, 301; 262, 311; 262, 327; 263, if_statement; 263, 264; 263, 271; 264, boolean_operator:and; 264, 265; 264, 268; 265, comparison_operator:is; 265, 266; 265, 267; 266, identifier:R; 267, None; 268, comparison_operator:is; 268, 269; 268, 270; 269, identifier:force; 270, False; 271, block; 271, 272; 271, 282; 271, 297; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 275; 274, identifier:print; 275, argument_list; 275, 276; 275, 277; 276, string:'sam file is not sorted'; 277, keyword_argument; 277, 278; 277, 279; 278, identifier:file; 279, attribute; 279, 280; 279, 281; 280, identifier:sys; 281, identifier:stderr; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 285; 284, identifier:print; 285, argument_list; 285, 286; 285, 292; 286, binary_operator:%; 286, 287; 286, 288; 287, string:'\te.g.: %s'; 288, parenthesized_expression; 288, 289; 289, subscript; 289, 290; 289, 291; 290, identifier:line; 291, integer:0; 292, keyword_argument; 292, 293; 292, 294; 293, identifier:file; 294, attribute; 294, 295; 294, 296; 295, identifier:sys; 296, identifier:stderr; 297, expression_statement; 297, 298; 298, call; 298, 299; 298, 300; 299, identifier:exit; 300, argument_list; 301, if_statement; 301, 302; 301, 305; 302, comparison_operator:is; 302, 303; 302, 304; 303, identifier:R; 304, None; 305, block; 305, 306; 305, 310; 306, expression_statement; 306, 307; 307, assignment; 307, 308; 307, 309; 308, identifier:R; 309, None; 310, continue_statement; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:R; 314, list:['@%s' % line[0], seq, '+%s' % line[0], qual]; 314, 315; 314, 320; 314, 321; 314, 326; 315, binary_operator:%; 315, 316; 315, 317; 316, string:'@%s'; 317, subscript; 317, 318; 317, 319; 318, identifier:line; 319, integer:0; 320, identifier:seq; 321, binary_operator:%; 321, 322; 321, 323; 322, string:'+%s'; 323, subscript; 323, 324; 323, 325; 324, identifier:line; 325, integer:0; 326, identifier:qual; 327, if_statement; 327, 328; 327, 331; 328, comparison_operator:is; 328, 329; 328, 330; 329, identifier:L; 330, None; 331, block; 331, 332; 331, 335; 331, 338; 332, expression_statement; 332, 333; 333, yield; 333, 334; 334, identifier:L; 335, expression_statement; 335, 336; 336, yield; 336, 337; 337, identifier:R; 338, expression_statement; 338, 339; 339, assignment; 339, 340; 339, 343; 340, pattern_list; 340, 341; 340, 342; 341, identifier:L; 342, identifier:R; 343, expression_list; 343, 344; 343, 345; 344, None; 345, None | def sam2fastq(sam, singles = False, force = False):
L, R = None, None
for line in sam:
if line.startswith('@') is True:
continue
line = line.strip().split()
bit = [True if i == '1' else False \
for i in bin(int(line[1])).split('b')[1][::-1]]
while len(bit) < 8:
bit.append(False)
pair, proper, na, nap, rev, mrev, left, right = bit
if pair is False:
if singles is True:
print_single(line, rev)
continue
if rev is True:
seq = rc(['', line[9]])[1]
qual = line[10][::-1]
else:
seq = line[9]
qual = line[10]
if left is True:
if L is not None and force is False:
print('sam file is not sorted', file = sys.stderr)
print('\te.g.: %s' % (line[0]), file = sys.stderr)
exit()
if L is not None:
L = None
continue
L = ['@%s' % line[0], seq, '+%s' % line[0], qual]
if R is not None:
yield L
yield R
L, R = None, None
if right is True:
if R is not None and force is False:
print('sam file is not sorted', file = sys.stderr)
print('\te.g.: %s' % (line[0]), file = sys.stderr)
exit()
if R is not None:
R = None
continue
R = ['@%s' % line[0], seq, '+%s' % line[0], qual]
if L is not None:
yield L
yield R
L, R = None, None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_sam; 3, parameters; 3, 4; 3, 5; 4, identifier:sam; 5, identifier:sort; 6, block; 6, 7; 6, 29; 6, 141; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:tempdir; 10, binary_operator:%; 10, 11; 10, 12; 11, string:'%s/'; 12, parenthesized_expression; 12, 13; 13, subscript; 13, 14; 13, 28; 14, call; 14, 15; 14, 25; 15, attribute; 15, 16; 15, 24; 16, call; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:os; 20, identifier:path; 21, identifier:abspath; 22, argument_list; 22, 23; 23, identifier:sam; 24, identifier:rsplit; 25, argument_list; 25, 26; 25, 27; 26, string:'/'; 27, integer:1; 28, integer:0; 29, if_statement; 29, 30; 29, 33; 29, 119; 30, comparison_operator:is; 30, 31; 30, 32; 31, identifier:sort; 32, True; 33, block; 33, 34; 33, 49; 33, 112; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:mapping; 37, binary_operator:%; 37, 38; 37, 39; 38, string:'%s.sorted.sam'; 39, parenthesized_expression; 39, 40; 40, subscript; 40, 41; 40, 48; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:sam; 44, identifier:rsplit; 45, argument_list; 45, 46; 45, 47; 46, string:'.'; 47, integer:1; 48, integer:0; 49, if_statement; 49, 50; 49, 53; 49, 79; 50, comparison_operator:!=; 50, 51; 50, 52; 51, identifier:sam; 52, string:'-'; 53, block; 53, 54; 54, if_statement; 54, 55; 54, 65; 55, comparison_operator:is; 55, 56; 55, 64; 56, call; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:os; 60, identifier:path; 61, identifier:exists; 62, argument_list; 62, 63; 63, identifier:mapping; 64, False; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:os; 70, identifier:system; 71, argument_list; 71, 72; 72, binary_operator:%; 72, 73; 72, 74; 73, string:"\
sort -k1 --buffer-size=%sG -T %s -o %s %s\
"; 74, tuple; 74, 75; 74, 76; 74, 77; 74, 78; 75, identifier:sbuffer; 76, identifier:tempdir; 77, identifier:mapping; 78, identifier:sam; 79, else_clause; 79, 80; 80, block; 80, 81; 80, 85; 80, 106; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:mapping; 84, string:'stdin-sam.sorted.sam'; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:p; 88, call; 88, 89; 88, 90; 89, identifier:Popen; 90, argument_list; 90, 91; 90, 98; 90, 103; 91, binary_operator:%; 91, 92; 91, 93; 91, 94; 92, string:"sort -k1 --buffer-size=%sG -T %s -o %s"; 93, line_continuation:\; 94, tuple; 94, 95; 94, 96; 94, 97; 95, identifier:sbuffer; 96, identifier:tempdir; 97, identifier:mapping; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:stdin; 100, attribute; 100, 101; 100, 102; 101, identifier:sys; 102, identifier:stdin; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:shell; 105, True; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:p; 110, identifier:communicate; 111, argument_list; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:mapping; 115, call; 115, 116; 115, 117; 116, identifier:open; 117, argument_list; 117, 118; 118, identifier:mapping; 119, else_clause; 119, 120; 120, block; 120, 121; 121, if_statement; 121, 122; 121, 125; 121, 132; 122, comparison_operator:==; 122, 123; 122, 124; 123, identifier:sam; 124, string:'-'; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:mapping; 129, attribute; 129, 130; 129, 131; 130, identifier:sys; 131, identifier:stdin; 132, else_clause; 132, 133; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:mapping; 137, call; 137, 138; 137, 139; 138, identifier:open; 139, argument_list; 139, 140; 140, identifier:sam; 141, return_statement; 141, 142; 142, identifier:mapping | def sort_sam(sam, sort):
tempdir = '%s/' % (os.path.abspath(sam).rsplit('/', 1)[0])
if sort is True:
mapping = '%s.sorted.sam' % (sam.rsplit('.', 1)[0])
if sam != '-':
if os.path.exists(mapping) is False:
os.system("\
sort -k1 --buffer-size=%sG -T %s -o %s %s\
" % (sbuffer, tempdir, mapping, sam))
else:
mapping = 'stdin-sam.sorted.sam'
p = Popen("sort -k1 --buffer-size=%sG -T %s -o %s" \
% (sbuffer, tempdir, mapping), stdin = sys.stdin, shell = True)
p.communicate()
mapping = open(mapping)
else:
if sam == '-':
mapping = sys.stdin
else:
mapping = open(sam)
return mapping |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:crossmap; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 4, identifier:fas; 5, identifier:reads; 6, identifier:options; 7, identifier:no_shrink; 8, identifier:keepDB; 9, identifier:threads; 10, identifier:cluster; 11, identifier:nodes; 12, block; 12, 13; 12, 22; 12, 26; 12, 213; 13, if_statement; 13, 14; 13, 17; 14, comparison_operator:is; 14, 15; 14, 16; 15, identifier:cluster; 16, True; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:threads; 21, string:'48'; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:btc; 25, list:[]; 26, for_statement; 26, 27; 26, 28; 26, 29; 27, identifier:fa; 28, identifier:fas; 29, block; 29, 30; 29, 38; 29, 45; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:btd; 33, call; 33, 34; 33, 35; 34, identifier:bowtiedb; 35, argument_list; 35, 36; 35, 37; 36, identifier:fa; 37, identifier:keepDB; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 44; 40, pattern_list; 40, 41; 40, 42; 40, 43; 41, identifier:F; 42, identifier:R; 43, identifier:U; 44, identifier:reads; 45, if_statement; 45, 46; 45, 49; 45, 142; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:F; 48, False; 49, block; 49, 50; 49, 59; 50, if_statement; 50, 51; 50, 54; 51, comparison_operator:is; 51, 52; 51, 53; 52, identifier:U; 53, False; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:u; 58, False; 59, for_statement; 59, 60; 59, 63; 59, 67; 60, pattern_list; 60, 61; 60, 62; 61, identifier:i; 62, identifier:f; 63, call; 63, 64; 63, 65; 64, identifier:enumerate; 65, argument_list; 65, 66; 66, identifier:F; 67, block; 67, 68; 67, 74; 67, 85; 67, 125; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:r; 71, subscript; 71, 72; 71, 73; 72, identifier:R; 73, identifier:i; 74, if_statement; 74, 75; 74, 78; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:U; 77, False; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:u; 82, subscript; 82, 83; 82, 84; 83, identifier:U; 84, identifier:i; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:sam; 88, binary_operator:%; 88, 89; 88, 90; 89, string:'%s/%s-vs-%s'; 90, tuple; 90, 91; 90, 96; 90, 97; 90, 107; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:os; 94, identifier:getcwd; 95, argument_list; 96, line_continuation:\; 97, subscript; 97, 98; 97, 105; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:fa; 101, identifier:rsplit; 102, argument_list; 102, 103; 102, 104; 103, string:'/'; 104, integer:1; 105, unary_operator:-; 105, 106; 106, integer:1; 107, subscript; 107, 108; 107, 124; 108, call; 108, 109; 108, 121; 109, attribute; 109, 110; 109, 120; 110, subscript; 110, 111; 110, 118; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:f; 114, identifier:rsplit; 115, argument_list; 115, 116; 115, 117; 116, string:'/'; 117, integer:1; 118, unary_operator:-; 118, 119; 119, integer:1; 120, identifier:rsplit; 121, argument_list; 121, 122; 121, 123; 122, string:'.'; 123, integer:3; 124, integer:0; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:btc; 129, identifier:append; 130, argument_list; 130, 131; 131, call; 131, 132; 131, 133; 132, identifier:bowtie; 133, argument_list; 133, 134; 133, 135; 133, 136; 133, 137; 133, 138; 133, 139; 133, 140; 133, 141; 134, identifier:sam; 135, identifier:btd; 136, identifier:f; 137, identifier:r; 138, identifier:u; 139, identifier:options; 140, identifier:no_shrink; 141, identifier:threads; 142, else_clause; 142, 143; 143, block; 143, 144; 143, 148; 143, 152; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:f; 147, False; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:r; 151, False; 152, for_statement; 152, 153; 152, 154; 152, 155; 153, identifier:u; 154, identifier:U; 155, block; 155, 156; 155, 196; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:sam; 159, binary_operator:%; 159, 160; 159, 161; 160, string:'%s/%s-vs-%s'; 161, tuple; 161, 162; 161, 167; 161, 168; 161, 178; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:os; 165, identifier:getcwd; 166, argument_list; 167, line_continuation:\; 168, subscript; 168, 169; 168, 176; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:fa; 172, identifier:rsplit; 173, argument_list; 173, 174; 173, 175; 174, string:'/'; 175, integer:1; 176, unary_operator:-; 176, 177; 177, integer:1; 178, subscript; 178, 179; 178, 195; 179, call; 179, 180; 179, 192; 180, attribute; 180, 181; 180, 191; 181, subscript; 181, 182; 181, 189; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:u; 185, identifier:rsplit; 186, argument_list; 186, 187; 186, 188; 187, string:'/'; 188, integer:1; 189, unary_operator:-; 189, 190; 190, integer:1; 191, identifier:rsplit; 192, argument_list; 192, 193; 192, 194; 193, string:'.'; 194, integer:3; 195, integer:0; 196, expression_statement; 196, 197; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:btc; 200, identifier:append; 201, argument_list; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:bowtie; 204, argument_list; 204, 205; 204, 206; 204, 207; 204, 208; 204, 209; 204, 210; 204, 211; 204, 212; 205, identifier:sam; 206, identifier:btd; 207, identifier:f; 208, identifier:r; 209, identifier:u; 210, identifier:options; 211, identifier:no_shrink; 212, identifier:threads; 213, if_statement; 213, 214; 213, 217; 213, 240; 214, comparison_operator:is; 214, 215; 214, 216; 215, identifier:cluster; 216, False; 217, block; 217, 218; 218, for_statement; 218, 219; 218, 220; 218, 221; 219, identifier:i; 220, identifier:btc; 221, block; 221, 222; 221, 234; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:p; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:subprocess; 228, identifier:Popen; 229, argument_list; 229, 230; 229, 231; 230, identifier:i; 231, keyword_argument; 231, 232; 231, 233; 232, identifier:shell; 233, True; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:p; 238, identifier:communicate; 239, argument_list; 240, else_clause; 240, 241; 241, block; 241, 242; 241, 273; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:ID; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, string:''; 248, identifier:join; 249, generator_expression; 249, 250; 249, 267; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:random; 253, identifier:choice; 254, argument_list; 254, 255; 255, list_comprehension; 255, 256; 255, 260; 256, call; 256, 257; 256, 258; 257, identifier:str; 258, argument_list; 258, 259; 259, identifier:i; 260, for_in_clause; 260, 261; 260, 262; 261, identifier:i; 262, call; 262, 263; 262, 264; 263, identifier:range; 264, argument_list; 264, 265; 264, 266; 265, integer:0; 266, integer:9; 267, for_in_clause; 267, 268; 267, 269; 268, identifier:_; 269, call; 269, 270; 269, 271; 270, identifier:range; 271, argument_list; 271, 272; 272, integer:5; 273, for_statement; 273, 274; 273, 277; 273, 286; 274, pattern_list; 274, 275; 274, 276; 275, identifier:node; 276, identifier:commands; 277, call; 277, 278; 277, 279; 278, identifier:enumerate; 279, argument_list; 279, 280; 279, 285; 280, call; 280, 281; 280, 282; 281, identifier:chunks; 282, argument_list; 282, 283; 282, 284; 283, identifier:btc; 284, identifier:nodes; 285, integer:1; 286, block; 286, 287; 286, 304; 286, 317; 286, 323; 286, 342; 287, expression_statement; 287, 288; 288, assignment; 288, 289; 288, 290; 289, identifier:bs; 290, call; 290, 291; 290, 292; 291, identifier:open; 292, argument_list; 292, 293; 292, 303; 293, binary_operator:%; 293, 294; 293, 295; 294, string:'%s/crossmap-qsub.%s.%s.sh'; 295, tuple; 295, 296; 295, 301; 295, 302; 296, call; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:os; 299, identifier:getcwd; 300, argument_list; 301, identifier:ID; 302, identifier:node; 303, string:'w'; 304, expression_statement; 304, 305; 305, call; 305, 306; 305, 307; 306, identifier:print; 307, argument_list; 307, 308; 307, 314; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, string:'\n'; 311, identifier:join; 312, argument_list; 312, 313; 313, identifier:commands; 314, keyword_argument; 314, 315; 314, 316; 315, identifier:file; 316, identifier:bs; 317, expression_statement; 317, 318; 318, call; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:bs; 321, identifier:close; 322, argument_list; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:p; 326, call; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, identifier:subprocess; 329, identifier:Popen; 330, argument_list; 330, 331; 330, 338; 330, 339; 331, binary_operator:%; 331, 332; 331, 333; 331, 334; 332, string:'qsub -V -N crossmap %s'; 333, line_continuation:\; 334, parenthesized_expression; 334, 335; 335, attribute; 335, 336; 335, 337; 336, identifier:bs; 337, identifier:name; 338, line_continuation:\; 339, keyword_argument; 339, 340; 339, 341; 340, identifier:shell; 341, True; 342, expression_statement; 342, 343; 343, call; 343, 344; 343, 347; 344, attribute; 344, 345; 344, 346; 345, identifier:p; 346, identifier:communicate; 347, argument_list | def crossmap(fas, reads, options, no_shrink, keepDB, threads, cluster, nodes):
if cluster is True:
threads = '48'
btc = []
for fa in fas:
btd = bowtiedb(fa, keepDB)
F, R, U = reads
if F is not False:
if U is False:
u = False
for i, f in enumerate(F):
r = R[i]
if U is not False:
u = U[i]
sam = '%s/%s-vs-%s' % (os.getcwd(), \
fa.rsplit('/', 1)[-1], f.rsplit('/', 1)[-1].rsplit('.', 3)[0])
btc.append(bowtie(sam, btd, f, r, u, options, no_shrink, threads))
else:
f = False
r = False
for u in U:
sam = '%s/%s-vs-%s' % (os.getcwd(), \
fa.rsplit('/', 1)[-1], u.rsplit('/', 1)[-1].rsplit('.', 3)[0])
btc.append(bowtie(sam, btd, f, r, u, options, no_shrink, threads))
if cluster is False:
for i in btc:
p = subprocess.Popen(i, shell = True)
p.communicate()
else:
ID = ''.join(random.choice([str(i) for i in range(0, 9)]) for _ in range(5))
for node, commands in enumerate(chunks(btc, nodes), 1):
bs = open('%s/crossmap-qsub.%s.%s.sh' % (os.getcwd(), ID, node), 'w')
print('\n'.join(commands), file=bs)
bs.close()
p = subprocess.Popen(\
'qsub -V -N crossmap %s' \
% (bs.name), \
shell = True)
p.communicate() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:bit_by_bit; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:in_data; 6, block; 6, 7; 6, 25; 6, 31; 6, 97; 6, 135; 6, 152; 7, if_statement; 7, 8; 7, 13; 8, call; 8, 9; 8, 10; 9, identifier:isinstance; 10, argument_list; 10, 11; 10, 12; 11, identifier:in_data; 12, identifier:str; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:in_data; 17, list_comprehension; 17, 18; 17, 22; 18, call; 18, 19; 18, 20; 19, identifier:ord; 20, argument_list; 20, 21; 21, identifier:c; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:c; 24, identifier:in_data; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:register; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:NonDirectInit; 31, for_statement; 31, 32; 31, 33; 31, 34; 32, identifier:octet; 33, identifier:in_data; 34, block; 34, 35; 34, 50; 35, if_statement; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:ReflectIn; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:octet; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:reflect; 47, argument_list; 47, 48; 47, 49; 48, identifier:octet; 49, integer:8; 50, for_statement; 50, 51; 50, 52; 50, 56; 51, identifier:i; 52, call; 52, 53; 52, 54; 53, identifier:range; 54, argument_list; 54, 55; 55, integer:8; 56, block; 56, 57; 56, 65; 56, 88; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:topbit; 60, binary_operator:&; 60, 61; 60, 62; 61, identifier:register; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:MSB_Mask; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:register; 68, binary_operator:|; 68, 69; 68, 78; 69, parenthesized_expression; 69, 70; 70, binary_operator:&; 70, 71; 70, 75; 71, parenthesized_expression; 71, 72; 72, binary_operator:<<; 72, 73; 72, 74; 73, identifier:register; 74, integer:1; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:Mask; 78, parenthesized_expression; 78, 79; 79, binary_operator:&; 79, 80; 79, 87; 80, parenthesized_expression; 80, 81; 81, binary_operator:>>; 81, 82; 81, 83; 82, identifier:octet; 83, parenthesized_expression; 83, 84; 84, binary_operator:-; 84, 85; 84, 86; 85, integer:7; 86, identifier:i; 87, integer:0x01; 88, if_statement; 88, 89; 88, 90; 89, identifier:topbit; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, augmented_assignment:^=; 92, 93; 92, 94; 93, identifier:register; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:Poly; 97, for_statement; 97, 98; 97, 99; 97, 105; 98, identifier:i; 99, call; 99, 100; 99, 101; 100, identifier:range; 101, argument_list; 101, 102; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:Width; 105, block; 105, 106; 105, 114; 105, 126; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:topbit; 109, binary_operator:&; 109, 110; 109, 111; 110, identifier:register; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:MSB_Mask; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:register; 117, parenthesized_expression; 117, 118; 118, binary_operator:&; 118, 119; 118, 123; 119, parenthesized_expression; 119, 120; 120, binary_operator:<<; 120, 121; 120, 122; 121, identifier:register; 122, integer:1; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:Mask; 126, if_statement; 126, 127; 126, 128; 127, identifier:topbit; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, augmented_assignment:^=; 130, 131; 130, 132; 131, identifier:register; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:Poly; 135, if_statement; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:ReflectOut; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:register; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:reflect; 147, argument_list; 147, 148; 147, 149; 148, identifier:register; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:Width; 152, return_statement; 152, 153; 153, binary_operator:^; 153, 154; 153, 155; 154, identifier:register; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:XorOut | def bit_by_bit(self, in_data):
if isinstance(in_data, str):
in_data = [ord(c) for c in in_data]
register = self.NonDirectInit
for octet in in_data:
if self.ReflectIn:
octet = self.reflect(octet, 8)
for i in range(8):
topbit = register & self.MSB_Mask
register = ((register << 1) & self.Mask) | ((octet >> (7 - i)) & 0x01)
if topbit:
register ^= self.Poly
for i in range(self.Width):
topbit = register & self.MSB_Mask
register = ((register << 1) & self.Mask)
if topbit:
register ^= self.Poly
if self.ReflectOut:
register = self.reflect(register, self.Width)
return register ^ self.XorOut |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:parse_ggKbase_tables; 3, parameters; 3, 4; 3, 5; 4, identifier:tables; 5, identifier:id_type; 6, block; 6, 7; 6, 11; 6, 232; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:g2info; 10, dictionary; 11, for_statement; 11, 12; 11, 13; 11, 14; 12, identifier:table; 13, identifier:tables; 14, block; 14, 15; 15, for_statement; 15, 16; 15, 17; 15, 21; 16, identifier:line; 17, call; 17, 18; 17, 19; 18, identifier:open; 19, argument_list; 19, 20; 20, identifier:table; 21, block; 21, 22; 21, 35; 21, 62; 21, 76; 21, 87; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:line; 25, call; 25, 26; 25, 33; 26, attribute; 26, 27; 26, 32; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:line; 30, identifier:strip; 31, argument_list; 32, identifier:split; 33, argument_list; 33, 34; 34, string:'\t'; 35, if_statement; 35, 36; 35, 44; 36, call; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, subscript; 38, 39; 38, 40; 39, identifier:line; 40, integer:0; 41, identifier:startswith; 42, argument_list; 42, 43; 43, string:'name'; 44, block; 44, 45; 44, 49; 44, 55; 44, 61; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:header; 48, identifier:line; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 54; 51, subscript; 51, 52; 51, 53; 52, identifier:header; 53, integer:4; 54, string:'genome size (bp)'; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 60; 57, subscript; 57, 58; 57, 59; 58, identifier:header; 59, integer:12; 60, string:'
header[13] = '; 61, continue_statement; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 68; 64, pattern_list; 64, 65; 64, 66; 64, 67; 65, identifier:name; 66, identifier:code; 67, identifier:info; 68, expression_list; 68, 69; 68, 72; 68, 75; 69, subscript; 69, 70; 69, 71; 70, identifier:line; 71, integer:0; 72, subscript; 72, 73; 72, 74; 73, identifier:line; 74, integer:1; 75, identifier:line; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:info; 79, list_comprehension; 79, 80; 79, 84; 80, call; 80, 81; 80, 82; 81, identifier:to_int; 82, argument_list; 82, 83; 83, identifier:i; 84, for_in_clause; 84, 85; 84, 86; 85, identifier:i; 86, identifier:info; 87, if_statement; 87, 88; 87, 91; 87, 167; 88, comparison_operator:is; 88, 89; 88, 90; 89, identifier:id_type; 90, False; 91, block; 91, 92; 91, 105; 91, 144; 92, if_statement; 92, 93; 92, 100; 93, boolean_operator:or; 93, 94; 93, 97; 94, comparison_operator:in; 94, 95; 94, 96; 95, string:'UNK'; 96, identifier:code; 97, comparison_operator:in; 97, 98; 97, 99; 98, string:'unknown'; 99, identifier:code; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:code; 104, identifier:name; 105, if_statement; 105, 106; 105, 117; 105, 143; 106, boolean_operator:and; 106, 107; 106, 111; 107, parenthesized_expression; 107, 108; 108, comparison_operator:!=; 108, 109; 108, 110; 109, identifier:name; 110, identifier:code; 111, parenthesized_expression; 111, 112; 112, boolean_operator:and; 112, 113; 112, 114; 113, identifier:name; 114, comparison_operator:in; 114, 115; 114, 116; 115, identifier:code; 116, identifier:g2info; 117, ERROR; 117, 118; 117, 123; 117, 130; 118, call; 118, 119; 118, 120; 118, 122; 119, string:'
print('; 120, ERROR; 120, 121; 121, identifier:exit; 122, argument_list; 123, ERROR; 123, 124; 123, 127; 124, comparison_operator:not; 124, 125; 124, 126; 125, identifier:name; 126, identifier:g2info; 127, subscript; 127, 128; 127, 129; 128, identifier:g2info; 129, identifier:name; 130, dictionary_comprehension; 130, 131; 130, 134; 131, pair; 131, 132; 131, 133; 132, identifier:item; 133, identifier:stat; 134, for_in_clause; 134, 135; 134, 138; 135, pattern_list; 135, 136; 135, 137; 136, identifier:item; 137, identifier:stat; 138, call; 138, 139; 138, 140; 139, identifier:zip; 140, argument_list; 140, 141; 140, 142; 141, identifier:header; 142, identifier:info; 143, block:; 144, if_statement; 144, 145; 144, 148; 145, comparison_operator:not; 145, 146; 145, 147; 146, identifier:code; 147, identifier:g2info; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 154; 151, subscript; 151, 152; 151, 153; 152, identifier:g2info; 153, identifier:code; 154, dictionary_comprehension; 154, 155; 154, 158; 155, pair; 155, 156; 155, 157; 156, identifier:item; 157, identifier:stat; 158, for_in_clause; 158, 159; 158, 162; 159, pattern_list; 159, 160; 159, 161; 160, identifier:item; 161, identifier:stat; 162, call; 162, 163; 162, 164; 163, identifier:zip; 164, argument_list; 164, 165; 164, 166; 165, identifier:header; 166, identifier:info; 167, else_clause; 167, 168; 168, block; 168, 169; 169, if_statement; 169, 170; 169, 173; 169, 178; 169, 187; 170, comparison_operator:==; 170, 171; 170, 172; 171, identifier:id_type; 172, string:'name'; 173, block; 173, 174; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:ID; 177, identifier:name; 178, elif_clause; 178, 179; 178, 182; 179, comparison_operator:==; 179, 180; 179, 181; 180, identifier:id_type; 181, string:'code'; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:ID; 186, identifier:code; 187, else_clause; 187, 188; 187, 231; 188, ERROR; 188, 189; 188, 204; 188, 217; 188, 230; 189, ERROR; 189, 190; 189, 193; 189, 194; 189, 201; 190, call; 190, 191; 190, 192; 191, identifier:exit; 192, argument_list; 193, identifier:ID; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:ID; 197, identifier:replace; 198, argument_list; 198, 199; 198, 200; 199, string:' '; 200, string:''; 201, subscript; 201, 202; 201, 203; 202, identifier:g2info; 203, identifier:ID; 204, dictionary_comprehension; 204, 205; 204, 208; 205, pair; 205, 206; 205, 207; 206, identifier:item; 207, identifier:stat; 208, for_in_clause; 208, 209; 208, 212; 209, pattern_list; 209, 210; 209, 211; 210, identifier:item; 211, identifier:stat; 212, call; 212, 213; 212, 214; 213, identifier:zip; 214, argument_list; 214, 215; 214, 216; 215, identifier:header; 216, identifier:info; 217, ERROR; 217, 218; 217, 225; 218, comparison_operator:==; 218, 219; 218, 224; 219, subscript; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:g2info; 222, identifier:ID; 223, string:'genome size (bp)'; 224, string:''; 225, subscript; 225, 226; 225, 229; 226, subscript; 226, 227; 226, 228; 227, identifier:g2info; 228, identifier:ID; 229, string:'genome size (bp)'; 230, integer:0; 231, block:; 232, return_statement; 232, 233; 233, identifier:g2info | def parse_ggKbase_tables(tables, id_type):
g2info = {}
for table in tables:
for line in open(table):
line = line.strip().split('\t')
if line[0].startswith('name'):
header = line
header[4] = 'genome size (bp)'
header[12] = '
header[13] = '
continue
name, code, info = line[0], line[1], line
info = [to_int(i) for i in info]
if id_type is False:
if 'UNK' in code or 'unknown' in code:
code = name
if (name != code) and (name and code in g2info):
print('
print('
exit()
if name not in g2info:
g2info[name] = {item:stat for item, stat in zip(header, info)}
if code not in g2info:
g2info[code] = {item:stat for item, stat in zip(header, info)}
else:
if id_type == 'name':
ID = name
elif id_type == 'code':
ID = code
else:
print('
exit()
ID = ID.replace(' ', '')
g2info[ID] = {item:stat for item, stat in zip(header, info)}
if g2info[ID]['genome size (bp)'] == '':
g2info[ID]['genome size (bp)'] = 0
return g2info |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:top_hits; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:hits; 5, identifier:num; 6, identifier:column; 7, identifier:reverse; 8, block; 8, 9; 8, 24; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:hits; 13, identifier:sort; 14, argument_list; 14, 15; 14, 21; 15, keyword_argument; 15, 16; 15, 17; 16, identifier:key; 17, call; 17, 18; 17, 19; 18, identifier:itemgetter; 19, argument_list; 19, 20; 20, identifier:column; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:reverse; 23, identifier:reverse; 24, for_statement; 24, 25; 24, 26; 24, 32; 25, identifier:hit; 26, subscript; 26, 27; 26, 28; 27, identifier:hits; 28, slice; 28, 29; 28, 30; 28, 31; 29, integer:0; 30, colon; 31, identifier:num; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, yield; 34, 35; 35, identifier:hit | def top_hits(hits, num, column, reverse):
hits.sort(key = itemgetter(column), reverse = reverse)
for hit in hits[0:num]:
yield hit |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:numBlast_sort; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:blast; 5, identifier:numHits; 6, identifier:evalueT; 7, identifier:bitT; 8, block; 8, 9; 8, 32; 8, 35; 8, 45; 8, 136; 8, 145; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:header; 12, list:['
'qstart', 'qend', 'tstart', 'tend', 'evalue', 'bitscore']; 12, 13; 12, 30; 13, concatenated_string; 13, 14; 13, 15; 13, 17; 13, 18; 13, 20; 13, 21; 13, 23; 13, 24; 13, 26; 13, 27; 13, 29; 14, string:'
'; 15, ERROR; 15, 16; 16, identifier:qstart; 17, string:', '; 18, ERROR; 18, 19; 19, identifier:qend; 20, string:', '; 21, ERROR; 21, 22; 22, identifier:tstart; 23, string:', '; 24, ERROR; 24, 25; 25, identifier:tend; 26, string:', '; 27, ERROR; 27, 28; 28, identifier:evalue; 29, string:', '; 30, ERROR; 30, 31; 31, identifier:bitscore; 32, expression_statement; 32, 33; 33, yield; 33, 34; 34, identifier:header; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:hmm; 38, dictionary_comprehension; 38, 39; 38, 42; 39, pair; 39, 40; 39, 41; 40, identifier:h; 41, list:[]; 42, for_in_clause; 42, 43; 42, 44; 43, identifier:h; 44, identifier:header; 45, for_statement; 45, 46; 45, 47; 45, 48; 46, identifier:line; 47, identifier:blast; 48, block; 48, 49; 48, 107; 48, 117; 49, if_statement; 49, 50; 49, 53; 49, 105; 50, attribute; 50, 51; 50, 52; 51, identifier:line; 52, identifier:startswith; 53, ERROR; 53, 54; 53, 56; 53, 72; 53, 76; 53, 82; 53, 88; 53, 90; 53, 95; 53, 98; 54, ERROR; 54, 55; 55, identifier:continue; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:line; 58, subscript; 58, 59; 58, 69; 58, 71; 59, call; 59, 60; 59, 67; 60, attribute; 60, 61; 60, 66; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:line; 64, identifier:strip; 65, argument_list; 66, identifier:split; 67, argument_list; 67, 68; 68, string:'\t'; 69, ERROR; 69, 70; 70, identifier:line; 71, integer:10; 72, ERROR; 72, 73; 73, subscript; 73, 74; 73, 75; 74, identifier:line; 75, integer:11; 76, call; 76, 77; 76, 78; 77, identifier:float; 78, argument_list; 78, 79; 79, subscript; 79, 80; 79, 81; 80, identifier:line; 81, integer:10; 82, call; 82, 83; 82, 84; 83, identifier:float; 84, argument_list; 84, 85; 85, subscript; 85, 86; 85, 87; 86, identifier:line; 87, integer:11; 88, ERROR; 88, 89; 89, identifier:evalue; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:bit; 92, subscript; 92, 93; 92, 94; 93, identifier:line; 94, integer:10; 95, subscript; 95, 96; 95, 97; 96, identifier:line; 97, integer:11; 98, boolean_operator:and; 98, 99; 98, 102; 99, comparison_operator:is; 99, 100; 99, 101; 100, identifier:evalueT; 101, False; 102, comparison_operator:>; 102, 103; 102, 104; 103, identifier:evalue; 104, identifier:evalueT; 105, block; 105, 106; 106, continue_statement; 107, if_statement; 107, 108; 107, 115; 108, boolean_operator:and; 108, 109; 108, 112; 109, comparison_operator:is; 109, 110; 109, 111; 110, identifier:bitT; 111, False; 112, comparison_operator:<; 112, 113; 112, 114; 113, identifier:bit; 114, identifier:bitT; 115, block; 115, 116; 116, continue_statement; 117, for_statement; 117, 118; 117, 121; 117, 126; 118, pattern_list; 118, 119; 118, 120; 119, identifier:i; 120, identifier:h; 121, call; 121, 122; 121, 123; 122, identifier:zip; 123, argument_list; 123, 124; 123, 125; 124, identifier:line; 125, identifier:header; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 134; 129, attribute; 129, 130; 129, 133; 130, subscript; 130, 131; 130, 132; 131, identifier:hmm; 132, identifier:h; 133, identifier:append; 134, argument_list; 134, 135; 135, identifier:i; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:hmm; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:pd; 142, identifier:DataFrame; 143, argument_list; 143, 144; 144, identifier:hmm; 145, for_statement; 145, 146; 145, 149; 145, 177; 146, pattern_list; 146, 147; 146, 148; 147, identifier:query; 148, identifier:df; 149, comparison_operator:in; 149, 150; 149, 164; 149, 167; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:hmm; 153, identifier:groupby; 154, argument_list; 154, 155; 154, 161; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:by; 157, list:['
df = df.sort_values(by = ['bitscore']; 157, 158; 157, 159; 158, string:'
df = df.sort_values(by = ['; 159, ERROR; 159, 160; 160, identifier:bitscore; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:ascending; 163, False; 164, ERROR; 164, 165; 164, 166; 165, identifier:for; 166, identifier:hit; 167, subscript; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, subscript; 169, 170; 169, 171; 170, identifier:df; 171, identifier:header; 172, identifier:values; 173, slice; 173, 174; 173, 175; 173, 176; 174, integer:0; 175, colon; 176, identifier:numHits; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, yield; 179, 180; 180, identifier:hit | def numBlast_sort(blast, numHits, evalueT, bitT):
header = ['
'qstart', 'qend', 'tstart', 'tend', 'evalue', 'bitscore']
yield header
hmm = {h:[] for h in header}
for line in blast:
if line.startswith('
continue
line = line.strip().split('\t')
line[10], line[11] = float(line[10]), float(line[11])
evalue, bit = line[10], line[11]
if evalueT is not False and evalue > evalueT:
continue
if bitT is not False and bit < bitT:
continue
for i, h in zip(line, header):
hmm[h].append(i)
hmm = pd.DataFrame(hmm)
for query, df in hmm.groupby(by = ['
df = df.sort_values(by = ['bitscore'], ascending = False)
for hit in df[header].values[0:numHits]:
yield hit |
0, module; 0, 1; 0, 64; 0, 67; 0, 75; 0, 267; 1, function_definition; 1, 2; 1, 3; 1, 9; 1, 47; 2, function_name:numDomtblout; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:domtblout; 5, identifier:numHits; 6, identifier:evalueT; 7, identifier:bitT; 8, identifier:sort; 9, ERROR; 9, 10; 9, 29; 9, 30; 9, 40; 9, 42; 9, 43; 9, 44; 9, 45; 9, 46; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:sort; 13, True; 14, block; 14, 15; 14, 28; 15, for_statement; 15, 16; 15, 17; 15, 24; 16, identifier:hit; 17, call; 17, 18; 17, 19; 18, identifier:numDomtblout_sort; 19, argument_list; 19, 20; 19, 21; 19, 22; 19, 23; 20, identifier:domtblout; 21, identifier:numHits; 22, identifier:evalueT; 23, identifier:bitT; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, yield; 26, 27; 27, identifier:hit; 28, return_statement; 29, identifier:header; 30, concatenated_string; 30, 31; 30, 32; 30, 35; 30, 36; 30, 39; 31, string:'
'; 32, ERROR; 32, 33; 32, 34; 33, identifier:query; 34, identifier:name; 35, string:', '; 36, ERROR; 36, 37; 36, 38; 37, identifier:query; 38, identifier:accession; 39, string:', '; 40, ERROR; 40, 41; 41, identifier:qlen; 42, string:'full E-value'; 43, string:'full score'; 44, string:'full bias'; 45, ERROR; 46, identifier:domain; 47, block; 47, 48; 47, 53; 47, 60; 48, expression_statement; 48, 49; 48, 50; 48, 51; 48, 52; 49, string:'domain c-Evalue'; 50, string:'domain i-Evalue'; 51, string:'domain score'; 52, string:'domain bias'; 53, expression_statement; 53, 54; 53, 55; 53, 56; 53, 57; 53, 58; 53, 59; 54, string:'hmm from'; 55, string:'hmm to'; 56, string:'seq from'; 57, string:'seq to'; 58, string:'env from'; 59, string:'env to'; 60, ERROR; 60, 61; 61, expression_statement; 61, 62; 61, 63; 62, string:'acc'; 63, string:'target description'; 64, expression_statement; 64, 65; 65, yield; 65, 66; 66, identifier:header; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 72; 69, pattern_list; 69, 70; 69, 71; 70, identifier:prev; 71, identifier:hits; 72, expression_list; 72, 73; 72, 74; 73, None; 74, list:[]; 75, for_statement; 75, 76; 75, 77; 75, 78; 76, identifier:line; 77, identifier:domtblout; 78, block; 78, 79; 78, 199; 78, 263; 79, if_statement; 79, 80; 79, 83; 79, 173; 80, attribute; 80, 81; 80, 82; 81, identifier:line; 82, identifier:startswith; 83, ERROR; 83, 84; 83, 86; 83, 134; 83, 138; 83, 144; 83, 150; 83, 152; 83, 157; 83, 164; 83, 167; 83, 169; 83, 170; 84, ERROR; 84, 85; 85, identifier:continue; 86, keyword_argument; 86, 87; 86, 88; 86, 123; 87, identifier:line; 88, ERROR; 88, 89; 88, 98; 88, 99; 88, 109; 88, 110; 88, 116; 88, 122; 89, call; 89, 90; 89, 97; 90, attribute; 90, 91; 90, 96; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:line; 94, identifier:strip; 95, argument_list; 96, identifier:split; 97, argument_list; 98, identifier:desc; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, string:' '; 102, identifier:join; 103, argument_list; 103, 104; 104, subscript; 104, 105; 104, 106; 105, identifier:line; 106, slice; 106, 107; 106, 108; 107, integer:18; 108, colon; 109, identifier:line; 110, subscript; 110, 111; 110, 112; 111, identifier:line; 112, slice; 112, 113; 112, 114; 112, 115; 113, integer:0; 114, colon; 115, integer:18; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:line; 119, identifier:append; 120, argument_list; 120, 121; 121, identifier:desc; 122, identifier:ID; 123, binary_operator:+; 123, 124; 123, 127; 124, subscript; 124, 125; 124, 126; 125, identifier:line; 126, integer:0; 127, subscript; 127, 128; 127, 131; 127, 133; 128, subscript; 128, 129; 128, 130; 129, identifier:line; 130, integer:9; 131, ERROR; 131, 132; 132, identifier:line; 133, integer:11; 134, ERROR; 134, 135; 135, subscript; 135, 136; 135, 137; 136, identifier:line; 137, integer:13; 138, call; 138, 139; 138, 140; 139, identifier:float; 140, argument_list; 140, 141; 141, subscript; 141, 142; 141, 143; 142, identifier:line; 143, integer:11; 144, call; 144, 145; 144, 146; 145, identifier:float; 146, argument_list; 146, 147; 147, subscript; 147, 148; 147, 149; 148, identifier:line; 149, integer:13; 150, ERROR; 150, 151; 151, identifier:evalue; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:bitscore; 154, subscript; 154, 155; 154, 156; 155, identifier:line; 156, integer:11; 157, subscript; 157, 158; 157, 161; 157, 163; 158, subscript; 158, 159; 158, 160; 159, identifier:line; 160, integer:13; 161, ERROR; 161, 162; 162, identifier:line; 163, integer:11; 164, subscript; 164, 165; 164, 166; 165, identifier:line; 166, integer:13; 167, ERROR; 167, 168; 168, identifier:evalue; 169, identifier:bitscore; 170, comparison_operator:!=; 170, 171; 170, 172; 171, identifier:ID; 172, identifier:prev; 173, block; 173, 174; 173, 195; 174, if_statement; 174, 175; 174, 181; 175, comparison_operator:>; 175, 176; 175, 180; 176, call; 176, 177; 176, 178; 177, identifier:len; 178, argument_list; 178, 179; 179, identifier:hits; 180, integer:0; 181, block; 181, 182; 182, for_statement; 182, 183; 182, 184; 182, 191; 183, identifier:hit; 184, call; 184, 185; 184, 186; 185, identifier:top_hits; 186, argument_list; 186, 187; 186, 188; 186, 189; 186, 190; 187, identifier:hits; 188, identifier:numHits; 189, integer:13; 190, True; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, yield; 193, 194; 194, identifier:hit; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:hits; 198, list:[]; 199, if_statement; 199, 200; 199, 207; 199, 215; 199, 231; 199, 247; 200, boolean_operator:and; 200, 201; 200, 204; 201, comparison_operator:==; 201, 202; 201, 203; 202, identifier:evalueT; 203, False; 204, comparison_operator:==; 204, 205; 204, 206; 205, identifier:bitT; 206, False; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:hits; 212, identifier:append; 213, argument_list; 213, 214; 214, identifier:line; 215, elif_clause; 215, 216; 215, 223; 216, boolean_operator:and; 216, 217; 216, 220; 217, comparison_operator:<=; 217, 218; 217, 219; 218, identifier:evalue; 219, identifier:evalueT; 220, comparison_operator:==; 220, 221; 220, 222; 221, identifier:bitT; 222, False; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:hits; 228, identifier:append; 229, argument_list; 229, 230; 230, identifier:line; 231, elif_clause; 231, 232; 231, 239; 232, boolean_operator:and; 232, 233; 232, 236; 233, comparison_operator:<=; 233, 234; 233, 235; 234, identifier:evalue; 235, identifier:evalueT; 236, comparison_operator:>=; 236, 237; 236, 238; 237, identifier:bit; 238, identifier:bitT; 239, block; 239, 240; 240, expression_statement; 240, 241; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:hits; 244, identifier:append; 245, argument_list; 245, 246; 246, identifier:line; 247, elif_clause; 247, 248; 247, 255; 248, boolean_operator:and; 248, 249; 248, 252; 249, comparison_operator:==; 249, 250; 249, 251; 250, identifier:evalueT; 251, False; 252, comparison_operator:>=; 252, 253; 252, 254; 253, identifier:bit; 254, identifier:bitT; 255, block; 255, 256; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:hits; 260, identifier:append; 261, argument_list; 261, 262; 262, identifier:line; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 266; 265, identifier:prev; 266, identifier:ID; 267, for_statement; 267, 268; 267, 269; 267, 276; 267, 281; 268, identifier:hit; 269, call; 269, 270; 269, 271; 270, identifier:top_hits; 271, argument_list; 271, 272; 271, 273; 271, 274; 271, 275; 272, identifier:hits; 273, identifier:numHits; 274, integer:13; 275, True; 276, ERROR; 276, 277; 277, block; 277, 278; 278, expression_statement; 278, 279; 279, yield; 279, 280; 280, identifier:hit; 281, block: | def numDomtblout(domtblout, numHits, evalueT, bitT, sort):
if sort is True:
for hit in numDomtblout_sort(domtblout, numHits, evalueT, bitT):
yield hit
return
header = ['
'query name', 'query accession', 'qlen',
'full E-value', 'full score', 'full bias',
'domain
'domain c-Evalue', 'domain i-Evalue', 'domain score', 'domain bias',
'hmm from', 'hmm to', 'seq from', 'seq to', 'env from', 'env to',
'acc', 'target description']
yield header
prev, hits = None, []
for line in domtblout:
if line.startswith('
continue
line = line.strip().split()
desc = ' '.join(line[18:])
line = line[0:18]
line.append(desc)
ID = line[0] + line[9]
line[11], line[13] = float(line[11]), float(line[13])
evalue, bitscore = line[11], line[13]
line[11], line[13] = evalue, bitscore
if ID != prev:
if len(hits) > 0:
for hit in top_hits(hits, numHits, 13, True):
yield hit
hits = []
if evalueT == False and bitT == False:
hits.append(line)
elif evalue <= evalueT and bitT == False:
hits.append(line)
elif evalue <= evalueT and bit >= bitT:
hits.append(line)
elif evalueT == False and bit >= bitT:
hits.append(line)
prev = ID
for hit in top_hits(hits, numHits, 13, True):
yield hit |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:compare_clades; 3, parameters; 3, 4; 4, identifier:pw; 5, block; 5, 6; 5, 20; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:names; 9, call; 9, 10; 9, 11; 10, identifier:sorted; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:set; 14, argument_list; 14, 15; 15, list_comprehension; 15, 16; 15, 17; 16, identifier:i; 17, for_in_clause; 17, 18; 17, 19; 18, identifier:i; 19, identifier:pw; 20, for_statement; 20, 21; 20, 22; 20, 27; 21, identifier:i; 22, call; 22, 23; 22, 24; 23, identifier:range; 24, argument_list; 24, 25; 24, 26; 25, integer:0; 26, integer:4; 27, block; 27, 28; 27, 36; 27, 218; 27, 260; 27, 264; 27, 310; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 33; 30, pattern_list; 30, 31; 30, 32; 31, identifier:wi; 32, identifier:bt; 33, expression_list; 33, 34; 33, 35; 34, dictionary; 35, dictionary; 36, for_statement; 36, 37; 36, 38; 36, 39; 37, identifier:a; 38, identifier:names; 39, block; 39, 40; 40, for_statement; 40, 41; 40, 42; 40, 45; 41, identifier:b; 42, subscript; 42, 43; 42, 44; 43, identifier:pw; 44, identifier:a; 45, block; 45, 46; 45, 56; 45, 64; 45, 86; 45, 154; 46, if_statement; 46, 47; 46, 54; 47, boolean_operator:or; 47, 48; 47, 51; 48, comparison_operator:not; 48, 49; 48, 50; 49, string:';'; 50, identifier:a; 51, comparison_operator:not; 51, 52; 51, 53; 52, string:';'; 53, identifier:b; 54, block; 54, 55; 55, continue_statement; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:pident; 59, subscript; 59, 60; 59, 63; 60, subscript; 60, 61; 60, 62; 61, identifier:pw; 62, identifier:a; 63, identifier:b; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 69; 66, pattern_list; 66, 67; 66, 68; 67, identifier:cA; 68, identifier:cB; 69, expression_list; 69, 70; 69, 78; 70, subscript; 70, 71; 70, 77; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:a; 74, identifier:split; 75, argument_list; 75, 76; 76, string:';'; 77, identifier:i; 78, subscript; 78, 79; 78, 85; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:b; 82, identifier:split; 83, argument_list; 83, 84; 84, string:';'; 85, identifier:i; 86, if_statement; 86, 87; 86, 98; 86, 123; 87, boolean_operator:and; 87, 88; 87, 95; 88, boolean_operator:and; 88, 89; 88, 92; 89, comparison_operator:==; 89, 90; 89, 91; 90, identifier:i; 91, integer:0; 92, comparison_operator:in; 92, 93; 92, 94; 93, string:'_'; 94, identifier:cA; 95, comparison_operator:in; 95, 96; 95, 97; 96, string:'_'; 97, identifier:cB; 98, block; 98, 99; 98, 111; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:cA; 102, subscript; 102, 103; 102, 110; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:cA; 106, identifier:rsplit; 107, argument_list; 107, 108; 107, 109; 108, string:'_'; 109, integer:1; 110, integer:1; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:cB; 114, subscript; 114, 115; 114, 122; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:cB; 118, identifier:rsplit; 119, argument_list; 119, 120; 119, 121; 120, string:'_'; 121, integer:1; 122, integer:1; 123, elif_clause; 123, 124; 123, 131; 124, boolean_operator:or; 124, 125; 124, 128; 125, comparison_operator:in; 125, 126; 125, 127; 126, string:'>'; 127, identifier:cA; 128, comparison_operator:in; 128, 129; 128, 130; 129, string:'>'; 130, identifier:cB; 131, block; 131, 132; 131, 143; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:cA; 135, subscript; 135, 136; 135, 142; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:cA; 139, identifier:split; 140, argument_list; 140, 141; 141, string:'>'; 142, integer:1; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:cB; 146, subscript; 146, 147; 146, 153; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:cB; 150, identifier:split; 151, argument_list; 151, 152; 152, string:'>'; 153, integer:1; 154, if_statement; 154, 155; 154, 158; 154, 179; 155, comparison_operator:==; 155, 156; 155, 157; 156, identifier:cA; 157, identifier:cB; 158, block; 158, 159; 158, 170; 159, if_statement; 159, 160; 159, 163; 160, comparison_operator:not; 160, 161; 160, 162; 161, identifier:cA; 162, identifier:wi; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 169; 166, subscript; 166, 167; 166, 168; 167, identifier:wi; 168, identifier:cA; 169, list:[]; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 177; 172, attribute; 172, 173; 172, 176; 173, subscript; 173, 174; 173, 175; 174, identifier:wi; 175, identifier:cA; 176, identifier:append; 177, argument_list; 177, 178; 178, identifier:pident; 179, else_clause; 179, 180; 180, block; 180, 181; 180, 192; 180, 207; 181, if_statement; 181, 182; 181, 185; 182, comparison_operator:not; 182, 183; 182, 184; 183, identifier:cA; 184, identifier:bt; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:bt; 190, identifier:cA; 191, dictionary; 192, if_statement; 192, 193; 192, 198; 193, comparison_operator:not; 193, 194; 193, 195; 194, identifier:cB; 195, subscript; 195, 196; 195, 197; 196, identifier:bt; 197, identifier:cA; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 206; 201, subscript; 201, 202; 201, 205; 202, subscript; 202, 203; 202, 204; 203, identifier:bt; 204, identifier:cA; 205, identifier:cB; 206, list:[]; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 216; 209, attribute; 209, 210; 209, 215; 210, subscript; 210, 211; 210, 214; 211, subscript; 211, 212; 211, 213; 212, identifier:bt; 213, identifier:cA; 214, identifier:cB; 215, identifier:append; 216, argument_list; 216, 217; 217, identifier:pident; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 219, 236; 220, identifier:print; 221, ERROR; 221, 222; 221, 225; 221, 226; 222, ERROR; 222, 223; 222, 224; 223, escape_sequence:\n; 224, identifier:for; 225, identifier:clade; 226, comparison_operator:in; 226, 227; 226, 228; 227, identifier:pidents; 228, call; 228, 229; 228, 230; 229, identifier:list; 230, argument_list; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:wi; 234, identifier:items; 235, argument_list; 236, type; 236, 237; 237, call; 237, 238; 237, 239; 238, identifier:print; 239, argument_list; 239, 240; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, string:'\t'; 243, identifier:join; 244, argument_list; 244, 245; 245, list:['wi:%s' % str(i), clade, str(min(pidents))]; 245, 246; 245, 252; 245, 253; 246, binary_operator:%; 246, 247; 246, 248; 247, string:'wi:%s'; 248, call; 248, 249; 248, 250; 249, identifier:str; 250, argument_list; 250, 251; 251, identifier:i; 252, identifier:clade; 253, call; 253, 254; 253, 255; 254, identifier:str; 255, argument_list; 255, 256; 256, call; 256, 257; 256, 258; 257, identifier:min; 258, argument_list; 258, 259; 259, identifier:pidents; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:comps; 263, list:[]; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 265, 277; 265, 279; 266, identifier:print; 267, ERROR; 267, 268; 267, 271; 268, ERROR; 268, 269; 268, 270; 269, escape_sequence:\n; 270, identifier:for; 271, comparison_operator:in; 271, 272; 271, 273; 272, identifier:comp; 273, call; 273, 274; 273, 275; 274, identifier:print_pairwise; 275, argument_list; 275, 276; 276, identifier:bt; 277, ERROR; 277, 278; 278, identifier:if; 279, type; 279, 280; 280, constrained_type; 280, 281; 280, 285; 281, type; 281, 282; 282, comparison_operator:is; 282, 283; 282, 284; 283, identifier:comp; 284, None; 285, type; 285, 286; 286, call; 286, 287; 286, 288; 287, identifier:print; 288, argument_list; 288, 289; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, string:'\t'; 292, identifier:join; 293, argument_list; 293, 294; 294, binary_operator:+; 294, 295; 294, 302; 295, list:['bt:%s' % str(i)]; 295, 296; 296, binary_operator:%; 296, 297; 296, 298; 297, string:'bt:%s'; 298, call; 298, 299; 298, 300; 299, identifier:str; 300, argument_list; 300, 301; 301, identifier:i; 302, list_comprehension; 302, 303; 302, 307; 303, call; 303, 304; 303, 305; 304, identifier:str; 305, argument_list; 305, 306; 306, identifier:j; 307, for_in_clause; 307, 308; 307, 309; 308, identifier:j; 309, identifier:comp; 310, ERROR; 310, 311; 310, 314; 310, 315; 310, 316; 310, 320; 310, 322; 310, 323; 310, 338; 310, 340; 310, 343; 310, 367; 311, subscript; 311, 312; 311, 313; 312, identifier:comp; 313, integer:0; 314, string:'
comps.extend([j for j in comp[1:] if j != '; 315, ERROR; 316, call; 316, 317; 316, 318; 317, identifier:print_comps; 318, argument_list; 318, 319; 319, identifier:comps; 320, ERROR; 320, 321; 321, identifier:comps; 322, ERROR; 323, call; 323, 324; 323, 325; 324, identifier:print; 325, argument_list; 325, 326; 325, 329; 326, ERROR; 326, 327; 326, 328; 327, escape_sequence:\n; 328, identifier:for; 329, comparison_operator:in; 329, 330; 329, 331; 330, identifier:comp; 331, call; 331, 332; 331, 333; 332, identifier:print_pairwise; 333, argument_list; 333, 334; 333, 335; 334, identifier:bt; 335, keyword_argument; 335, 336; 335, 337; 336, identifier:median; 337, True; 338, ERROR; 338, 339; 339, identifier:if; 340, comparison_operator:is; 340, 341; 340, 342; 341, identifier:comp; 342, None; 343, call; 343, 344; 343, 345; 344, identifier:print; 345, argument_list; 345, 346; 346, call; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, string:'\t'; 349, identifier:join; 350, argument_list; 350, 351; 351, binary_operator:+; 351, 352; 351, 359; 352, list:['bt:%s' % str(i)]; 352, 353; 353, binary_operator:%; 353, 354; 353, 355; 354, string:'bt:%s'; 355, call; 355, 356; 355, 357; 356, identifier:str; 357, argument_list; 357, 358; 358, identifier:i; 359, list_comprehension; 359, 360; 359, 364; 360, call; 360, 361; 360, 362; 361, identifier:str; 362, argument_list; 362, 363; 363, identifier:j; 364, for_in_clause; 364, 365; 364, 366; 365, identifier:j; 366, identifier:comp; 367, comparison_operator:!=; 367, 368; 367, 371; 368, subscript; 368, 369; 368, 370; 369, identifier:comp; 370, integer:0; 371, binary_operator:-; 371, 372; 371, 373; 371, 374; 372, string:'
comps.extend([j for j in comp[1:] if j != '; 373, ERROR; 374, call; 374, 375; 374, 376; 375, identifier:print_comps; 376, argument_list; 376, 377; 377, identifier:comps | def compare_clades(pw):
names = sorted(set([i for i in pw]))
for i in range(0, 4):
wi, bt = {}, {}
for a in names:
for b in pw[a]:
if ';' not in a or ';' not in b:
continue
pident = pw[a][b]
cA, cB = a.split(';')[i], b.split(';')[i]
if i == 0 and '_' in cA and '_' in cB:
cA = cA.rsplit('_', 1)[1]
cB = cB.rsplit('_', 1)[1]
elif '>' in cA or '>' in cB:
cA = cA.split('>')[1]
cB = cB.split('>')[1]
if cA == cB:
if cA not in wi:
wi[cA] = []
wi[cA].append(pident)
else:
if cA not in bt:
bt[cA] = {}
if cB not in bt[cA]:
bt[cA][cB] = []
bt[cA][cB].append(pident)
print('\n
for clade, pidents in list(wi.items()):
print('\t'.join(['wi:%s' % str(i), clade, str(min(pidents))]))
comps = []
print('\n
for comp in print_pairwise(bt):
if comp is not None:
print('\t'.join(['bt:%s' % str(i)] + [str(j) for j in comp]))
if comp[0] != '
comps.extend([j for j in comp[1:] if j != '-'])
print_comps(comps)
comps = []
print('\n
for comp in print_pairwise(bt, median = True):
if comp is not None:
print('\t'.join(['bt:%s' % str(i)] + [str(j) for j in comp]))
if comp[0] != '
comps.extend([j for j in comp[1:] if j != '-'])
print_comps(comps) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:searchAccession; 3, parameters; 3, 4; 4, identifier:acc; 5, block; 5, 6; 5, 16; 5, 91; 5, 101; 5, 176; 5, 186; 5, 261; 5, 292; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 11; 8, pattern_list; 8, 9; 8, 10; 9, identifier:out; 10, identifier:error; 11, call; 11, 12; 11, 13; 12, identifier:entrez; 13, argument_list; 13, 14; 13, 15; 14, string:'genome'; 15, identifier:acc; 16, for_statement; 16, 17; 16, 18; 16, 23; 17, identifier:line; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:out; 21, identifier:splitlines; 22, argument_list; 23, block; 23, 24; 23, 37; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:line; 27, call; 27, 28; 27, 36; 28, attribute; 28, 29; 28, 35; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:line; 32, identifier:decode; 33, argument_list; 33, 34; 34, string:'ascii'; 35, identifier:strip; 36, argument_list; 37, if_statement; 37, 38; 37, 45; 38, boolean_operator:or; 38, 39; 38, 42; 39, comparison_operator:in; 39, 40; 39, 41; 40, string:'Assembly_Accession'; 41, identifier:line; 42, comparison_operator:in; 42, 43; 42, 44; 43, string:'BioSample'; 44, identifier:line; 45, block; 45, 46; 45, 78; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:newAcc; 49, subscript; 49, 50; 49, 77; 50, call; 50, 51; 50, 75; 51, attribute; 51, 52; 51, 74; 52, subscript; 52, 53; 52, 73; 53, call; 53, 54; 53, 71; 54, attribute; 54, 55; 54, 70; 55, subscript; 55, 56; 55, 69; 56, call; 56, 57; 56, 67; 57, attribute; 57, 58; 57, 66; 58, subscript; 58, 59; 58, 65; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:line; 62, identifier:split; 63, argument_list; 63, 64; 64, string:'>'; 65, integer:1; 66, identifier:split; 67, argument_list; 67, 68; 68, string:'<'; 69, integer:0; 70, identifier:split; 71, argument_list; 71, 72; 72, string:'.'; 73, integer:0; 74, identifier:split; 75, argument_list; 75, 76; 76, string:','; 77, integer:0; 78, if_statement; 78, 79; 78, 85; 79, comparison_operator:>; 79, 80; 79, 84; 80, call; 80, 81; 80, 82; 81, identifier:len; 82, argument_list; 82, 83; 83, identifier:newAcc; 84, integer:0; 85, block; 85, 86; 86, return_statement; 86, 87; 87, tuple; 87, 88; 87, 89; 87, 90; 88, True; 89, identifier:acc; 90, identifier:newAcc; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, pattern_list; 93, 94; 93, 95; 94, identifier:out; 95, identifier:error; 96, call; 96, 97; 96, 98; 97, identifier:entrez; 98, argument_list; 98, 99; 98, 100; 99, string:'nucleotide'; 100, identifier:acc; 101, for_statement; 101, 102; 101, 103; 101, 108; 102, identifier:line; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:out; 106, identifier:splitlines; 107, argument_list; 108, block; 108, 109; 108, 122; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:line; 112, call; 112, 113; 112, 121; 113, attribute; 113, 114; 113, 120; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:line; 117, identifier:decode; 118, argument_list; 118, 119; 119, string:'ascii'; 120, identifier:strip; 121, argument_list; 122, if_statement; 122, 123; 122, 130; 123, boolean_operator:or; 123, 124; 123, 127; 124, comparison_operator:in; 124, 125; 124, 126; 125, string:'Assembly_Accession'; 126, identifier:line; 127, comparison_operator:in; 127, 128; 127, 129; 128, string:'BioSample'; 129, identifier:line; 130, block; 130, 131; 130, 163; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:newAcc; 134, subscript; 134, 135; 134, 162; 135, call; 135, 136; 135, 160; 136, attribute; 136, 137; 136, 159; 137, subscript; 137, 138; 137, 158; 138, call; 138, 139; 138, 156; 139, attribute; 139, 140; 139, 155; 140, subscript; 140, 141; 140, 154; 141, call; 141, 142; 141, 152; 142, attribute; 142, 143; 142, 151; 143, subscript; 143, 144; 143, 150; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:line; 147, identifier:split; 148, argument_list; 148, 149; 149, string:'>'; 150, integer:1; 151, identifier:split; 152, argument_list; 152, 153; 153, string:'<'; 154, integer:0; 155, identifier:split; 156, argument_list; 156, 157; 157, string:'.'; 158, integer:0; 159, identifier:split; 160, argument_list; 160, 161; 161, string:','; 162, integer:0; 163, if_statement; 163, 164; 163, 170; 164, comparison_operator:>; 164, 165; 164, 169; 165, call; 165, 166; 165, 167; 166, identifier:len; 167, argument_list; 167, 168; 168, identifier:newAcc; 169, integer:0; 170, block; 170, 171; 171, return_statement; 171, 172; 172, tuple; 172, 173; 172, 174; 172, 175; 173, True; 174, identifier:acc; 175, identifier:newAcc; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 181; 178, pattern_list; 178, 179; 178, 180; 179, identifier:out; 180, identifier:error; 181, call; 181, 182; 181, 183; 182, identifier:entrez; 183, argument_list; 183, 184; 183, 185; 184, string:'assembly'; 185, identifier:acc; 186, for_statement; 186, 187; 186, 188; 186, 193; 187, identifier:line; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:out; 191, identifier:splitlines; 192, argument_list; 193, block; 193, 194; 193, 207; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:line; 197, call; 197, 198; 197, 206; 198, attribute; 198, 199; 198, 205; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:line; 202, identifier:decode; 203, argument_list; 203, 204; 204, string:'ascii'; 205, identifier:strip; 206, argument_list; 207, if_statement; 207, 208; 207, 215; 208, boolean_operator:or; 208, 209; 208, 212; 209, comparison_operator:in; 209, 210; 209, 211; 210, string:'Assembly_Accession'; 211, identifier:line; 212, comparison_operator:in; 212, 213; 212, 214; 213, string:'BioSample'; 214, identifier:line; 215, block; 215, 216; 215, 248; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:newAcc; 219, subscript; 219, 220; 219, 247; 220, call; 220, 221; 220, 245; 221, attribute; 221, 222; 221, 244; 222, subscript; 222, 223; 222, 243; 223, call; 223, 224; 223, 241; 224, attribute; 224, 225; 224, 240; 225, subscript; 225, 226; 225, 239; 226, call; 226, 227; 226, 237; 227, attribute; 227, 228; 227, 236; 228, subscript; 228, 229; 228, 235; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:line; 232, identifier:split; 233, argument_list; 233, 234; 234, string:'>'; 235, integer:1; 236, identifier:split; 237, argument_list; 237, 238; 238, string:'<'; 239, integer:0; 240, identifier:split; 241, argument_list; 241, 242; 242, string:'.'; 243, integer:0; 244, identifier:split; 245, argument_list; 245, 246; 246, string:','; 247, integer:0; 248, if_statement; 248, 249; 248, 255; 249, comparison_operator:>; 249, 250; 249, 254; 250, call; 250, 251; 250, 252; 251, identifier:len; 252, argument_list; 252, 253; 253, identifier:newAcc; 254, integer:0; 255, block; 255, 256; 256, return_statement; 256, 257; 257, tuple; 257, 258; 257, 259; 257, 260; 258, True; 259, identifier:acc; 260, identifier:newAcc; 261, for_statement; 261, 262; 261, 263; 261, 268; 262, identifier:error; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:error; 266, identifier:splitlines; 267, argument_list; 268, block; 268, 269; 268, 282; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:error; 272, call; 272, 273; 272, 281; 273, attribute; 273, 274; 273, 280; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:error; 277, identifier:decode; 278, argument_list; 278, 279; 279, string:'ascii'; 280, identifier:strip; 281, argument_list; 282, if_statement; 282, 283; 282, 286; 283, comparison_operator:in; 283, 284; 283, 285; 284, string:'500 Can'; 285, identifier:error; 286, block; 286, 287; 287, return_statement; 287, 288; 288, tuple; 288, 289; 288, 290; 288, 291; 289, False; 290, identifier:acc; 291, string:'no network'; 292, return_statement; 292, 293; 293, tuple; 293, 294; 293, 295; 293, 296; 294, False; 295, identifier:acc; 296, string:'efetch failed' | def searchAccession(acc):
out, error = entrez('genome', acc)
for line in out.splitlines():
line = line.decode('ascii').strip()
if 'Assembly_Accession' in line or 'BioSample' in line:
newAcc = line.split('>')[1].split('<')[0].split('.')[0].split(',')[0]
if len(newAcc) > 0:
return (True, acc, newAcc)
out, error = entrez('nucleotide', acc)
for line in out.splitlines():
line = line.decode('ascii').strip()
if 'Assembly_Accession' in line or 'BioSample' in line:
newAcc = line.split('>')[1].split('<')[0].split('.')[0].split(',')[0]
if len(newAcc) > 0:
return (True, acc, newAcc)
out, error = entrez('assembly', acc)
for line in out.splitlines():
line = line.decode('ascii').strip()
if 'Assembly_Accession' in line or 'BioSample' in line:
newAcc = line.split('>')[1].split('<')[0].split('.')[0].split(',')[0]
if len(newAcc) > 0:
return (True, acc, newAcc)
for error in error.splitlines():
error = error.decode('ascii').strip()
if '500 Can' in error:
return (False, acc, 'no network')
return (False, acc, 'efetch failed') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:_configure_logger; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, identifier:fmt; 5, identifier:quiet; 6, identifier:level; 7, identifier:fpath; 8, identifier:pre_hooks; 9, identifier:post_hooks; 10, identifier:metric_grouping_interval; 11, block; 11, 12; 11, 24; 11, 26; 11, 30; 11, 57; 11, 63; 11, 77; 11, 87; 11, 96; 11, 102; 11, 125; 11, 141; 11, 157; 11, 164; 11, 178; 11, 182; 11, 194; 11, 210; 11, 218; 11, 236; 11, 245; 11, 272; 11, 280; 11, 289; 11, 296; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:level; 15, call; 15, 16; 15, 17; 16, identifier:getattr; 17, argument_list; 17, 18; 17, 19; 18, identifier:logging; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:level; 22, identifier:upper; 23, argument_list; 24, global_statement; 24, 25; 25, identifier:_GLOBAL_LOG_CONFIGURED; 26, if_statement; 26, 27; 26, 28; 27, identifier:_GLOBAL_LOG_CONFIGURED; 28, block; 28, 29; 29, return_statement; 30, function_definition; 30, 31; 30, 32; 30, 34; 31, function_name:wrap_hook; 32, parameters; 32, 33; 33, identifier:fn; 34, block; 34, 35; 34, 55; 35, decorated_definition; 35, 36; 35, 41; 36, decorator; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:wraps; 39, argument_list; 39, 40; 40, identifier:fn; 41, function_definition; 41, 42; 41, 43; 41, 47; 42, function_name:processor; 43, parameters; 43, 44; 43, 45; 43, 46; 44, identifier:logger; 45, identifier:method_name; 46, identifier:event_dict; 47, block; 47, 48; 47, 53; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:fn; 51, argument_list; 51, 52; 52, identifier:event_dict; 53, return_statement; 53, 54; 54, identifier:event_dict; 55, return_statement; 55, 56; 56, identifier:processor; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:processors; 60, call; 60, 61; 60, 62; 61, identifier:define_log_processors; 62, argument_list; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:processors; 67, identifier:extend; 68, argument_list; 68, 69; 69, list_comprehension; 69, 70; 69, 74; 70, call; 70, 71; 70, 72; 71, identifier:wrap_hook; 72, argument_list; 72, 73; 73, identifier:h; 74, for_in_clause; 74, 75; 74, 76; 75, identifier:h; 76, identifier:pre_hooks; 77, if_statement; 77, 78; 77, 79; 78, identifier:metric_grouping_interval; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:processors; 84, identifier:append; 85, argument_list; 85, 86; 86, identifier:metrics_grouping_processor; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:log_renderer; 90, call; 90, 91; 90, 92; 91, identifier:define_log_renderer; 92, argument_list; 92, 93; 92, 94; 92, 95; 93, identifier:fmt; 94, identifier:fpath; 95, identifier:quiet; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:stderr_required; 99, parenthesized_expression; 99, 100; 100, not_operator; 100, 101; 101, identifier:quiet; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:pretty_to_stderr; 105, parenthesized_expression; 105, 106; 106, boolean_operator:and; 106, 107; 106, 108; 107, identifier:stderr_required; 108, parenthesized_expression; 108, 109; 109, boolean_operator:or; 109, 110; 109, 113; 110, comparison_operator:==; 110, 111; 110, 112; 111, identifier:fmt; 112, string:"pretty"; 113, parenthesized_expression; 113, 114; 114, boolean_operator:and; 114, 115; 114, 118; 115, comparison_operator:is; 115, 116; 115, 117; 116, identifier:fmt; 117, None; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:sys; 122, identifier:stderr; 123, identifier:isatty; 124, argument_list; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:should_inject_pretty_renderer; 128, parenthesized_expression; 128, 129; 129, boolean_operator:and; 129, 130; 129, 131; 130, identifier:pretty_to_stderr; 131, not_operator; 131, 132; 132, call; 132, 133; 132, 134; 133, identifier:isinstance; 134, argument_list; 134, 135; 134, 136; 135, identifier:log_renderer; 136, attribute; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:structlog; 139, identifier:dev; 140, identifier:ConsoleRenderer; 141, if_statement; 141, 142; 141, 143; 142, identifier:should_inject_pretty_renderer; 143, block; 143, 144; 143, 148; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:stderr_required; 147, False; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:processors; 152, identifier:append; 153, argument_list; 153, 154; 154, call; 154, 155; 154, 156; 155, identifier:StderrConsoleRenderer; 156, argument_list; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:processors; 161, identifier:append; 162, argument_list; 162, 163; 163, identifier:log_renderer; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:processors; 168, identifier:extend; 169, argument_list; 169, 170; 170, list_comprehension; 170, 171; 170, 175; 171, call; 171, 172; 171, 173; 172, identifier:wrap_hook; 173, argument_list; 173, 174; 174, identifier:h; 175, for_in_clause; 175, 176; 175, 177; 176, identifier:h; 177, identifier:post_hooks; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:streams; 181, list:[]; 182, if_statement; 182, 183; 182, 184; 183, identifier:stderr_required; 184, block; 184, 185; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:streams; 189, identifier:append; 190, argument_list; 190, 191; 191, attribute; 191, 192; 191, 193; 192, identifier:sys; 193, identifier:stderr; 194, if_statement; 194, 195; 194, 198; 195, comparison_operator:is; 195, 196; 195, 197; 196, identifier:fpath; 197, None; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:streams; 203, identifier:append; 204, argument_list; 204, 205; 205, call; 205, 206; 205, 207; 206, identifier:open; 207, argument_list; 207, 208; 207, 209; 208, identifier:fpath; 209, string:'a'; 210, assert_statement; 210, 211; 210, 217; 211, comparison_operator:!=; 211, 212; 211, 216; 212, call; 212, 213; 212, 214; 213, identifier:len; 214, argument_list; 214, 215; 215, identifier:streams; 216, integer:0; 217, string:"cannot configure logger for 0 streams"; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:stream; 221, conditional_expression:if; 221, 222; 221, 225; 221, 231; 222, subscript; 222, 223; 222, 224; 223, identifier:streams; 224, integer:0; 225, comparison_operator:==; 225, 226; 225, 230; 226, call; 226, 227; 226, 228; 227, identifier:len; 228, argument_list; 228, 229; 229, identifier:streams; 230, integer:1; 231, call; 231, 232; 231, 233; 232, identifier:Stream; 233, argument_list; 233, 234; 234, list_splat; 234, 235; 235, identifier:streams; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:atexit; 240, identifier:register; 241, argument_list; 241, 242; 242, attribute; 242, 243; 242, 244; 243, identifier:stream; 244, identifier:close; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:structlog; 249, identifier:configure; 250, argument_list; 250, 251; 250, 254; 250, 257; 250, 266; 250, 269; 251, keyword_argument; 251, 252; 251, 253; 252, identifier:processors; 253, identifier:processors; 254, keyword_argument; 254, 255; 254, 256; 255, identifier:context_class; 256, identifier:dict; 257, keyword_argument; 257, 258; 257, 259; 258, identifier:logger_factory; 259, call; 259, 260; 259, 261; 260, identifier:LevelLoggerFactory; 261, argument_list; 261, 262; 261, 263; 262, identifier:stream; 263, keyword_argument; 263, 264; 263, 265; 264, identifier:level; 265, identifier:level; 266, keyword_argument; 266, 267; 266, 268; 267, identifier:wrapper_class; 268, identifier:BoundLevelLogger; 269, keyword_argument; 269, 270; 269, 271; 270, identifier:cache_logger_on_first_use; 271, True; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:stdlib_root_log; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:logging; 278, identifier:getLogger; 279, argument_list; 280, expression_statement; 280, 281; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:stdlib_root_log; 284, identifier:addHandler; 285, argument_list; 285, 286; 286, call; 286, 287; 286, 288; 287, identifier:StdlibStructlogHandler; 288, argument_list; 289, expression_statement; 289, 290; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:stdlib_root_log; 293, identifier:setLevel; 294, argument_list; 294, 295; 295, identifier:level; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 299; 298, identifier:_GLOBAL_LOG_CONFIGURED; 299, True | def _configure_logger(fmt, quiet, level, fpath,
pre_hooks, post_hooks, metric_grouping_interval):
level = getattr(logging, level.upper())
global _GLOBAL_LOG_CONFIGURED
if _GLOBAL_LOG_CONFIGURED:
return
def wrap_hook(fn):
@wraps(fn)
def processor(logger, method_name, event_dict):
fn(event_dict)
return event_dict
return processor
processors = define_log_processors()
processors.extend(
[ wrap_hook(h) for h in pre_hooks ]
)
if metric_grouping_interval:
processors.append(metrics_grouping_processor)
log_renderer = define_log_renderer(fmt, fpath, quiet)
stderr_required = (not quiet)
pretty_to_stderr = (
stderr_required
and (
fmt == "pretty"
or (fmt is None and sys.stderr.isatty())
)
)
should_inject_pretty_renderer = (
pretty_to_stderr
and not isinstance(log_renderer, structlog.dev.ConsoleRenderer)
)
if should_inject_pretty_renderer:
stderr_required = False
processors.append(StderrConsoleRenderer())
processors.append(log_renderer)
processors.extend(
[ wrap_hook(h) for h in post_hooks ]
)
streams = []
if stderr_required:
streams.append(sys.stderr)
if fpath is not None:
streams.append(open(fpath, 'a'))
assert len(streams) != 0, "cannot configure logger for 0 streams"
stream = streams[0] if len(streams) == 1 else Stream(*streams)
atexit.register(stream.close)
structlog.configure(
processors=processors,
context_class=dict,
logger_factory=LevelLoggerFactory(stream, level=level),
wrapper_class=BoundLevelLogger,
cache_logger_on_first_use=True,
)
stdlib_root_log = logging.getLogger()
stdlib_root_log.addHandler(StdlibStructlogHandler())
stdlib_root_log.setLevel(level)
_GLOBAL_LOG_CONFIGURED = True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:combine_modifiers; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:graphemes; 6, block; 6, 7; 6, 11; 6, 15; 6, 22; 6, 203; 6, 213; 6, 217; 6, 221; 6, 278; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:result; 10, list:[]; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:temp; 14, string:""; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:count; 18, call; 18, 19; 18, 20; 19, identifier:len; 20, argument_list; 20, 21; 21, identifier:graphemes; 22, for_statement; 22, 23; 22, 24; 22, 28; 23, identifier:grapheme; 24, call; 24, 25; 24, 26; 25, identifier:reversed; 26, argument_list; 26, 27; 27, identifier:graphemes; 28, block; 28, 29; 28, 33; 28, 85; 28, 119; 28, 190; 28, 199; 29, expression_statement; 29, 30; 30, augmented_assignment:-=; 30, 31; 30, 32; 31, identifier:count; 32, integer:1; 33, if_statement; 33, 34; 33, 60; 34, boolean_operator:and; 34, 35; 34, 50; 34, 51; 35, boolean_operator:and; 35, 36; 35, 42; 36, comparison_operator:==; 36, 37; 36, 41; 37, call; 37, 38; 37, 39; 38, identifier:len; 39, argument_list; 39, 40; 40, identifier:grapheme; 41, integer:1; 42, comparison_operator:==; 42, 43; 42, 49; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:unicodedata; 46, identifier:category; 47, argument_list; 47, 48; 48, identifier:grapheme; 49, string:"Lm"; 50, line_continuation:\; 51, not_operator; 51, 52; 52, comparison_operator:in; 52, 53; 52, 57; 53, call; 53, 54; 53, 55; 54, identifier:ord; 55, argument_list; 55, 56; 56, identifier:grapheme; 57, list:[712, 716]; 57, 58; 57, 59; 58, integer:712; 59, integer:716; 60, block; 60, 61; 60, 67; 60, 84; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:temp; 64, binary_operator:+; 64, 65; 64, 66; 65, identifier:grapheme; 66, identifier:temp; 67, if_statement; 67, 68; 67, 71; 68, comparison_operator:==; 68, 69; 68, 70; 69, identifier:count; 70, integer:0; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 78; 74, subscript; 74, 75; 74, 76; 75, identifier:result; 76, unary_operator:-; 76, 77; 77, integer:1; 78, binary_operator:+; 78, 79; 78, 80; 79, identifier:temp; 80, subscript; 80, 81; 80, 82; 81, identifier:result; 82, unary_operator:-; 82, 83; 83, integer:1; 84, continue_statement; 85, if_statement; 85, 86; 85, 101; 86, boolean_operator:and; 86, 87; 86, 93; 87, comparison_operator:==; 87, 88; 87, 92; 88, call; 88, 89; 88, 90; 89, identifier:len; 90, argument_list; 90, 91; 91, identifier:grapheme; 92, integer:1; 93, comparison_operator:in; 93, 94; 93, 98; 94, call; 94, 95; 94, 96; 95, identifier:ord; 96, argument_list; 96, 97; 97, identifier:grapheme; 98, list:[712, 716]; 98, 99; 98, 100; 99, integer:712; 100, integer:716; 101, block; 101, 102; 101, 114; 101, 118; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 108; 104, subscript; 104, 105; 104, 106; 105, identifier:result; 106, unary_operator:-; 106, 107; 107, integer:1; 108, binary_operator:+; 108, 109; 108, 110; 109, identifier:grapheme; 110, subscript; 110, 111; 110, 112; 111, identifier:result; 112, unary_operator:-; 112, 113; 113, integer:1; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:temp; 117, string:""; 118, continue_statement; 119, if_statement; 119, 120; 119, 135; 120, boolean_operator:and; 120, 121; 120, 127; 121, comparison_operator:==; 121, 122; 121, 126; 122, call; 122, 123; 122, 124; 123, identifier:len; 124, argument_list; 124, 125; 125, identifier:grapheme; 126, integer:1; 127, comparison_operator:==; 127, 128; 127, 134; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:unicodedata; 131, identifier:category; 132, argument_list; 132, 133; 133, identifier:grapheme; 134, string:"Sk"; 135, block; 135, 136; 136, if_statement; 136, 137; 136, 143; 136, 156; 137, comparison_operator:==; 137, 138; 137, 142; 138, call; 138, 139; 138, 140; 139, identifier:len; 140, argument_list; 140, 141; 141, identifier:result; 142, integer:0; 143, block; 143, 144; 143, 151; 143, 155; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:result; 148, identifier:append; 149, argument_list; 149, 150; 150, identifier:grapheme; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:temp; 154, string:""; 155, continue_statement; 156, else_clause; 156, 157; 157, block; 157, 158; 158, if_statement; 158, 159; 158, 172; 159, comparison_operator:==; 159, 160; 159, 171; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:unicodedata; 163, identifier:category; 164, argument_list; 164, 165; 165, subscript; 165, 166; 165, 170; 166, subscript; 166, 167; 166, 168; 167, identifier:result; 168, unary_operator:-; 168, 169; 169, integer:1; 170, integer:0; 171, string:"Sk"; 172, block; 172, 173; 172, 185; 172, 189; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 179; 175, subscript; 175, 176; 175, 177; 176, identifier:result; 177, unary_operator:-; 177, 178; 178, integer:1; 179, binary_operator:+; 179, 180; 179, 181; 180, identifier:grapheme; 181, subscript; 181, 182; 181, 183; 182, identifier:result; 183, unary_operator:-; 183, 184; 184, integer:1; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:temp; 188, string:""; 189, continue_statement; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:result; 194, identifier:append; 195, argument_list; 195, 196; 196, binary_operator:+; 196, 197; 196, 198; 197, identifier:grapheme; 198, identifier:temp; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:temp; 202, string:""; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:segments; 206, subscript; 206, 207; 206, 208; 207, identifier:result; 208, slice; 208, 209; 208, 210; 208, 211; 209, colon; 210, colon; 211, unary_operator:-; 211, 212; 212, integer:1; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:i; 216, integer:0; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:r; 220, list:[]; 221, while_statement; 221, 222; 221, 228; 222, comparison_operator:<; 222, 223; 222, 224; 223, identifier:i; 224, call; 224, 225; 224, 226; 225, identifier:len; 226, argument_list; 226, 227; 227, identifier:segments; 228, block; 228, 229; 229, if_statement; 229, 230; 229, 243; 229, 263; 230, comparison_operator:in; 230, 231; 230, 240; 231, call; 231, 232; 231, 233; 232, identifier:ord; 233, argument_list; 233, 234; 234, subscript; 234, 235; 234, 238; 235, subscript; 235, 236; 235, 237; 236, identifier:segments; 237, identifier:i; 238, unary_operator:-; 238, 239; 239, integer:1; 240, list:[865, 860]; 240, 241; 240, 242; 241, integer:865; 242, integer:860; 243, block; 243, 244; 243, 259; 244, expression_statement; 244, 245; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:r; 248, identifier:append; 249, argument_list; 249, 250; 250, binary_operator:+; 250, 251; 250, 254; 251, subscript; 251, 252; 251, 253; 252, identifier:segments; 253, identifier:i; 254, subscript; 254, 255; 254, 256; 255, identifier:segments; 256, binary_operator:+; 256, 257; 256, 258; 257, identifier:i; 258, integer:1; 259, expression_statement; 259, 260; 260, augmented_assignment:+=; 260, 261; 260, 262; 261, identifier:i; 262, integer:2; 263, else_clause; 263, 264; 264, block; 264, 265; 264, 274; 265, expression_statement; 265, 266; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:r; 269, identifier:append; 270, argument_list; 270, 271; 271, subscript; 271, 272; 271, 273; 272, identifier:segments; 273, identifier:i; 274, expression_statement; 274, 275; 275, augmented_assignment:+=; 275, 276; 275, 277; 276, identifier:i; 277, integer:1; 278, return_statement; 278, 279; 279, identifier:r | def combine_modifiers(self, graphemes):
result = []
temp = ""
count = len(graphemes)
for grapheme in reversed(graphemes):
count -= 1
if len(grapheme) == 1 and unicodedata.category(grapheme) == "Lm" \
and not ord(grapheme) in [712, 716]:
temp = grapheme + temp
if count == 0:
result[-1] = temp + result[-1]
continue
if len(grapheme) == 1 and ord(grapheme) in [712, 716]:
result[-1] = grapheme + result[-1]
temp = ""
continue
if len(grapheme) == 1 and unicodedata.category(grapheme) == "Sk":
if len(result) == 0:
result.append(grapheme)
temp = ""
continue
else:
if unicodedata.category(result[-1][0]) == "Sk":
result[-1] = grapheme + result[-1]
temp = ""
continue
result.append(grapheme + temp)
temp = ""
segments = result[::-1]
i = 0
r = []
while i < len(segments):
if ord(segments[i][-1]) in [865, 860]:
r.append(segments[i] + segments[i + 1])
i += 2
else:
r.append(segments[i])
i += 1
return r |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:check_mismatches; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:read; 5, identifier:pair; 6, identifier:mismatches; 7, identifier:mm_option; 8, identifier:req_map; 9, block; 9, 10; 9, 43; 9, 50; 9, 57; 9, 68; 9, 75; 9, 91; 9, 117; 9, 167; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:pair; 13, False; 14, block; 14, 15; 14, 22; 14, 29; 14, 36; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:mm; 18, call; 18, 19; 18, 20; 19, identifier:count_mismatches; 20, argument_list; 20, 21; 21, identifier:read; 22, if_statement; 22, 23; 22, 26; 23, comparison_operator:is; 23, 24; 23, 25; 24, identifier:mm; 25, False; 26, block; 26, 27; 27, return_statement; 27, 28; 28, False; 29, if_statement; 29, 30; 29, 33; 30, comparison_operator:is; 30, 31; 30, 32; 31, identifier:mismatches; 32, False; 33, block; 33, 34; 34, return_statement; 34, 35; 35, True; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:<=; 37, 38; 37, 39; 38, identifier:mm; 39, identifier:mismatches; 40, block; 40, 41; 41, return_statement; 41, 42; 42, True; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:r_mm; 46, call; 46, 47; 46, 48; 47, identifier:count_mismatches; 48, argument_list; 48, 49; 49, identifier:read; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:p_mm; 53, call; 53, 54; 53, 55; 54, identifier:count_mismatches; 55, argument_list; 55, 56; 56, identifier:pair; 57, if_statement; 57, 58; 57, 65; 58, boolean_operator:and; 58, 59; 58, 62; 59, comparison_operator:is; 59, 60; 59, 61; 60, identifier:r_mm; 61, False; 62, comparison_operator:is; 62, 63; 62, 64; 63, identifier:p_mm; 64, False; 65, block; 65, 66; 66, return_statement; 66, 67; 67, False; 68, if_statement; 68, 69; 68, 72; 69, comparison_operator:is; 69, 70; 69, 71; 70, identifier:mismatches; 71, False; 72, block; 72, 73; 73, return_statement; 73, 74; 74, True; 75, if_statement; 75, 76; 75, 79; 76, comparison_operator:is; 76, 77; 76, 78; 77, identifier:req_map; 78, True; 79, block; 79, 80; 80, if_statement; 80, 81; 80, 88; 81, boolean_operator:or; 81, 82; 81, 85; 82, comparison_operator:is; 82, 83; 82, 84; 83, identifier:r_mm; 84, False; 85, comparison_operator:is; 85, 86; 85, 87; 86, identifier:p_mm; 87, False; 88, block; 88, 89; 89, return_statement; 89, 90; 90, False; 91, if_statement; 91, 92; 91, 95; 92, comparison_operator:==; 92, 93; 92, 94; 93, identifier:mm_option; 94, string:'one'; 95, block; 95, 96; 96, if_statement; 96, 97; 96, 114; 97, boolean_operator:or; 97, 98; 97, 106; 98, parenthesized_expression; 98, 99; 99, boolean_operator:and; 99, 100; 99, 103; 100, comparison_operator:is; 100, 101; 100, 102; 101, identifier:r_mm; 102, False; 103, comparison_operator:<=; 103, 104; 103, 105; 104, identifier:r_mm; 105, identifier:mismatches; 106, parenthesized_expression; 106, 107; 107, boolean_operator:and; 107, 108; 107, 111; 108, comparison_operator:is; 108, 109; 108, 110; 109, identifier:p_mm; 110, False; 111, comparison_operator:<=; 111, 112; 111, 113; 112, identifier:p_mm; 113, identifier:mismatches; 114, block; 114, 115; 115, return_statement; 115, 116; 116, True; 117, if_statement; 117, 118; 117, 121; 118, comparison_operator:==; 118, 119; 118, 120; 119, identifier:mm_option; 120, string:'both'; 121, block; 121, 122; 122, if_statement; 122, 123; 122, 126; 122, 134; 122, 146; 123, comparison_operator:is; 123, 124; 123, 125; 124, identifier:r_mm; 125, False; 126, block; 126, 127; 127, if_statement; 127, 128; 127, 131; 128, comparison_operator:<=; 128, 129; 128, 130; 129, identifier:p_mm; 130, identifier:mismatches; 131, block; 131, 132; 132, return_statement; 132, 133; 133, True; 134, elif_clause; 134, 135; 134, 138; 135, comparison_operator:is; 135, 136; 135, 137; 136, identifier:p_mm; 137, False; 138, block; 138, 139; 139, if_statement; 139, 140; 139, 143; 140, comparison_operator:<=; 140, 141; 140, 142; 141, identifier:r_mm; 142, identifier:mismatches; 143, block; 143, 144; 144, return_statement; 144, 145; 145, True; 146, elif_clause; 146, 147; 146, 164; 147, boolean_operator:and; 147, 148; 147, 156; 148, parenthesized_expression; 148, 149; 149, boolean_operator:and; 149, 150; 149, 153; 150, comparison_operator:is; 150, 151; 150, 152; 151, identifier:r_mm; 152, False; 153, comparison_operator:<=; 153, 154; 153, 155; 154, identifier:r_mm; 155, identifier:mismatches; 156, parenthesized_expression; 156, 157; 157, boolean_operator:and; 157, 158; 157, 161; 158, comparison_operator:is; 158, 159; 158, 160; 159, identifier:p_mm; 160, False; 161, comparison_operator:<=; 161, 162; 161, 163; 162, identifier:p_mm; 163, identifier:mismatches; 164, block; 164, 165; 165, return_statement; 165, 166; 166, True; 167, return_statement; 167, 168; 168, False | def check_mismatches(read, pair, mismatches, mm_option, req_map):
if pair is False:
mm = count_mismatches(read)
if mm is False:
return False
if mismatches is False:
return True
if mm <= mismatches:
return True
r_mm = count_mismatches(read)
p_mm = count_mismatches(pair)
if r_mm is False and p_mm is False:
return False
if mismatches is False:
return True
if req_map is True:
if r_mm is False or p_mm is False:
return False
if mm_option == 'one':
if (r_mm is not False and r_mm <= mismatches) or (p_mm is not False and p_mm <= mismatches):
return True
if mm_option == 'both':
if r_mm is False:
if p_mm <= mismatches:
return True
elif p_mm is False:
if r_mm <= mismatches:
return True
elif (r_mm is not False and r_mm <= mismatches) and (p_mm is not False and p_mm <= mismatches):
return True
return False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:get_steam; 3, parameters; 4, block; 4, 5; 4, 25; 4, 33; 4, 47; 4, 61; 4, 84; 5, expression_statement; 5, 6; 6, assignment; 6, 7; 6, 8; 7, identifier:helper; 8, lambda; 8, 9; 8, 11; 9, lambda_parameters; 9, 10; 10, identifier:udd; 11, conditional_expression:if; 11, 12; 11, 16; 11, 24; 12, call; 12, 13; 12, 14; 13, identifier:Steam; 14, argument_list; 14, 15; 15, identifier:udd; 16, call; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:os; 20, identifier:path; 21, identifier:exists; 22, argument_list; 22, 23; 23, identifier:udd; 24, None; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:plat; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:platform; 31, identifier:system; 32, argument_list; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:==; 34, 35; 34, 36; 35, identifier:plat; 36, string:'Darwin'; 37, block; 37, 38; 38, return_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:helper; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:paths; 45, identifier:default_osx_userdata_path; 46, argument_list; 47, if_statement; 47, 48; 47, 51; 48, comparison_operator:==; 48, 49; 48, 50; 49, identifier:plat; 50, string:'Linux'; 51, block; 51, 52; 52, return_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:helper; 55, argument_list; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:paths; 59, identifier:default_linux_userdata_path; 60, argument_list; 61, if_statement; 61, 62; 61, 65; 62, comparison_operator:==; 62, 63; 62, 64; 63, identifier:plat; 64, string:'Windows'; 65, block; 65, 66; 65, 74; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:possible_dir; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:winutils; 72, identifier:find_userdata_directory; 73, argument_list; 74, return_statement; 74, 75; 75, conditional_expression:if; 75, 76; 75, 80; 75, 83; 76, call; 76, 77; 76, 78; 77, identifier:helper; 78, argument_list; 78, 79; 79, identifier:possible_dir; 80, comparison_operator:is; 80, 81; 80, 82; 81, identifier:possible_dir; 82, None; 83, None; 84, return_statement; 84, 85; 85, None | def get_steam():
helper = lambda udd: Steam(udd) if os.path.exists(udd) else None
plat = platform.system()
if plat == 'Darwin':
return helper(paths.default_osx_userdata_path())
if plat == 'Linux':
return helper(paths.default_linux_userdata_path())
if plat == 'Windows':
possible_dir = winutils.find_userdata_directory()
return helper(possible_dir) if possible_dir is not None else None
return None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:generate_barcodes; 3, parameters; 3, 4; 3, 5; 4, identifier:nIds; 5, default_parameter; 5, 6; 5, 7; 6, identifier:codeLen; 7, integer:12; 8, block; 8, 9; 8, 39; 8, 54; 8, 75; 8, 87; 8, 112; 8, 116; 8, 192; 9, function_definition; 9, 10; 9, 11; 9, 15; 10, function_name:next_code; 11, parameters; 11, 12; 11, 13; 11, 14; 12, identifier:b; 13, identifier:c; 14, identifier:i; 15, block; 15, 16; 16, return_statement; 16, 17; 17, binary_operator:+; 17, 18; 17, 25; 18, binary_operator:+; 18, 19; 18, 24; 19, subscript; 19, 20; 19, 21; 20, identifier:c; 21, slice; 21, 22; 21, 23; 22, colon; 23, identifier:i; 24, identifier:b; 25, parenthesized_expression; 25, 26; 26, conditional_expression:if; 26, 27; 26, 34; 26, 38; 27, subscript; 27, 28; 27, 29; 28, identifier:c; 29, slice; 29, 30; 29, 33; 30, binary_operator:+; 30, 31; 30, 32; 31, identifier:i; 32, integer:1; 33, colon; 34, comparison_operator:<; 34, 35; 34, 36; 35, identifier:i; 36, unary_operator:-; 36, 37; 37, integer:1; 38, string:''; 39, function_definition; 39, 40; 39, 41; 39, 42; 40, function_name:rand_base; 41, parameters; 42, block; 42, 43; 43, return_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:random; 47, identifier:choice; 48, argument_list; 48, 49; 49, list:['A', 'T', 'C', 'G']; 49, 50; 49, 51; 49, 52; 49, 53; 50, string:'A'; 51, string:'T'; 52, string:'C'; 53, string:'G'; 54, function_definition; 54, 55; 54, 56; 54, 58; 55, function_name:rand_seq; 56, parameters; 56, 57; 57, identifier:n; 58, block; 58, 59; 59, return_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, string:''; 63, identifier:join; 64, argument_list; 64, 65; 65, list_comprehension; 65, 66; 65, 69; 66, call; 66, 67; 66, 68; 67, identifier:rand_base; 68, argument_list; 69, for_in_clause; 69, 70; 69, 71; 70, identifier:_; 71, call; 71, 72; 71, 73; 72, identifier:range; 73, argument_list; 73, 74; 74, identifier:n; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:hpf; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:re; 81, identifier:compile; 82, argument_list; 82, 83; 82, 84; 83, string:'aaaa|cccc|gggg|tttt'; 84, attribute; 84, 85; 84, 86; 85, identifier:re; 86, identifier:IGNORECASE; 87, while_statement; 87, 88; 87, 89; 88, True; 89, block; 89, 90; 89, 98; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:codes; 93, list:[rand_seq(codeLen)]; 93, 94; 94, call; 94, 95; 94, 96; 95, identifier:rand_seq; 96, argument_list; 96, 97; 97, identifier:codeLen; 98, if_statement; 98, 99; 98, 110; 99, parenthesized_expression; 99, 100; 100, comparison_operator:is; 100, 101; 100, 109; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:hpf; 104, identifier:search; 105, argument_list; 105, 106; 106, subscript; 106, 107; 106, 108; 107, identifier:codes; 108, integer:0; 109, None; 110, block; 110, 111; 111, break_statement; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:idx; 115, integer:0; 116, while_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:codes; 122, identifier:nIds; 123, block; 123, 124; 123, 128; 123, 182; 124, expression_statement; 124, 125; 125, augmented_assignment:-=; 125, 126; 125, 127; 126, identifier:idx; 127, integer:1; 128, if_statement; 128, 129; 128, 133; 128, 149; 129, comparison_operator:<; 129, 130; 129, 131; 130, identifier:idx; 131, unary_operator:-; 131, 132; 132, identifier:codeLen; 133, block; 133, 134; 133, 139; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:idx; 137, unary_operator:-; 137, 138; 138, integer:1; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:codes; 143, identifier:append; 144, argument_list; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:rand_seq; 147, argument_list; 147, 148; 148, identifier:codeLen; 149, else_clause; 149, 150; 150, block; 150, 151; 150, 165; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:nc; 154, call; 154, 155; 154, 156; 155, identifier:next_code; 156, argument_list; 156, 157; 156, 160; 156, 164; 157, call; 157, 158; 157, 159; 158, identifier:rand_base; 159, argument_list; 160, subscript; 160, 161; 160, 162; 161, identifier:codes; 162, unary_operator:-; 162, 163; 163, integer:1; 164, identifier:idx; 165, if_statement; 165, 166; 165, 174; 166, comparison_operator:is; 166, 167; 166, 173; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:hpf; 170, identifier:search; 171, argument_list; 171, 172; 172, identifier:nc; 173, None; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:codes; 179, identifier:append; 180, argument_list; 180, 181; 181, identifier:nc; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:codes; 185, call; 185, 186; 185, 187; 186, identifier:list; 187, argument_list; 187, 188; 188, call; 188, 189; 188, 190; 189, identifier:set; 190, argument_list; 190, 191; 191, identifier:codes; 192, return_statement; 192, 193; 193, identifier:codes | def generate_barcodes(nIds, codeLen=12):
def next_code(b, c, i):
return c[:i] + b + (c[i+1:] if i < -1 else '')
def rand_base():
return random.choice(['A', 'T', 'C', 'G'])
def rand_seq(n):
return ''.join([rand_base() for _ in range(n)])
hpf = re.compile('aaaa|cccc|gggg|tttt', re.IGNORECASE)
while True:
codes = [rand_seq(codeLen)]
if (hpf.search(codes[0]) is None):
break
idx = 0
while len(codes) < nIds:
idx -= 1
if idx < -codeLen:
idx = -1
codes.append(rand_seq(codeLen))
else:
nc = next_code(rand_base(), codes[-1], idx)
if hpf.search(nc) is None:
codes.append(nc)
codes = list(set(codes))
return codes |
0, module; 0, 1; 1, ERROR; 1, 2; 2, function_definition; 2, 3; 2, 4; 2, 8; 3, function_name:parse_fasta_annotations; 4, parameters; 4, 5; 4, 6; 4, 7; 5, identifier:fastas; 6, identifier:annot_tables; 7, identifier:trans_table; 8, block; 8, 9; 8, 57; 8, 215; 8, 235; 8, 246; 8, 260; 8, 277; 9, if_statement; 9, 10; 9, 13; 10, comparison_operator:is; 10, 11; 10, 12; 11, identifier:annot_tables; 12, False; 13, block; 13, 14; 13, 18; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:annots; 17, dictionary; 18, for_statement; 18, 19; 18, 20; 18, 21; 19, identifier:table; 20, identifier:annot_tables; 21, block; 21, 22; 22, for_statement; 22, 23; 22, 24; 22, 28; 23, identifier:cds; 24, call; 24, 25; 24, 26; 25, identifier:open; 26, argument_list; 26, 27; 27, identifier:table; 28, block; 28, 29; 28, 45; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 36; 31, pattern_list; 31, 32; 31, 33; 31, 34; 31, 35; 32, identifier:ID; 33, identifier:start; 34, identifier:end; 35, identifier:strand; 36, call; 36, 37; 36, 44; 37, attribute; 37, 38; 37, 43; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:cds; 41, identifier:strip; 42, argument_list; 43, identifier:split; 44, argument_list; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:annots; 49, identifier:ID; 50, list:[start, end, int(strand)]; 50, 51; 50, 52; 50, 53; 51, identifier:start; 52, identifier:end; 53, call; 53, 54; 53, 55; 54, identifier:int; 55, argument_list; 55, 56; 56, identifier:strand; 57, for_statement; 57, 58; 57, 59; 57, 60; 57, 203; 57, 208; 58, identifier:fasta; 59, identifier:fastas; 60, ERROR; 60, 61; 60, 160; 60, 179; 60, 180; 60, 182; 60, 183; 60, 185; 60, 191; 60, 197; 60, 200; 61, for_statement; 61, 62; 61, 63; 61, 67; 61, 78; 61, 131; 62, identifier:seq; 63, call; 63, 64; 63, 65; 64, identifier:parse_fasta; 65, argument_list; 65, 66; 66, identifier:fasta; 67, ERROR; 67, 68; 67, 73; 68, call; 68, 69; 68, 70; 68, 72; 69, string:'
print('; 70, ERROR; 70, 71; 71, identifier:exit; 72, argument_list; 73, comparison_operator:in; 73, 74; 73, 75; 74, string:'ID='; 75, subscript; 75, 76; 75, 77; 76, identifier:seq; 77, integer:0; 78, block; 78, 79; 78, 101; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:ID; 82, subscript; 82, 83; 82, 100; 83, call; 83, 84; 83, 97; 84, attribute; 84, 85; 84, 96; 85, subscript; 85, 86; 85, 95; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:seq; 90, integer:0; 91, identifier:rsplit; 92, argument_list; 92, 93; 92, 94; 93, string:'ID='; 94, integer:1; 95, integer:1; 96, identifier:split; 97, argument_list; 97, 98; 97, 99; 98, string:';'; 99, integer:1; 100, integer:0; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:contig; 104, subscript; 104, 105; 104, 130; 105, call; 105, 106; 105, 124; 106, attribute; 106, 107; 106, 123; 107, subscript; 107, 108; 107, 122; 108, call; 108, 109; 108, 120; 109, attribute; 109, 110; 109, 119; 110, subscript; 110, 111; 110, 118; 111, call; 111, 112; 111, 117; 112, attribute; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:seq; 115, integer:0; 116, identifier:split; 117, argument_list; 118, integer:0; 119, identifier:split; 120, argument_list; 120, 121; 121, string:'>'; 122, integer:1; 123, identifier:rsplit; 124, argument_list; 124, 125; 124, 129; 125, binary_operator:%; 125, 126; 125, 127; 126, string:'_%s'; 127, parenthesized_expression; 127, 128; 128, identifier:ID; 129, integer:1; 130, integer:0; 131, else_clause; 131, 132; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:contig; 136, subscript; 136, 137; 136, 159; 137, call; 137, 138; 137, 156; 138, attribute; 138, 139; 138, 155; 139, subscript; 139, 140; 139, 154; 140, call; 140, 141; 140, 152; 141, attribute; 141, 142; 141, 151; 142, subscript; 142, 143; 142, 150; 143, call; 143, 144; 143, 149; 144, attribute; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:seq; 147, integer:0; 148, identifier:split; 149, argument_list; 150, integer:0; 151, identifier:split; 152, argument_list; 152, 153; 153, string:'>'; 154, integer:1; 155, identifier:rsplit; 156, argument_list; 156, 157; 156, 158; 157, string:'_'; 158, integer:1; 159, integer:0; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:locus; 163, subscript; 163, 164; 163, 178; 164, call; 164, 165; 164, 176; 165, attribute; 165, 166; 165, 175; 166, subscript; 166, 167; 166, 174; 167, call; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, subscript; 169, 170; 169, 171; 170, identifier:seq; 171, integer:0; 172, identifier:split; 173, argument_list; 174, integer:0; 175, identifier:split; 176, argument_list; 176, 177; 177, string:'>'; 178, integer:1; 179, string:'
info = seq[0].split('; 180, ERROR; 180, 181; 181, identifier:start; 182, identifier:end; 183, ERROR; 183, 184; 184, identifier:strand; 185, call; 185, 186; 185, 187; 186, identifier:int; 187, argument_list; 187, 188; 188, subscript; 188, 189; 188, 190; 189, identifier:info; 190, integer:1; 191, call; 191, 192; 191, 193; 192, identifier:int; 193, argument_list; 193, 194; 194, subscript; 194, 195; 194, 196; 195, identifier:info; 196, integer:2; 197, subscript; 197, 198; 197, 199; 198, identifier:info; 199, integer:3; 200, comparison_operator:==; 200, 201; 200, 202; 201, identifier:strand; 202, string:'1'; 203, block; 203, 204; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:strand; 207, integer:1; 208, else_clause; 208, 209; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:strand; 213, unary_operator:-; 213, 214; 214, integer:1; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:product; 218, list:[''.join(info[4].split()[1:])]; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, string:''; 222, identifier:join; 223, argument_list; 223, 224; 224, subscript; 224, 225; 224, 232; 225, call; 225, 226; 225, 231; 226, attribute; 226, 227; 226, 230; 227, subscript; 227, 228; 227, 229; 228, identifier:info; 229, integer:4; 230, identifier:split; 231, argument_list; 232, slice; 232, 233; 232, 234; 233, integer:1; 234, colon; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 243; 237, pattern_list; 237, 238; 237, 239; 237, 241; 237, 242; 238, identifier:else; 239, ERROR; 239, 240; 240, identifier:start; 241, identifier:end; 242, identifier:strand; 243, subscript; 243, 244; 243, 245; 244, identifier:annots; 245, identifier:locus; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:product; 249, subscript; 249, 250; 249, 259; 250, call; 250, 251; 250, 256; 251, attribute; 251, 252; 251, 255; 252, subscript; 252, 253; 252, 254; 253, identifier:seq; 254, integer:0; 255, identifier:split; 256, argument_list; 256, 257; 256, 258; 257, string:' '; 258, integer:1; 259, integer:1; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:info; 263, dictionary; 263, 264; 263, 268; 263, 274; 264, pair; 264, 265; 264, 266; 265, string:'transl_table'; 266, list:[trans_table]; 266, 267; 267, identifier:trans_table; 268, pair; 268, 269; 268, 270; 269, string:'translation'; 270, list:[seq[1]]; 270, 271; 271, subscript; 271, 272; 271, 273; 272, identifier:seq; 273, integer:1; 274, pair; 274, 275; 274, 276; 275, string:'product'; 276, identifier:product; 277, expression_statement; 277, 278; 278, yield; 278, 279; 279, expression_list; 279, 280; 279, 281; 280, identifier:contig; 281, list:[locus, [start, end, strand], info]; 281, 282; 281, 283; 281, 287; 282, identifier:locus; 283, list:[start, end, strand]; 283, 284; 283, 285; 283, 286; 284, identifier:start; 285, identifier:end; 286, identifier:strand; 287, identifier:info | def parse_fasta_annotations(fastas, annot_tables, trans_table):
if annot_tables is not False:
annots = {}
for table in annot_tables:
for cds in open(table):
ID, start, end, strand = cds.strip().split()
annots[ID] = [start, end, int(strand)]
for fasta in fastas:
for seq in parse_fasta(fasta):
if ('
print('
exit()
if 'ID=' in seq[0]:
ID = seq[0].rsplit('ID=', 1)[1].split(';', 1)[0]
contig = seq[0].split()[0].split('>')[1].rsplit('_%s' % (ID), 1)[0]
else:
contig = seq[0].split()[0].split('>')[1].rsplit('_', 1)[0]
locus = seq[0].split()[0].split('>')[1]
if ('
info = seq[0].split('
start, end, strand = int(info[1]), int(info[2]), info[3]
if strand == '1':
strand = 1
else:
strand = -1
product = [''.join(info[4].split()[1:])]
else:
start, end, strand = annots[locus]
product = seq[0].split(' ', 1)[1]
info = {'transl_table':[trans_table], \
'translation':[seq[1]], \
'product':product}
yield contig, [locus, [start, end, strand], info] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:find_consensus; 3, parameters; 3, 4; 4, identifier:bases; 5, block; 5, 6; 5, 15; 5, 32; 5, 75; 5, 93; 5, 123; 5, 183; 5, 189; 5, 195; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:nucs; 9, list:['A', 'T', 'G', 'C', 'N']; 9, 10; 9, 11; 9, 12; 9, 13; 9, 14; 10, string:'A'; 11, string:'T'; 12, string:'G'; 13, string:'C'; 14, string:'N'; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:total; 18, call; 18, 19; 18, 20; 19, identifier:sum; 20, argument_list; 20, 21; 21, list_comprehension; 21, 22; 21, 25; 21, 28; 22, subscript; 22, 23; 22, 24; 23, identifier:bases; 24, identifier:nuc; 25, for_in_clause; 25, 26; 25, 27; 26, identifier:nuc; 27, identifier:nucs; 28, if_clause; 28, 29; 29, comparison_operator:in; 29, 30; 29, 31; 30, identifier:nuc; 31, identifier:bases; 32, try_statement; 32, 33; 32, 51; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:top; 37, call; 37, 38; 37, 39; 38, identifier:max; 39, argument_list; 39, 40; 40, list_comprehension; 40, 41; 40, 44; 40, 47; 41, subscript; 41, 42; 41, 43; 42, identifier:bases; 43, identifier:nuc; 44, for_in_clause; 44, 45; 44, 46; 45, identifier:nuc; 46, identifier:nucs; 47, if_clause; 47, 48; 48, comparison_operator:in; 48, 49; 48, 50; 49, identifier:nuc; 50, identifier:bases; 51, except_clause; 51, 52; 52, block; 52, 53; 52, 61; 52, 67; 52, 73; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:bases; 57, string:'consensus'; 58, tuple; 58, 59; 58, 60; 59, string:'N'; 60, string:'n/a'; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:bases; 65, string:'consensus frequency'; 66, string:'n/a'; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:bases; 71, string:'reference frequency'; 72, string:'n/a'; 73, return_statement; 73, 74; 74, identifier:bases; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:top; 78, list_comprehension; 78, 79; 78, 84; 78, 87; 79, tuple; 79, 80; 79, 81; 80, identifier:nuc; 81, subscript; 81, 82; 81, 83; 82, identifier:bases; 83, identifier:nuc; 84, for_in_clause; 84, 85; 84, 86; 85, identifier:nuc; 86, identifier:bases; 87, if_clause; 87, 88; 88, comparison_operator:==; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:bases; 91, identifier:nuc; 92, identifier:top; 93, if_statement; 93, 94; 93, 101; 93, 110; 94, comparison_operator:==; 94, 95; 94, 100; 95, subscript; 95, 96; 95, 99; 96, subscript; 96, 97; 96, 98; 97, identifier:top; 98, integer:0; 99, integer:1; 100, integer:0; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:bases; 106, string:'consensus'; 107, tuple; 107, 108; 107, 109; 108, string:'n/a'; 109, integer:0; 110, else_clause; 110, 111; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:bases; 116, string:'consensus'; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:random; 120, identifier:choice; 121, argument_list; 121, 122; 122, identifier:top; 123, if_statement; 123, 124; 123, 127; 123, 136; 124, comparison_operator:==; 124, 125; 124, 126; 125, identifier:total; 126, integer:0; 127, block; 127, 128; 127, 132; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:c_freq; 131, string:'n/a'; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:ref_freq; 135, string:'n/a'; 136, else_clause; 136, 137; 137, block; 137, 138; 137, 154; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:c_freq; 141, binary_operator:/; 141, 142; 141, 150; 142, call; 142, 143; 142, 144; 143, identifier:float; 144, argument_list; 144, 145; 145, subscript; 145, 146; 145, 149; 146, subscript; 146, 147; 146, 148; 147, identifier:bases; 148, string:'consensus'; 149, integer:1; 150, call; 150, 151; 150, 152; 151, identifier:float; 152, argument_list; 152, 153; 153, identifier:total; 154, if_statement; 154, 155; 154, 160; 154, 165; 155, comparison_operator:not; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:bases; 158, string:'ref'; 159, identifier:bases; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:ref_freq; 164, integer:0; 165, else_clause; 165, 166; 166, block; 166, 167; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:ref_freq; 170, binary_operator:/; 170, 171; 170, 179; 171, call; 171, 172; 171, 173; 172, identifier:float; 173, argument_list; 173, 174; 174, subscript; 174, 175; 174, 176; 175, identifier:bases; 176, subscript; 176, 177; 176, 178; 177, identifier:bases; 178, string:'ref'; 179, call; 179, 180; 179, 181; 180, identifier:float; 181, argument_list; 181, 182; 182, identifier:total; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 188; 185, subscript; 185, 186; 185, 187; 186, identifier:bases; 187, string:'consensus frequency'; 188, identifier:c_freq; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 194; 191, subscript; 191, 192; 191, 193; 192, identifier:bases; 193, string:'reference frequency'; 194, identifier:ref_freq; 195, return_statement; 195, 196; 196, identifier:bases | def find_consensus(bases):
nucs = ['A', 'T', 'G', 'C', 'N']
total = sum([bases[nuc] for nuc in nucs if nuc in bases])
try:
top = max([bases[nuc] for nuc in nucs if nuc in bases])
except:
bases['consensus'] = ('N', 'n/a')
bases['consensus frequency'] = 'n/a'
bases['reference frequency'] = 'n/a'
return bases
top = [(nuc, bases[nuc]) for nuc in bases if bases[nuc] == top]
if top[0][1] == 0:
bases['consensus'] = ('n/a', 0)
else:
bases['consensus'] = random.choice(top)
if total == 0:
c_freq = 'n/a'
ref_freq = 'n/a'
else:
c_freq = float(bases['consensus'][1]) / float(total)
if bases['ref'] not in bases:
ref_freq = 0
else:
ref_freq = float(bases[bases['ref']]) / float(total)
bases['consensus frequency'] = c_freq
bases['reference frequency'] = ref_freq
return bases |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:print_consensus; 3, parameters; 3, 4; 4, identifier:genomes; 5, block; 5, 6; 5, 10; 5, 128; 5, 204; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:cons; 9, dictionary; 10, for_statement; 10, 11; 10, 14; 10, 22; 11, pattern_list; 11, 12; 11, 13; 12, identifier:genome; 13, identifier:contigs; 14, call; 14, 15; 14, 16; 15, identifier:list; 16, argument_list; 16, 17; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:genomes; 20, identifier:items; 21, argument_list; 22, block; 22, 23; 22, 29; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, subscript; 25, 26; 25, 27; 26, identifier:cons; 27, identifier:genome; 28, dictionary; 29, for_statement; 29, 30; 29, 33; 29, 41; 30, pattern_list; 30, 31; 30, 32; 31, identifier:contig; 32, identifier:samples; 33, call; 33, 34; 33, 35; 34, identifier:list; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:contigs; 39, identifier:items; 40, argument_list; 41, block; 41, 42; 42, for_statement; 42, 43; 42, 46; 42, 54; 43, pattern_list; 43, 44; 43, 45; 44, identifier:sample; 45, identifier:stats; 46, call; 46, 47; 46, 48; 47, identifier:list; 48, argument_list; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:samples; 52, identifier:items; 53, argument_list; 54, block; 54, 55; 54, 70; 54, 82; 55, if_statement; 55, 56; 55, 61; 56, comparison_operator:not; 56, 57; 56, 58; 57, identifier:sample; 58, subscript; 58, 59; 58, 60; 59, identifier:cons; 60, identifier:genome; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 69; 64, subscript; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:cons; 67, identifier:genome; 68, identifier:sample; 69, dictionary; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:seq; 73, assignment; 73, 74; 73, 81; 74, subscript; 74, 75; 74, 80; 75, subscript; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:cons; 78, identifier:genome; 79, identifier:sample; 80, identifier:contig; 81, list:[]; 82, for_statement; 82, 83; 82, 86; 82, 93; 83, pattern_list; 83, 84; 83, 85; 84, identifier:pos; 85, identifier:ps; 86, call; 86, 87; 86, 88; 87, identifier:enumerate; 88, argument_list; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:stats; 91, string:'bp_stats'; 92, integer:1; 93, block; 93, 94; 93, 108; 93, 121; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 99; 96, pattern_list; 96, 97; 96, 98; 97, identifier:ref; 98, identifier:consensus; 99, expression_list; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:ps; 102, string:'ref'; 103, subscript; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:ps; 106, string:'consensus'; 107, integer:0; 108, if_statement; 108, 109; 108, 112; 109, comparison_operator:==; 109, 110; 109, 111; 110, identifier:consensus; 111, string:'n/a'; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:consensus; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:ref; 119, identifier:lower; 120, argument_list; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:seq; 125, identifier:append; 126, argument_list; 126, 127; 127, identifier:consensus; 128, for_statement; 128, 129; 128, 132; 128, 137; 129, pattern_list; 129, 130; 129, 131; 130, identifier:genome; 131, identifier:samples; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:cons; 135, identifier:items; 136, argument_list; 137, block; 137, 138; 138, for_statement; 138, 139; 138, 142; 138, 147; 139, pattern_list; 139, 140; 139, 141; 140, identifier:sample; 141, identifier:contigs; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:samples; 145, identifier:items; 146, argument_list; 147, block; 147, 148; 147, 156; 147, 164; 147, 198; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:fn; 151, binary_operator:%; 151, 152; 151, 153; 152, string:'%s.%s.consensus.fa'; 153, tuple; 153, 154; 153, 155; 154, identifier:genome; 155, identifier:sample; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:f; 159, call; 159, 160; 159, 161; 160, identifier:open; 161, argument_list; 161, 162; 161, 163; 162, identifier:fn; 163, string:'w'; 164, for_statement; 164, 165; 164, 168; 164, 173; 165, pattern_list; 165, 166; 165, 167; 166, identifier:contig; 167, identifier:seq; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:contigs; 171, identifier:items; 172, argument_list; 173, block; 173, 174; 173, 185; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 177; 176, identifier:print; 177, argument_list; 177, 178; 177, 182; 178, binary_operator:%; 178, 179; 178, 180; 179, string:'>%s'; 180, parenthesized_expression; 180, 181; 181, identifier:contig; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:file; 184, identifier:f; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 188; 187, identifier:print; 188, argument_list; 188, 189; 188, 195; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, string:''; 192, identifier:join; 193, argument_list; 193, 194; 194, identifier:seq; 195, keyword_argument; 195, 196; 195, 197; 196, identifier:file; 197, identifier:f; 198, expression_statement; 198, 199; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:f; 202, identifier:close; 203, argument_list; 204, return_statement; 204, 205; 205, identifier:cons | def print_consensus(genomes):
cons = {}
for genome, contigs in list(genomes.items()):
cons[genome] = {}
for contig, samples in list(contigs.items()):
for sample, stats in list(samples.items()):
if sample not in cons[genome]:
cons[genome][sample] = {}
seq = cons[genome][sample][contig] = []
for pos, ps in enumerate(stats['bp_stats'], 1):
ref, consensus = ps['ref'], ps['consensus'][0]
if consensus == 'n/a':
consensus = ref.lower()
seq.append(consensus)
for genome, samples in cons.items():
for sample, contigs in samples.items():
fn = '%s.%s.consensus.fa' % (genome, sample)
f = open(fn, 'w')
for contig, seq in contigs.items():
print('>%s' % (contig), file = f)
print(''.join(seq), file = f)
f.close()
return cons |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:parse_cov; 3, parameters; 3, 4; 3, 5; 4, identifier:cov_table; 5, identifier:scaffold2genome; 6, block; 6, 7; 6, 11; 6, 15; 6, 179; 6, 195; 6, 255; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:size; 10, dictionary; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:mapped; 14, dictionary; 15, for_statement; 15, 16; 15, 17; 15, 21; 16, identifier:line; 17, call; 17, 18; 17, 19; 18, identifier:open; 19, argument_list; 19, 20; 20, identifier:cov_table; 21, block; 21, 22; 21, 35; 21, 126; 21, 132; 21, 155; 21, 161; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:line; 25, call; 25, 26; 25, 33; 26, attribute; 26, 27; 26, 32; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:line; 30, identifier:strip; 31, argument_list; 32, identifier:split; 33, argument_list; 33, 34; 34, string:'\t'; 35, if_statement; 35, 36; 35, 41; 35, 124; 36, attribute; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:line; 39, integer:0; 40, identifier:startswith; 41, ERROR; 41, 42; 41, 43; 41, 76; 41, 79; 41, 80; 41, 121; 42, ERROR; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:samples; 45, subscript; 45, 46; 45, 51; 45, 53; 46, subscript; 46, 47; 46, 48; 47, identifier:line; 48, slice; 48, 49; 48, 50; 49, integer:1; 50, colon; 51, ERROR; 51, 52; 52, identifier:samples; 53, comparison_operator:in; 53, 54; 53, 72; 53, 75; 54, subscript; 54, 55; 54, 71; 55, call; 55, 56; 55, 68; 56, attribute; 56, 57; 56, 67; 57, subscript; 57, 58; 57, 65; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:i; 61, identifier:rsplit; 62, argument_list; 62, 63; 62, 64; 63, string:'/'; 64, integer:1; 65, unary_operator:-; 65, 66; 66, integer:1; 67, identifier:split; 68, argument_list; 68, 69; 68, 70; 69, string:'.'; 70, integer:1; 71, integer:0; 72, ERROR; 72, 73; 72, 74; 73, identifier:for; 74, identifier:i; 75, identifier:samples; 76, ERROR; 76, 77; 76, 78; 77, identifier:continue; 78, identifier:scaffold; 79, identifier:length; 80, subscript; 80, 81; 80, 111; 80, 113; 81, subscript; 81, 82; 81, 96; 81, 98; 82, call; 82, 83; 82, 91; 82, 94; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:line; 87, integer:0; 88, identifier:split; 89, argument_list; 89, 90; 90, string:': '; 91, ERROR; 91, 92; 91, 93; 92, identifier:length; 93, identifier:float; 94, argument_list; 94, 95; 95, identifier:length; 96, ERROR; 96, 97; 97, identifier:covs; 98, comparison_operator:in; 98, 99; 98, 103; 98, 106; 99, call; 99, 100; 99, 101; 100, identifier:float; 101, argument_list; 101, 102; 102, identifier:i; 103, ERROR; 103, 104; 103, 105; 104, identifier:for; 105, identifier:i; 106, subscript; 106, 107; 106, 108; 107, identifier:line; 108, slice; 108, 109; 108, 110; 109, integer:1; 110, colon; 111, ERROR; 111, 112; 112, identifier:bases; 113, comparison_operator:in; 113, 114; 113, 117; 113, 120; 114, binary_operator:*; 114, 115; 114, 116; 115, identifier:c; 116, identifier:length; 117, ERROR; 117, 118; 117, 119; 118, identifier:for; 119, identifier:c; 120, identifier:covs; 121, comparison_operator:not; 121, 122; 121, 123; 122, identifier:scaffold; 123, identifier:scaffold2genome; 124, block; 124, 125; 125, continue_statement; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:genome; 129, subscript; 129, 130; 129, 131; 130, identifier:scaffold2genome; 131, identifier:scaffold; 132, if_statement; 132, 133; 132, 136; 133, comparison_operator:not; 133, 134; 133, 135; 134, identifier:genome; 135, identifier:size; 136, block; 136, 137; 136, 143; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:size; 141, identifier:genome; 142, integer:0; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:mapped; 147, identifier:genome; 148, dictionary_comprehension; 148, 149; 148, 152; 149, pair; 149, 150; 149, 151; 150, identifier:sample; 151, integer:0; 152, for_in_clause; 152, 153; 152, 154; 153, identifier:sample; 154, identifier:samples; 155, expression_statement; 155, 156; 156, augmented_assignment:+=; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:size; 159, identifier:genome; 160, identifier:length; 161, for_statement; 161, 162; 161, 165; 161, 170; 162, pattern_list; 162, 163; 162, 164; 163, identifier:sample; 164, identifier:count; 165, call; 165, 166; 165, 167; 166, identifier:zip; 167, argument_list; 167, 168; 167, 169; 168, identifier:samples; 169, identifier:bases; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, augmented_assignment:+=; 172, 173; 172, 178; 173, subscript; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:mapped; 176, identifier:genome; 177, identifier:sample; 178, identifier:count; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:coverage; 182, dictionary; 182, 183; 182, 186; 182, 189; 182, 192; 183, pair; 183, 184; 183, 185; 184, string:'genome'; 185, list:[]; 186, pair; 186, 187; 186, 188; 187, string:'genome size (bp)'; 188, list:[]; 189, pair; 189, 190; 189, 191; 190, string:'sample'; 191, list:[]; 192, pair; 192, 193; 192, 194; 193, string:'coverage'; 194, list:[]; 195, for_statement; 195, 196; 195, 199; 195, 204; 196, pattern_list; 196, 197; 196, 198; 197, identifier:genome; 198, identifier:length; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:size; 202, identifier:items; 203, argument_list; 204, block; 204, 205; 205, for_statement; 205, 206; 205, 207; 205, 208; 206, identifier:sample; 207, identifier:samples; 208, block; 208, 209; 208, 219; 208, 228; 208, 237; 208, 246; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:cov; 212, binary_operator:/; 212, 213; 212, 218; 213, subscript; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:mapped; 216, identifier:genome; 217, identifier:sample; 218, identifier:length; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 226; 221, attribute; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:coverage; 224, string:'genome'; 225, identifier:append; 226, argument_list; 226, 227; 227, identifier:genome; 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:coverage; 233, string:'genome size (bp)'; 234, identifier:append; 235, argument_list; 235, 236; 236, identifier:length; 237, expression_statement; 237, 238; 238, call; 238, 239; 238, 244; 239, attribute; 239, 240; 239, 243; 240, subscript; 240, 241; 240, 242; 241, identifier:coverage; 242, string:'sample'; 243, identifier:append; 244, argument_list; 244, 245; 245, identifier:sample; 246, expression_statement; 246, 247; 247, call; 247, 248; 247, 253; 248, attribute; 248, 249; 248, 252; 249, subscript; 249, 250; 249, 251; 250, identifier:coverage; 251, string:'coverage'; 252, identifier:append; 253, argument_list; 253, 254; 254, identifier:cov; 255, return_statement; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:pd; 259, identifier:DataFrame; 260, argument_list; 260, 261; 261, identifier:coverage | def parse_cov(cov_table, scaffold2genome):
size = {}
mapped = {}
for line in open(cov_table):
line = line.strip().split('\t')
if line[0].startswith('
samples = line[1:]
samples = [i.rsplit('/', 1)[-1].split('.', 1)[0] for i in samples]
continue
scaffold, length = line[0].split(': ')
length = float(length)
covs = [float(i) for i in line[1:]]
bases = [c * length for c in covs]
if scaffold not in scaffold2genome:
continue
genome = scaffold2genome[scaffold]
if genome not in size:
size[genome] = 0
mapped[genome] = {sample:0 for sample in samples}
size[genome] += length
for sample, count in zip(samples, bases):
mapped[genome][sample] += count
coverage = {'genome':[], 'genome size (bp)':[], 'sample':[], 'coverage':[]}
for genome, length in size.items():
for sample in samples:
cov = mapped[genome][sample] / length
coverage['genome'].append(genome)
coverage['genome size (bp)'].append(length)
coverage['sample'].append(sample)
coverage['coverage'].append(cov)
return pd.DataFrame(coverage) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:print_genome_matrix; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:hits; 5, identifier:fastas; 6, identifier:id2desc; 7, identifier:file_name; 8, block; 8, 9; 8, 17; 8, 24; 8, 35; 8, 85; 8, 98; 8, 106; 8, 117; 8, 189; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:out; 12, call; 12, 13; 12, 14; 13, identifier:open; 14, argument_list; 14, 15; 14, 16; 15, identifier:file_name; 16, string:'w'; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:fastas; 20, call; 20, 21; 20, 22; 21, identifier:sorted; 22, argument_list; 22, 23; 23, identifier:fastas; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 25, 31; 25, 33; 26, identifier:print; 27, ERROR; 27, 28; 27, 29; 27, 30; 28, string:'
print('; 29, identifier:fasta; 30, identifier:fastas; 31, type; 31, 32; 32, identifier:line; 33, list:[fasta]; 33, 34; 34, identifier:fasta; 35, for_statement; 35, 36; 35, 37; 35, 38; 36, identifier:other; 37, identifier:fastas; 38, block; 38, 39; 38, 75; 39, if_statement; 39, 40; 39, 43; 39, 48; 40, comparison_operator:==; 40, 41; 40, 42; 41, identifier:other; 42, identifier:fasta; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:average; 47, string:'-'; 48, else_clause; 48, 49; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:average; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:numpy; 56, identifier:average; 57, argument_list; 57, 58; 58, list_comprehension; 58, 59; 58, 68; 59, subscript; 59, 60; 59, 67; 60, subscript; 60, 61; 60, 66; 61, subscript; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:hits; 64, identifier:fasta; 65, identifier:other; 66, identifier:i; 67, integer:3; 68, for_in_clause; 68, 69; 68, 70; 69, identifier:i; 70, subscript; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:hits; 73, identifier:fasta; 74, identifier:other; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:line; 79, identifier:append; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:str; 83, argument_list; 83, 84; 84, identifier:average; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:print; 88, argument_list; 88, 89; 88, 95; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, string:'\t'; 92, identifier:join; 93, argument_list; 93, 94; 94, identifier:line; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:file; 97, identifier:out; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:print; 101, argument_list; 101, 102; 101, 103; 102, string:''; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:file; 105, identifier:out; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 107, 113; 107, 115; 108, identifier:print; 109, ERROR; 109, 110; 109, 111; 109, 112; 110, string:'
print('; 111, identifier:fasta; 112, identifier:fastas; 113, type; 113, 114; 114, identifier:line; 115, list:[fasta]; 115, 116; 116, identifier:fasta; 117, for_statement; 117, 118; 117, 119; 117, 120; 118, identifier:other; 119, identifier:fastas; 120, block; 120, 121; 120, 179; 121, if_statement; 121, 122; 121, 125; 121, 130; 122, comparison_operator:==; 122, 123; 122, 124; 123, identifier:other; 124, identifier:fasta; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:percent; 129, string:'-'; 130, else_clause; 130, 131; 131, block; 131, 132; 131, 146; 131, 168; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:orthologs; 135, call; 135, 136; 135, 137; 136, identifier:float; 137, argument_list; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:len; 140, argument_list; 140, 141; 141, subscript; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:hits; 144, identifier:fasta; 145, identifier:other; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:orfs; 149, call; 149, 150; 149, 151; 150, identifier:float; 151, argument_list; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:len; 154, argument_list; 154, 155; 155, list_comprehension; 155, 156; 155, 157; 155, 160; 156, identifier:i; 157, for_in_clause; 157, 158; 157, 159; 158, identifier:i; 159, identifier:id2desc; 160, if_clause; 160, 161; 161, comparison_operator:==; 161, 162; 161, 167; 162, subscript; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:id2desc; 165, identifier:i; 166, integer:0; 167, identifier:fasta; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:percent; 171, binary_operator:*; 171, 172; 171, 178; 172, call; 172, 173; 172, 174; 173, identifier:float; 174, argument_list; 174, 175; 175, binary_operator:/; 175, 176; 175, 177; 176, identifier:orthologs; 177, identifier:orfs; 178, integer:100; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:line; 183, identifier:append; 184, argument_list; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:str; 187, argument_list; 187, 188; 188, identifier:percent; 189, expression_statement; 189, 190; 190, call; 190, 191; 190, 192; 191, identifier:print; 192, argument_list; 192, 193; 192, 199; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, string:'\t'; 196, identifier:join; 197, argument_list; 197, 198; 198, identifier:line; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:file; 201, identifier:out | def print_genome_matrix(hits, fastas, id2desc, file_name):
out = open(file_name, 'w')
fastas = sorted(fastas)
print('
print('
for fasta in fastas:
line = [fasta]
for other in fastas:
if other == fasta:
average = '-'
else:
average = numpy.average([hits[fasta][other][i][3] for i in hits[fasta][other]])
line.append(str(average))
print('\t'.join(line), file=out)
print('', file=out)
print('
print('
for fasta in fastas:
line = [fasta]
for other in fastas:
if other == fasta:
percent = '-'
else:
orthologs = float(len(hits[fasta][other]))
orfs = float(len([i for i in id2desc if id2desc[i][0] == fasta]))
percent = float(orthologs / orfs) * 100
line.append(str(percent))
print('\t'.join(line), file=out) |
0, module; 0, 1; 1, ERROR; 1, 2; 1, 298; 1, 304; 2, function_definition; 2, 3; 2, 4; 2, 17; 3, function_name:calc_thresholds; 4, parameters; 4, 5; 4, 6; 4, 7; 4, 14; 5, identifier:rbh; 6, identifier:file_name; 7, default_parameter; 7, 8; 7, 9; 8, identifier:thresholds; 9, list:[False, False, False, False]; 9, 10; 9, 11; 9, 12; 9, 13; 10, False; 11, False; 12, False; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:stdevs; 16, integer:2; 17, block; 17, 18; 17, 25; 17, 29; 17, 70; 17, 78; 17, 84; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:calc_threshold; 21, subscript; 21, 22; 21, 23; 22, identifier:thresholds; 23, unary_operator:-; 23, 24; 24, integer:1; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:norm_threshold; 28, dictionary; 29, for_statement; 29, 30; 29, 31; 29, 42; 30, identifier:pair; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:itertools; 34, identifier:permutations; 35, argument_list; 35, 36; 35, 41; 36, list_comprehension; 36, 37; 36, 38; 37, identifier:i; 38, for_in_clause; 38, 39; 38, 40; 39, identifier:i; 40, identifier:rbh; 41, integer:2; 42, block; 42, 43; 42, 58; 43, if_statement; 43, 44; 43, 49; 44, comparison_operator:not; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:pair; 47, integer:0; 48, identifier:norm_threshold; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 57; 52, subscript; 52, 53; 52, 54; 53, identifier:norm_threshold; 54, subscript; 54, 55; 54, 56; 55, identifier:pair; 56, integer:0; 57, dictionary; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 69; 60, subscript; 60, 61; 60, 66; 61, subscript; 61, 62; 61, 63; 62, identifier:norm_threshold; 63, subscript; 63, 64; 63, 65; 64, identifier:pair; 65, integer:0; 66, subscript; 66, 67; 66, 68; 67, identifier:pair; 68, integer:1; 69, dictionary; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:out; 73, call; 73, 74; 73, 75; 74, identifier:open; 75, argument_list; 75, 76; 75, 77; 76, identifier:file_name; 77, string:'w'; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 79, 83; 80, identifier:print; 81, ERROR; 81, 82; 82, identifier:comparisons; 83, list:[]; 84, for_statement; 84, 85; 84, 86; 84, 87; 85, identifier:genome; 86, identifier:rbh; 87, block; 87, 88; 88, for_statement; 88, 89; 88, 90; 88, 93; 89, identifier:compare; 90, subscript; 90, 91; 90, 92; 91, identifier:rbh; 92, identifier:genome; 93, block; 93, 94; 93, 108; 93, 114; 93, 121; 93, 140; 93, 170; 93, 179; 93, 188; 93, 197; 93, 206; 93, 215; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:pair; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, string:''; 100, identifier:join; 101, argument_list; 101, 102; 102, call; 102, 103; 102, 104; 103, identifier:sorted; 104, argument_list; 104, 105; 105, list:[genome, compare]; 105, 106; 105, 107; 106, identifier:genome; 107, identifier:compare; 108, if_statement; 108, 109; 108, 112; 109, comparison_operator:in; 109, 110; 109, 111; 110, identifier:pair; 111, identifier:comparisons; 112, block; 112, 113; 113, continue_statement; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:comparisons; 118, identifier:append; 119, argument_list; 119, 120; 120, identifier:pair; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:scores; 124, dictionary; 124, 125; 124, 128; 124, 131; 124, 134; 124, 137; 125, pair; 125, 126; 125, 127; 126, string:'percent identity'; 127, list:[]; 128, pair; 128, 129; 128, 130; 129, string:'e-value'; 130, list:[]; 131, pair; 131, 132; 131, 133; 132, string:'bit score'; 133, list:[]; 134, pair; 134, 135; 134, 136; 135, string:'normalized bit score'; 136, list:[]; 137, pair; 137, 138; 137, 139; 138, string:'alignment length fraction'; 139, list:[]; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 159; 142, pattern_list; 142, 143; 142, 144; 142, 155; 142, 156; 142, 157; 142, 158; 143, identifier:print; 144, ERROR; 144, 145; 144, 147; 144, 154; 145, ERROR; 145, 146; 146, identifier:for; 147, comparison_operator:in; 147, 148; 147, 149; 148, identifier:id; 149, subscript; 149, 150; 149, 153; 150, subscript; 150, 151; 150, 152; 151, identifier:rbh; 152, identifier:genome; 153, identifier:compare; 154, identifier:pident; 155, identifier:length_fraction; 156, identifier:e; 157, identifier:bit; 158, identifier:norm_bit; 159, subscript; 159, 160; 159, 167; 160, subscript; 160, 161; 160, 166; 161, subscript; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:rbh; 164, identifier:genome; 165, identifier:compare; 166, identifier:id; 167, slice; 167, 168; 167, 169; 168, integer:3; 169, colon; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 177; 172, attribute; 172, 173; 172, 176; 173, subscript; 173, 174; 173, 175; 174, identifier:scores; 175, string:'percent identity'; 176, identifier:append; 177, argument_list; 177, 178; 178, identifier:pident; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 186; 181, attribute; 181, 182; 181, 185; 182, subscript; 182, 183; 182, 184; 183, identifier:scores; 184, string:'alignment length fraction'; 185, identifier:append; 186, argument_list; 186, 187; 187, identifier:length_fraction; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 195; 190, attribute; 190, 191; 190, 194; 191, subscript; 191, 192; 191, 193; 192, identifier:scores; 193, string:'e-value'; 194, identifier:append; 195, argument_list; 195, 196; 196, identifier:e; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 204; 199, attribute; 199, 200; 199, 203; 200, subscript; 200, 201; 200, 202; 201, identifier:scores; 202, string:'bit score'; 203, identifier:append; 204, argument_list; 204, 205; 205, identifier:bit; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 213; 208, attribute; 208, 209; 208, 212; 209, subscript; 209, 210; 209, 211; 210, identifier:scores; 211, string:'normalized bit score'; 212, identifier:append; 213, argument_list; 213, 214; 214, identifier:norm_bit; 215, if_statement; 215, 216; 215, 219; 215, 287; 216, comparison_operator:is; 216, 217; 216, 218; 217, identifier:calc_threshold; 218, True; 219, ERROR; 219, 220; 219, 226; 219, 235; 219, 244; 219, 253; 219, 254; 219, 256; 219, 257; 219, 262; 219, 267; 219, 269; 219, 276; 219, 277; 219, 279; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:norms; 223, subscript; 223, 224; 223, 225; 224, identifier:scores; 225, string:'normalized bit score'; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:average; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:numpy; 232, identifier:average; 233, argument_list; 233, 234; 234, identifier:norms; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:std; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:numpy; 241, identifier:std; 242, argument_list; 242, 243; 243, identifier:norms; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 247; 246, identifier:normal_thresh; 247, binary_operator:-; 247, 248; 247, 249; 248, identifier:average; 249, parenthesized_expression; 249, 250; 250, binary_operator:*; 250, 251; 250, 252; 251, identifier:std; 252, identifier:stdevs; 253, string:'
print('; 254, ERROR; 254, 255; 255, identifier:print; 256, ERROR; 257, subscript; 257, 258; 257, 261; 258, subscript; 258, 259; 258, 260; 259, identifier:norm_threshold; 260, identifier:genome; 261, identifier:compare; 262, subscript; 262, 263; 262, 266; 263, subscript; 263, 264; 263, 265; 264, identifier:norm_threshold; 265, identifier:compare; 266, identifier:genome; 267, ERROR; 267, 268; 268, identifier:normal_thresh; 269, ERROR; 269, 270; 270, comparison_operator:in; 270, 271; 270, 272; 270, 275; 271, identifier:normal_thresh; 272, ERROR; 272, 273; 272, 274; 273, identifier:for; 274, identifier:score; 275, identifier:scores; 276, identifier:print; 277, ERROR; 277, 278; 278, identifier:if; 279, comparison_operator:>; 279, 280; 279, 286; 280, call; 280, 281; 280, 282; 281, identifier:len; 282, argument_list; 282, 283; 283, subscript; 283, 284; 283, 285; 284, identifier:scores; 285, identifier:score; 286, integer:0; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, call; 289, 290; 289, 291; 290, identifier:print; 291, argument_list; 291, 292; 291, 295; 292, concatenated_string; 292, 293; 292, 294; 293, string:'
print('; 294, string:'; 295, keyword_argument; 295, 296; 295, 297; 296, identifier:file; 297, identifier:out; 298, expression_statement; 298, 299; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:out; 302, identifier:close; 303, argument_list; 304, if_statement; 304, 305; 304, 308; 304, 320; 305, comparison_operator:is; 305, 306; 305, 307; 306, identifier:calc_threshold; 307, True; 308, block; 308, 309; 309, return_statement; 309, 310; 310, binary_operator:+; 310, 311; 310, 318; 311, subscript; 311, 312; 311, 313; 312, identifier:thresholds; 313, slice; 313, 314; 313, 315; 313, 316; 314, integer:0; 315, colon; 316, unary_operator:-; 316, 317; 317, integer:1; 318, list:[norm_threshold]; 318, 319; 319, identifier:norm_threshold; 320, else_clause; 320, 321; 321, block; 321, 322; 322, return_statement; 322, 323; 323, identifier:thresholds | def calc_thresholds(rbh, file_name, thresholds = [False, False, False, False], stdevs = 2):
calc_threshold = thresholds[-1]
norm_threshold = {}
for pair in itertools.permutations([i for i in rbh], 2):
if pair[0] not in norm_threshold:
norm_threshold[pair[0]] = {}
norm_threshold[pair[0]][pair[1]] = {}
out = open(file_name, 'w')
print('
comparisons = []
for genome in rbh:
for compare in rbh[genome]:
pair = ''.join(sorted([genome, compare]))
if pair in comparisons:
continue
comparisons.append(pair)
scores = {'percent identity': [], 'e-value': [], 'bit score': [], 'normalized bit score': [], 'alignment length fraction': []}
print('
for id in rbh[genome][compare]:
pident, length_fraction, e, bit, norm_bit = rbh[genome][compare][id][3:]
scores['percent identity'].append(pident)
scores['alignment length fraction'].append(length_fraction)
scores['e-value'].append(e)
scores['bit score'].append(bit)
scores['normalized bit score'].append(norm_bit)
if calc_threshold is True:
norms = scores['normalized bit score']
average = numpy.average(norms)
std = numpy.std(norms)
normal_thresh = average - (std * stdevs)
print('
print('
print('
norm_threshold[genome][compare], norm_threshold[compare][genome] = normal_thresh, normal_thresh
for score in scores:
print('
if len(scores[score]) > 0:
print('
print('', file=out)
out.close()
if calc_threshold is True:
return thresholds[0:-1] + [norm_threshold]
else:
return thresholds |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_update_property; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:tree_to_update; 5, identifier:xpath_root; 6, identifier:xpaths; 7, identifier:values; 8, block; 8, 9; 8, 234; 8, 241; 8, 248; 9, function_definition; 9, 10; 9, 11; 9, 17; 10, function_name:update_element; 11, parameters; 11, 12; 11, 13; 11, 14; 11, 15; 11, 16; 12, identifier:elem; 13, identifier:idx; 14, identifier:root; 15, identifier:path; 16, identifier:vals; 17, block; 17, 18; 17, 42; 17, 51; 17, 118; 17, 124; 17, 128; 17, 232; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:has_root; 21, call; 21, 22; 21, 23; 22, identifier:bool; 23, argument_list; 23, 24; 24, boolean_operator:and; 24, 25; 24, 36; 25, boolean_operator:and; 25, 26; 25, 27; 26, identifier:root; 27, comparison_operator:>; 27, 28; 27, 32; 28, call; 28, 29; 28, 30; 29, identifier:len; 30, argument_list; 30, 31; 31, identifier:path; 32, call; 32, 33; 32, 34; 33, identifier:len; 34, argument_list; 34, 35; 35, identifier:root; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:path; 39, identifier:startswith; 40, argument_list; 40, 41; 41, identifier:root; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, pattern_list; 44, 45; 44, 46; 45, identifier:path; 46, identifier:attr; 47, call; 47, 48; 47, 49; 48, identifier:get_xpath_tuple; 49, argument_list; 49, 50; 50, identifier:path; 51, if_statement; 51, 52; 51, 53; 51, 71; 51, 86; 52, identifier:attr; 53, block; 53, 54; 53, 63; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:removed; 57, list:[get_element(elem, path)]; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:get_element; 60, argument_list; 60, 61; 60, 62; 61, identifier:elem; 62, identifier:path; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:remove_element_attributes; 66, argument_list; 66, 67; 66, 70; 67, subscript; 67, 68; 67, 69; 68, identifier:removed; 69, integer:0; 70, identifier:attr; 71, elif_clause; 71, 72; 71, 74; 72, not_operator; 72, 73; 73, identifier:has_root; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:removed; 78, call; 78, 79; 78, 80; 79, identifier:wrap_value; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:remove_element; 83, argument_list; 83, 84; 83, 85; 84, identifier:elem; 85, identifier:path; 86, else_clause; 86, 87; 87, block; 87, 88; 87, 96; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:path; 91, call; 91, 92; 91, 93; 92, identifier:get_xpath_branch; 93, argument_list; 93, 94; 93, 95; 94, identifier:root; 95, identifier:path; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:removed; 99, conditional_expression:if; 99, 100; 99, 101; 99, 104; 100, list:[]; 101, comparison_operator:!=; 101, 102; 101, 103; 102, identifier:idx; 103, integer:0; 104, list_comprehension; 104, 105; 104, 111; 105, call; 105, 106; 105, 107; 106, identifier:remove_element; 107, argument_list; 107, 108; 107, 109; 107, 110; 108, identifier:e; 109, identifier:path; 110, True; 111, for_in_clause; 111, 112; 111, 113; 112, identifier:e; 113, call; 113, 114; 113, 115; 114, identifier:get_elements; 115, argument_list; 115, 116; 115, 117; 116, identifier:elem; 117, identifier:root; 118, if_statement; 118, 119; 118, 121; 119, not_operator; 119, 120; 120, identifier:vals; 121, block; 121, 122; 122, return_statement; 122, 123; 123, identifier:removed; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:items; 127, list:[]; 128, for_statement; 128, 129; 128, 132; 128, 139; 129, pattern_list; 129, 130; 129, 131; 130, identifier:i; 131, identifier:val; 132, call; 132, 133; 132, 134; 133, identifier:enumerate; 134, argument_list; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:wrap_value; 137, argument_list; 137, 138; 138, identifier:vals; 139, block; 139, 140; 139, 144; 139, 159; 139, 176; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:elem_to_update; 143, identifier:elem; 144, if_statement; 144, 145; 144, 146; 145, identifier:has_root; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:elem_to_update; 150, call; 150, 151; 150, 152; 151, identifier:insert_element; 152, argument_list; 152, 153; 152, 154; 152, 158; 153, identifier:elem; 154, parenthesized_expression; 154, 155; 155, binary_operator:+; 155, 156; 155, 157; 156, identifier:i; 157, identifier:idx; 158, identifier:root; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:val; 162, conditional_expression:if; 162, 163; 162, 169; 162, 175; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:val; 166, identifier:decode; 167, argument_list; 167, 168; 168, string:'utf-8'; 169, not_operator; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:isinstance; 172, argument_list; 172, 173; 172, 174; 173, identifier:val; 174, identifier:string_types; 175, identifier:val; 176, if_statement; 176, 177; 176, 179; 176, 193; 176, 213; 177, not_operator; 177, 178; 178, identifier:attr; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:items; 184, identifier:append; 185, argument_list; 185, 186; 186, call; 186, 187; 186, 188; 187, identifier:insert_element; 188, argument_list; 188, 189; 188, 190; 188, 191; 188, 192; 189, identifier:elem_to_update; 190, identifier:i; 191, identifier:path; 192, identifier:val; 193, elif_clause; 193, 194; 193, 195; 194, identifier:path; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:items; 200, identifier:append; 201, argument_list; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:insert_element; 204, argument_list; 204, 205; 204, 206; 204, 207; 204, 208; 205, identifier:elem_to_update; 206, identifier:i; 207, identifier:path; 208, dictionary_splat; 208, 209; 209, dictionary; 209, 210; 210, pair; 210, 211; 210, 212; 211, identifier:attr; 212, identifier:val; 213, else_clause; 213, 214; 214, block; 214, 215; 214, 225; 215, expression_statement; 215, 216; 216, call; 216, 217; 216, 218; 217, identifier:set_element_attributes; 218, argument_list; 218, 219; 218, 220; 219, identifier:elem_to_update; 220, dictionary_splat; 220, 221; 221, dictionary; 221, 222; 222, pair; 222, 223; 222, 224; 223, identifier:attr; 224, identifier:val; 225, expression_statement; 225, 226; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:items; 229, identifier:append; 230, argument_list; 230, 231; 231, identifier:elem_to_update; 232, return_statement; 232, 233; 233, identifier:items; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:xpaths; 237, call; 237, 238; 237, 239; 238, identifier:reduce_value; 239, argument_list; 239, 240; 240, identifier:xpaths; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:values; 244, call; 244, 245; 244, 246; 245, identifier:filter_empty; 246, argument_list; 246, 247; 247, identifier:values; 248, if_statement; 248, 249; 248, 254; 248, 264; 249, call; 249, 250; 249, 251; 250, identifier:isinstance; 251, argument_list; 251, 252; 251, 253; 252, identifier:xpaths; 253, identifier:string_types; 254, block; 254, 255; 255, return_statement; 255, 256; 256, call; 256, 257; 256, 258; 257, identifier:update_element; 258, argument_list; 258, 259; 258, 260; 258, 261; 258, 262; 258, 263; 259, identifier:tree_to_update; 260, integer:0; 261, identifier:xpath_root; 262, identifier:xpaths; 263, identifier:values; 264, else_clause; 264, 265; 265, block; 265, 266; 265, 270; 265, 302; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:each; 269, list:[]; 270, for_statement; 270, 271; 270, 274; 270, 278; 271, pattern_list; 271, 272; 271, 273; 272, identifier:index; 273, identifier:xpath; 274, call; 274, 275; 274, 276; 275, identifier:enumerate; 276, argument_list; 276, 277; 277, identifier:xpaths; 278, block; 278, 279; 278, 288; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:value; 282, conditional_expression:if; 282, 283; 282, 286; 282, 287; 283, subscript; 283, 284; 283, 285; 284, identifier:values; 285, identifier:index; 286, identifier:values; 287, None; 288, expression_statement; 288, 289; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:each; 292, identifier:extend; 293, argument_list; 293, 294; 294, call; 294, 295; 294, 296; 295, identifier:update_element; 296, argument_list; 296, 297; 296, 298; 296, 299; 296, 300; 296, 301; 297, identifier:tree_to_update; 298, identifier:index; 299, identifier:xpath_root; 300, identifier:xpath; 301, identifier:value; 302, return_statement; 302, 303; 303, identifier:each | def _update_property(tree_to_update, xpath_root, xpaths, values):
def update_element(elem, idx, root, path, vals):
has_root = bool(root and len(path) > len(root) and path.startswith(root))
path, attr = get_xpath_tuple(path)
if attr:
removed = [get_element(elem, path)]
remove_element_attributes(removed[0], attr)
elif not has_root:
removed = wrap_value(remove_element(elem, path))
else:
path = get_xpath_branch(root, path)
removed = [] if idx != 0 else [remove_element(e, path, True) for e in get_elements(elem, root)]
if not vals:
return removed
items = []
for i, val in enumerate(wrap_value(vals)):
elem_to_update = elem
if has_root:
elem_to_update = insert_element(elem, (i + idx), root)
val = val.decode('utf-8') if not isinstance(val, string_types) else val
if not attr:
items.append(insert_element(elem_to_update, i, path, val))
elif path:
items.append(insert_element(elem_to_update, i, path, **{attr: val}))
else:
set_element_attributes(elem_to_update, **{attr: val})
items.append(elem_to_update)
return items
xpaths = reduce_value(xpaths)
values = filter_empty(values)
if isinstance(xpaths, string_types):
return update_element(tree_to_update, 0, xpath_root, xpaths, values)
else:
each = []
for index, xpath in enumerate(xpaths):
value = values[index] if values else None
each.extend(update_element(tree_to_update, index, xpath_root, xpath, value))
return each |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:validate_complex_list; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:prop; 5, identifier:value; 6, default_parameter; 6, 7; 6, 8; 7, identifier:xpath_map; 8, None; 9, block; 9, 10; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:value; 13, None; 14, block; 14, 15; 14, 24; 14, 46; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:validate_type; 18, argument_list; 18, 19; 18, 20; 18, 21; 19, identifier:prop; 20, identifier:value; 21, tuple; 21, 22; 21, 23; 22, identifier:dict; 23, identifier:list; 24, if_statement; 24, 25; 24, 28; 24, 35; 25, comparison_operator:in; 25, 26; 25, 27; 26, identifier:prop; 27, identifier:_complex_definitions; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:complex_keys; 32, subscript; 32, 33; 32, 34; 33, identifier:_complex_definitions; 34, identifier:prop; 35, else_clause; 35, 36; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:complex_keys; 40, conditional_expression:if; 40, 41; 40, 42; 40, 45; 41, dictionary; 42, comparison_operator:is; 42, 43; 42, 44; 43, identifier:xpath_map; 44, None; 45, identifier:xpath_map; 46, for_statement; 46, 47; 46, 50; 46, 57; 47, pattern_list; 47, 48; 47, 49; 48, identifier:idx; 49, identifier:complex_struct; 50, call; 50, 51; 50, 52; 51, identifier:enumerate; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:wrap_value; 55, argument_list; 55, 56; 56, identifier:value; 57, block; 57, 58; 57, 71; 57, 78; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:cs_idx; 61, binary_operator:+; 61, 62; 61, 70; 62, binary_operator:+; 62, 63; 62, 66; 63, binary_operator:+; 63, 64; 63, 65; 64, identifier:prop; 65, string:'['; 66, call; 66, 67; 66, 68; 67, identifier:str; 68, argument_list; 68, 69; 69, identifier:idx; 70, string:']'; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:validate_type; 74, argument_list; 74, 75; 74, 76; 74, 77; 75, identifier:cs_idx; 76, identifier:complex_struct; 77, identifier:dict; 78, for_statement; 78, 79; 78, 82; 78, 86; 79, pattern_list; 79, 80; 79, 81; 80, identifier:cs_prop; 81, identifier:cs_val; 82, call; 82, 83; 82, 84; 83, identifier:iteritems; 84, argument_list; 84, 85; 85, identifier:complex_struct; 86, block; 86, 87; 86, 98; 86, 122; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:cs_key; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, string:'.'; 93, identifier:join; 94, argument_list; 94, 95; 95, tuple; 95, 96; 95, 97; 96, identifier:cs_idx; 97, identifier:cs_prop; 98, if_statement; 98, 99; 98, 102; 99, comparison_operator:not; 99, 100; 99, 101; 100, identifier:cs_prop; 101, identifier:complex_keys; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:_validation_error; 106, argument_list; 106, 107; 106, 108; 106, 109; 106, 110; 107, identifier:prop; 108, None; 109, identifier:value; 110, parenthesized_expression; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, string:'keys: {0}'; 114, identifier:format; 115, argument_list; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, string:','; 119, identifier:join; 120, argument_list; 120, 121; 121, identifier:complex_keys; 122, if_statement; 122, 123; 122, 129; 122, 139; 123, not_operator; 123, 124; 124, call; 124, 125; 124, 126; 125, identifier:isinstance; 126, argument_list; 126, 127; 126, 128; 127, identifier:cs_val; 128, identifier:list; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 133; 132, identifier:validate_type; 133, argument_list; 133, 134; 133, 135; 133, 136; 134, identifier:cs_key; 135, identifier:cs_val; 136, tuple; 136, 137; 136, 138; 137, identifier:string_types; 138, identifier:list; 139, else_clause; 139, 140; 140, block; 140, 141; 141, for_statement; 141, 142; 141, 145; 141, 149; 142, pattern_list; 142, 143; 142, 144; 143, identifier:list_idx; 144, identifier:list_val; 145, call; 145, 146; 145, 147; 146, identifier:enumerate; 147, argument_list; 147, 148; 148, identifier:cs_val; 149, block; 149, 150; 149, 163; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:list_prop; 153, binary_operator:+; 153, 154; 153, 162; 154, binary_operator:+; 154, 155; 154, 158; 155, binary_operator:+; 155, 156; 155, 157; 156, identifier:cs_key; 157, string:'['; 158, call; 158, 159; 158, 160; 159, identifier:str; 160, argument_list; 160, 161; 161, identifier:list_idx; 162, string:']'; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 166; 165, identifier:validate_type; 166, argument_list; 166, 167; 166, 168; 166, 169; 167, identifier:list_prop; 168, identifier:list_val; 169, identifier:string_types | def validate_complex_list(prop, value, xpath_map=None):
if value is not None:
validate_type(prop, value, (dict, list))
if prop in _complex_definitions:
complex_keys = _complex_definitions[prop]
else:
complex_keys = {} if xpath_map is None else xpath_map
for idx, complex_struct in enumerate(wrap_value(value)):
cs_idx = prop + '[' + str(idx) + ']'
validate_type(cs_idx, complex_struct, dict)
for cs_prop, cs_val in iteritems(complex_struct):
cs_key = '.'.join((cs_idx, cs_prop))
if cs_prop not in complex_keys:
_validation_error(prop, None, value, ('keys: {0}'.format(','.join(complex_keys))))
if not isinstance(cs_val, list):
validate_type(cs_key, cs_val, (string_types, list))
else:
for list_idx, list_val in enumerate(cs_val):
list_prop = cs_key + '[' + str(list_idx) + ']'
validate_type(list_prop, list_val, string_types) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:validate_dates; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:prop; 5, identifier:value; 6, default_parameter; 6, 7; 6, 8; 7, identifier:xpath_map; 8, None; 9, block; 9, 10; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:value; 13, None; 14, block; 14, 15; 14, 22; 14, 29; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:validate_type; 18, argument_list; 18, 19; 18, 20; 18, 21; 19, identifier:prop; 20, identifier:value; 21, identifier:dict; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:date_keys; 25, call; 25, 26; 25, 27; 26, identifier:set; 27, argument_list; 27, 28; 28, identifier:value; 29, if_statement; 29, 30; 29, 31; 30, identifier:date_keys; 31, block; 31, 32; 31, 84; 31, 90; 31, 103; 31, 109; 31, 116; 31, 123; 31, 140; 31, 157; 31, 174; 31, 191; 32, if_statement; 32, 33; 32, 40; 33, boolean_operator:or; 33, 34; 33, 37; 34, comparison_operator:not; 34, 35; 34, 36; 35, identifier:DATE_TYPE; 36, identifier:date_keys; 37, comparison_operator:not; 37, 38; 37, 39; 38, identifier:DATE_VALUES; 39, identifier:date_keys; 40, block; 40, 41; 40, 65; 41, if_statement; 41, 42; 41, 45; 41, 52; 42, comparison_operator:in; 42, 43; 42, 44; 43, identifier:prop; 44, identifier:_complex_definitions; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:complex_keys; 49, subscript; 49, 50; 49, 51; 50, identifier:_complex_definitions; 51, identifier:prop; 52, else_clause; 52, 53; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:complex_keys; 57, conditional_expression:if; 57, 58; 57, 61; 57, 64; 58, subscript; 58, 59; 58, 60; 59, identifier:_complex_definitions; 60, identifier:DATES; 61, comparison_operator:is; 61, 62; 61, 63; 62, identifier:xpath_map; 63, None; 64, identifier:xpath_map; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:_validation_error; 68, argument_list; 68, 69; 68, 70; 68, 71; 68, 72; 69, identifier:prop; 70, None; 71, identifier:value; 72, parenthesized_expression; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, string:'keys: {0}'; 76, identifier:format; 77, argument_list; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, string:','; 81, identifier:join; 82, argument_list; 82, 83; 83, identifier:complex_keys; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:date_type; 87, subscript; 87, 88; 87, 89; 88, identifier:value; 89, identifier:DATE_TYPE; 90, if_statement; 90, 91; 90, 94; 91, comparison_operator:not; 91, 92; 91, 93; 92, identifier:date_type; 93, identifier:DATE_TYPES; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:_validation_error; 98, argument_list; 98, 99; 98, 100; 98, 101; 98, 102; 99, string:'dates.type'; 100, None; 101, identifier:date_type; 102, identifier:DATE_TYPES; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:date_vals; 106, subscript; 106, 107; 106, 108; 107, identifier:value; 108, identifier:DATE_VALUES; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:validate_type; 112, argument_list; 112, 113; 112, 114; 112, 115; 113, string:'dates.values'; 114, identifier:date_vals; 115, identifier:list; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:dates_len; 119, call; 119, 120; 119, 121; 120, identifier:len; 121, argument_list; 121, 122; 122, identifier:date_vals; 123, if_statement; 123, 124; 123, 131; 124, boolean_operator:and; 124, 125; 124, 128; 125, comparison_operator:==; 125, 126; 125, 127; 126, identifier:date_type; 127, identifier:DATE_TYPE_MISSING; 128, comparison_operator:!=; 128, 129; 128, 130; 129, identifier:dates_len; 130, integer:0; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 135; 134, identifier:_validation_error; 135, argument_list; 135, 136; 135, 137; 135, 138; 135, 139; 136, string:'len(dates.values)'; 137, None; 138, identifier:dates_len; 139, integer:0; 140, if_statement; 140, 141; 140, 148; 141, boolean_operator:and; 141, 142; 141, 145; 142, comparison_operator:==; 142, 143; 142, 144; 143, identifier:date_type; 144, identifier:DATE_TYPE_SINGLE; 145, comparison_operator:!=; 145, 146; 145, 147; 146, identifier:dates_len; 147, integer:1; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:_validation_error; 152, argument_list; 152, 153; 152, 154; 152, 155; 152, 156; 153, string:'len(dates.values)'; 154, None; 155, identifier:dates_len; 156, integer:1; 157, if_statement; 157, 158; 157, 165; 158, boolean_operator:and; 158, 159; 158, 162; 159, comparison_operator:==; 159, 160; 159, 161; 160, identifier:date_type; 161, identifier:DATE_TYPE_RANGE; 162, comparison_operator:!=; 162, 163; 162, 164; 163, identifier:dates_len; 164, integer:2; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 169; 168, identifier:_validation_error; 169, argument_list; 169, 170; 169, 171; 169, 172; 169, 173; 170, string:'len(dates.values)'; 171, None; 172, identifier:dates_len; 173, integer:2; 174, if_statement; 174, 175; 174, 182; 175, boolean_operator:and; 175, 176; 175, 179; 176, comparison_operator:==; 176, 177; 176, 178; 177, identifier:date_type; 178, identifier:DATE_TYPE_MULTIPLE; 179, comparison_operator:<; 179, 180; 179, 181; 180, identifier:dates_len; 181, integer:2; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 186; 185, identifier:_validation_error; 186, argument_list; 186, 187; 186, 188; 186, 189; 186, 190; 187, string:'len(dates.values)'; 188, None; 189, identifier:dates_len; 190, string:'at least two'; 191, for_statement; 191, 192; 191, 195; 191, 199; 192, pattern_list; 192, 193; 192, 194; 193, identifier:idx; 194, identifier:date; 195, call; 195, 196; 195, 197; 196, identifier:enumerate; 197, argument_list; 197, 198; 198, identifier:date_vals; 199, block; 199, 200; 199, 211; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:date_key; 203, binary_operator:+; 203, 204; 203, 210; 204, binary_operator:+; 204, 205; 204, 206; 205, string:'dates.value['; 206, call; 206, 207; 206, 208; 207, identifier:str; 208, argument_list; 208, 209; 209, identifier:idx; 210, string:']'; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 214; 213, identifier:validate_type; 214, argument_list; 214, 215; 214, 216; 214, 217; 215, identifier:date_key; 216, identifier:date; 217, identifier:string_types | def validate_dates(prop, value, xpath_map=None):
if value is not None:
validate_type(prop, value, dict)
date_keys = set(value)
if date_keys:
if DATE_TYPE not in date_keys or DATE_VALUES not in date_keys:
if prop in _complex_definitions:
complex_keys = _complex_definitions[prop]
else:
complex_keys = _complex_definitions[DATES] if xpath_map is None else xpath_map
_validation_error(prop, None, value, ('keys: {0}'.format(','.join(complex_keys))))
date_type = value[DATE_TYPE]
if date_type not in DATE_TYPES:
_validation_error('dates.type', None, date_type, DATE_TYPES)
date_vals = value[DATE_VALUES]
validate_type('dates.values', date_vals, list)
dates_len = len(date_vals)
if date_type == DATE_TYPE_MISSING and dates_len != 0:
_validation_error('len(dates.values)', None, dates_len, 0)
if date_type == DATE_TYPE_SINGLE and dates_len != 1:
_validation_error('len(dates.values)', None, dates_len, 1)
if date_type == DATE_TYPE_RANGE and dates_len != 2:
_validation_error('len(dates.values)', None, dates_len, 2)
if date_type == DATE_TYPE_MULTIPLE and dates_len < 2:
_validation_error('len(dates.values)', None, dates_len, 'at least two')
for idx, date in enumerate(date_vals):
date_key = 'dates.value[' + str(idx) + ']'
validate_type(date_key, date, string_types) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:getCharacterSet; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 12; 5, 16; 5, 20; 5, 24; 5, 236; 6, expression_statement; 6, 7; 7, string:'''Get a character set with individual members or ranges.
Current index is on '[', the start of the character set.
'''; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:chars; 11, string:u''; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:c; 15, None; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:cnt; 19, integer:1; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:start; 23, integer:0; 24, while_statement; 24, 25; 24, 26; 25, True; 26, block; 26, 27; 26, 31; 26, 39; 26, 168; 26, 204; 26, 231; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:escaped_slash; 30, False; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:c; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:next; 38, argument_list; 39, if_statement; 39, 40; 39, 52; 39, 99; 39, 155; 40, boolean_operator:and; 40, 41; 40, 48; 41, comparison_operator:==; 41, 42; 41, 47; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:lookahead; 46, argument_list; 47, string:u'-'; 48, not_operator; 48, 49; 49, comparison_operator:==; 49, 50; 49, 51; 50, identifier:c; 51, string:u'\\'; 52, block; 52, 53; 52, 57; 52, 63; 52, 71; 52, 89; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:f; 56, identifier:c; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:next; 62, argument_list; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:c; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:next; 70, argument_list; 71, if_statement; 71, 72; 71, 81; 72, boolean_operator:or; 72, 73; 72, 75; 73, not_operator; 73, 74; 74, identifier:c; 75, parenthesized_expression; 75, 76; 76, comparison_operator:in; 76, 77; 76, 78; 77, identifier:c; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:meta_chars; 81, block; 81, 82; 82, raise_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:StringGenerator; 86, identifier:SyntaxError; 87, argument_list; 87, 88; 88, string:u"unexpected end of class range"; 89, expression_statement; 89, 90; 90, augmented_assignment:+=; 90, 91; 90, 92; 91, identifier:chars; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:getCharacterRange; 96, argument_list; 96, 97; 96, 98; 97, identifier:f; 98, identifier:c; 99, elif_clause; 99, 100; 99, 103; 100, comparison_operator:==; 100, 101; 100, 102; 101, identifier:c; 102, string:u'\\'; 103, block; 103, 104; 104, if_statement; 104, 105; 104, 114; 104, 128; 105, comparison_operator:in; 105, 106; 105, 111; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:lookahead; 110, argument_list; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:meta_chars; 114, block; 114, 115; 114, 123; 114, 127; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:c; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:next; 122, argument_list; 123, expression_statement; 123, 124; 124, augmented_assignment:+=; 124, 125; 124, 126; 125, identifier:chars; 126, identifier:c; 127, continue_statement; 128, elif_clause; 128, 129; 128, 138; 129, comparison_operator:in; 129, 130; 129, 135; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:lookahead; 134, argument_list; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:string_code; 138, block; 138, 139; 138, 147; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:c; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:next; 146, argument_list; 147, expression_statement; 147, 148; 148, augmented_assignment:+=; 148, 149; 148, 150; 149, identifier:chars; 150, subscript; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:string_code; 154, identifier:c; 155, elif_clause; 155, 156; 155, 163; 156, boolean_operator:and; 156, 157; 156, 158; 157, identifier:c; 158, comparison_operator:not; 158, 159; 158, 160; 159, identifier:c; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:meta_chars; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, augmented_assignment:+=; 165, 166; 165, 167; 166, identifier:chars; 167, identifier:c; 168, if_statement; 168, 169; 168, 172; 169, comparison_operator:==; 169, 170; 169, 171; 170, identifier:c; 171, string:u']'; 172, block; 172, 173; 172, 203; 173, if_statement; 173, 174; 173, 181; 173, 192; 174, comparison_operator:==; 174, 175; 174, 180; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:lookahead; 179, argument_list; 180, string:u'{'; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 187; 184, list_pattern; 184, 185; 184, 186; 185, identifier:start; 186, identifier:cnt; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:self; 190, identifier:getQuantifier; 191, argument_list; 192, else_clause; 192, 193; 193, block; 193, 194; 193, 199; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:start; 197, unary_operator:-; 197, 198; 198, integer:1; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:cnt; 202, integer:1; 203, break_statement; 204, if_statement; 204, 205; 204, 221; 205, boolean_operator:and; 205, 206; 205, 213; 206, boolean_operator:and; 206, 207; 206, 208; 207, identifier:c; 208, comparison_operator:in; 208, 209; 208, 210; 209, identifier:c; 210, attribute; 210, 211; 210, 212; 211, identifier:self; 212, identifier:meta_chars; 213, not_operator; 213, 214; 214, comparison_operator:==; 214, 215; 214, 220; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:last; 219, argument_list; 220, string:u"\\"; 221, block; 221, 222; 222, raise_statement; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:StringGenerator; 226, identifier:SyntaxError; 227, argument_list; 227, 228; 228, binary_operator:%; 228, 229; 228, 230; 229, string:u"Un-escaped character in class definition: %s"; 230, identifier:c; 231, if_statement; 231, 232; 231, 234; 232, not_operator; 232, 233; 233, identifier:c; 234, block; 234, 235; 235, break_statement; 236, return_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:StringGenerator; 240, identifier:CharacterSet; 241, argument_list; 241, 242; 241, 243; 241, 244; 242, identifier:chars; 243, identifier:start; 244, identifier:cnt | def getCharacterSet(self):
'''Get a character set with individual members or ranges.
Current index is on '[', the start of the character set.
'''
chars = u''
c = None
cnt = 1
start = 0
while True:
escaped_slash = False
c = self.next()
if self.lookahead() == u'-' and not c == u'\\':
f = c
self.next()
c = self.next()
if not c or (c in self.meta_chars):
raise StringGenerator.SyntaxError(u"unexpected end of class range")
chars += self.getCharacterRange(f, c)
elif c == u'\\':
if self.lookahead() in self.meta_chars:
c = self.next()
chars += c
continue
elif self.lookahead() in self.string_code:
c = self.next()
chars += self.string_code[c]
elif c and c not in self.meta_chars:
chars += c
if c == u']':
if self.lookahead() == u'{':
[start, cnt] = self.getQuantifier()
else:
start = -1
cnt = 1
break
if c and c in self.meta_chars and not self.last() == u"\\":
raise StringGenerator.SyntaxError(u"Un-escaped character in class definition: %s" % c)
if not c:
break
return StringGenerator.CharacterSet(chars, start, cnt) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:getSequence; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:level; 7, integer:0; 8, block; 8, 9; 8, 11; 8, 15; 8, 19; 8, 23; 8, 27; 8, 31; 8, 344; 8, 356; 8, 371; 9, expression_statement; 9, 10; 10, string:'''Get a sequence of nodes.'''; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:seq; 14, list:[]; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:op; 18, string:''; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:left_operand; 22, None; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:right_operand; 26, None; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:sequence_closed; 30, False; 31, while_statement; 31, 32; 31, 33; 32, True; 33, block; 33, 34; 33, 42; 33, 47; 33, 240; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:c; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:next; 41, argument_list; 42, if_statement; 42, 43; 42, 45; 43, not_operator; 43, 44; 44, identifier:c; 45, block; 45, 46; 46, break_statement; 47, if_statement; 47, 48; 47, 55; 47, 67; 47, 93; 47, 118; 47, 146; 47, 177; 47, 195; 47, 213; 48, boolean_operator:and; 48, 49; 48, 50; 49, identifier:c; 50, comparison_operator:not; 50, 51; 50, 52; 51, identifier:c; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:meta_chars; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:seq; 60, identifier:append; 61, argument_list; 61, 62; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:getLiteral; 66, argument_list; 67, elif_clause; 67, 68; 67, 81; 68, boolean_operator:and; 68, 69; 68, 74; 69, boolean_operator:and; 69, 70; 69, 71; 70, identifier:c; 71, comparison_operator:==; 71, 72; 71, 73; 72, identifier:c; 73, string:u'$'; 74, comparison_operator:==; 74, 75; 74, 80; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:lookahead; 79, argument_list; 80, string:u'{'; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:seq; 86, identifier:append; 87, argument_list; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:getSource; 92, argument_list; 93, elif_clause; 93, 94; 93, 106; 94, boolean_operator:and; 94, 95; 94, 98; 95, comparison_operator:==; 95, 96; 95, 97; 96, identifier:c; 97, string:u'['; 98, not_operator; 98, 99; 99, comparison_operator:==; 99, 100; 99, 105; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:last; 104, argument_list; 105, string:u'\\'; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:seq; 111, identifier:append; 112, argument_list; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:getCharacterSet; 117, argument_list; 118, elif_clause; 118, 119; 118, 131; 119, boolean_operator:and; 119, 120; 119, 123; 120, comparison_operator:==; 120, 121; 120, 122; 121, identifier:c; 122, string:u'('; 123, not_operator; 123, 124; 124, comparison_operator:==; 124, 125; 124, 130; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:last; 129, argument_list; 130, string:u'\\'; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:seq; 136, identifier:append; 137, argument_list; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:getSequence; 142, argument_list; 142, 143; 143, binary_operator:+; 143, 144; 143, 145; 144, identifier:level; 145, integer:1; 146, elif_clause; 146, 147; 146, 159; 147, boolean_operator:and; 147, 148; 147, 151; 148, comparison_operator:==; 148, 149; 148, 150; 149, identifier:c; 150, string:u')'; 151, not_operator; 151, 152; 152, comparison_operator:==; 152, 153; 152, 158; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:last; 157, argument_list; 158, string:u'\\'; 159, block; 159, 160; 159, 172; 159, 176; 160, if_statement; 160, 161; 160, 164; 161, comparison_operator:==; 161, 162; 161, 163; 162, identifier:level; 163, integer:0; 164, block; 164, 165; 165, raise_statement; 165, 166; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:StringGenerator; 169, identifier:SyntaxError; 170, argument_list; 170, 171; 171, string:u"Extra closing parenthesis"; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:sequence_closed; 175, True; 176, break_statement; 177, elif_clause; 177, 178; 177, 190; 178, boolean_operator:and; 178, 179; 178, 182; 179, comparison_operator:==; 179, 180; 179, 181; 180, identifier:c; 181, string:u'|'; 182, not_operator; 182, 183; 183, comparison_operator:==; 183, 184; 183, 189; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:last; 188, argument_list; 189, string:u'\\'; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:op; 194, identifier:c; 195, elif_clause; 195, 196; 195, 208; 196, boolean_operator:and; 196, 197; 196, 200; 197, comparison_operator:==; 197, 198; 197, 199; 198, identifier:c; 199, string:u'&'; 200, not_operator; 200, 201; 201, comparison_operator:==; 201, 202; 201, 207; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:self; 205, identifier:last; 206, argument_list; 207, string:u'\\'; 208, block; 208, 209; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:op; 212, identifier:c; 213, else_clause; 213, 214; 214, block; 214, 215; 215, if_statement; 215, 216; 215, 230; 216, boolean_operator:and; 216, 217; 216, 222; 217, comparison_operator:in; 217, 218; 217, 219; 218, identifier:c; 219, attribute; 219, 220; 219, 221; 220, identifier:self; 221, identifier:meta_chars; 222, not_operator; 222, 223; 223, comparison_operator:==; 223, 224; 223, 229; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:last; 228, argument_list; 229, string:u"\\"; 230, block; 230, 231; 231, raise_statement; 231, 232; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:StringGenerator; 235, identifier:SyntaxError; 236, argument_list; 236, 237; 237, binary_operator:%; 237, 238; 237, 239; 238, string:u"Un-escaped special character: %s"; 239, identifier:c; 240, if_statement; 240, 241; 240, 245; 240, 274; 241, boolean_operator:and; 241, 242; 241, 243; 242, identifier:op; 243, not_operator; 243, 244; 244, identifier:left_operand; 245, block; 245, 246; 245, 266; 246, if_statement; 246, 247; 246, 256; 247, boolean_operator:or; 247, 248; 247, 250; 248, not_operator; 248, 249; 249, identifier:seq; 250, comparison_operator:<; 250, 251; 250, 255; 251, call; 251, 252; 251, 253; 252, identifier:len; 253, argument_list; 253, 254; 254, identifier:seq; 255, integer:1; 256, block; 256, 257; 257, raise_statement; 257, 258; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:StringGenerator; 261, identifier:SyntaxError; 262, argument_list; 262, 263; 263, binary_operator:%; 263, 264; 263, 265; 264, string:u"Operator: %s with no left operand"; 265, identifier:op; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:left_operand; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:seq; 272, identifier:pop; 273, argument_list; 274, elif_clause; 274, 275; 274, 285; 275, boolean_operator:and; 275, 276; 275, 284; 276, boolean_operator:and; 276, 277; 276, 278; 277, identifier:op; 278, comparison_operator:>=; 278, 279; 278, 283; 279, call; 279, 280; 279, 281; 280, identifier:len; 281, argument_list; 281, 282; 282, identifier:seq; 283, integer:1; 284, identifier:left_operand; 285, block; 285, 286; 285, 294; 285, 332; 285, 336; 285, 340; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:right_operand; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:seq; 292, identifier:pop; 293, argument_list; 294, if_statement; 294, 295; 294, 298; 294, 313; 295, comparison_operator:==; 295, 296; 295, 297; 296, identifier:op; 297, string:u'|'; 298, block; 298, 299; 299, expression_statement; 299, 300; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:seq; 303, identifier:append; 304, argument_list; 304, 305; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:StringGenerator; 308, identifier:SequenceOR; 309, argument_list; 309, 310; 310, list:[left_operand, right_operand]; 310, 311; 310, 312; 311, identifier:left_operand; 312, identifier:right_operand; 313, elif_clause; 313, 314; 313, 317; 314, comparison_operator:==; 314, 315; 314, 316; 315, identifier:op; 316, string:u'&'; 317, block; 317, 318; 318, expression_statement; 318, 319; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:seq; 322, identifier:append; 323, argument_list; 323, 324; 324, call; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:StringGenerator; 327, identifier:SequenceAND; 328, argument_list; 328, 329; 329, list:[left_operand, right_operand]; 329, 330; 329, 331; 330, identifier:left_operand; 331, identifier:right_operand; 332, expression_statement; 332, 333; 333, assignment; 333, 334; 333, 335; 334, identifier:op; 335, string:u''; 336, expression_statement; 336, 337; 337, assignment; 337, 338; 337, 339; 338, identifier:left_operand; 339, None; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 343; 342, identifier:right_operand; 343, None; 344, if_statement; 344, 345; 344, 346; 345, identifier:op; 346, block; 346, 347; 347, raise_statement; 347, 348; 348, call; 348, 349; 348, 352; 349, attribute; 349, 350; 349, 351; 350, identifier:StringGenerator; 351, identifier:SyntaxError; 352, argument_list; 352, 353; 353, binary_operator:%; 353, 354; 353, 355; 354, string:u"Operator: %s with no right operand"; 355, identifier:op; 356, if_statement; 356, 357; 356, 363; 357, boolean_operator:and; 357, 358; 357, 361; 358, comparison_operator:>; 358, 359; 358, 360; 359, identifier:level; 360, integer:0; 361, not_operator; 361, 362; 362, identifier:sequence_closed; 363, block; 363, 364; 364, raise_statement; 364, 365; 365, call; 365, 366; 365, 369; 366, attribute; 366, 367; 366, 368; 367, identifier:StringGenerator; 368, identifier:SyntaxError; 369, argument_list; 369, 370; 370, string:u"Missing closing parenthesis"; 371, return_statement; 371, 372; 372, call; 372, 373; 372, 376; 373, attribute; 373, 374; 373, 375; 374, identifier:StringGenerator; 375, identifier:Sequence; 376, argument_list; 376, 377; 377, identifier:seq | def getSequence(self, level=0):
'''Get a sequence of nodes.'''
seq = []
op = ''
left_operand = None
right_operand = None
sequence_closed = False
while True:
c = self.next()
if not c:
break
if c and c not in self.meta_chars:
seq.append(self.getLiteral())
elif c and c == u'$' and self.lookahead() == u'{':
seq.append(self.getSource())
elif c == u'[' and not self.last() == u'\\':
seq.append(self.getCharacterSet())
elif c == u'(' and not self.last() == u'\\':
seq.append(self.getSequence(level + 1))
elif c == u')' and not self.last() == u'\\':
if level == 0:
raise StringGenerator.SyntaxError(u"Extra closing parenthesis")
sequence_closed = True
break
elif c == u'|' and not self.last() == u'\\':
op = c
elif c == u'&' and not self.last() == u'\\':
op = c
else:
if c in self.meta_chars and not self.last() == u"\\":
raise StringGenerator.SyntaxError(u"Un-escaped special character: %s" % c)
if op and not left_operand:
if not seq or len(seq) < 1:
raise StringGenerator.SyntaxError(u"Operator: %s with no left operand" % op)
left_operand = seq.pop()
elif op and len(seq) >= 1 and left_operand:
right_operand = seq.pop()
if op == u'|':
seq.append(StringGenerator.SequenceOR([left_operand, right_operand]))
elif op == u'&':
seq.append(StringGenerator.SequenceAND([left_operand, right_operand]))
op = u''
left_operand = None
right_operand = None
if op:
raise StringGenerator.SyntaxError(u"Operator: %s with no right operand" % op)
if level > 0 and not sequence_closed:
raise StringGenerator.SyntaxError(u"Missing closing parenthesis")
return StringGenerator.Sequence(seq) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:process; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:data; 6, identifier:type; 7, identifier:history; 8, block; 8, 9; 8, 15; 8, 23; 8, 30; 8, 38; 8, 42; 8, 129; 8, 138; 8, 147; 9, if_statement; 9, 10; 9, 13; 10, comparison_operator:in; 10, 11; 10, 12; 11, identifier:type; 12, identifier:history; 13, block; 13, 14; 14, return_statement; 15, if_statement; 15, 16; 15, 21; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:type; 19, identifier:enum; 20, argument_list; 21, block; 21, 22; 22, return_statement; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:history; 27, identifier:append; 28, argument_list; 28, 29; 29, identifier:type; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:resolved; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:type; 36, identifier:resolve; 37, argument_list; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:value; 41, None; 42, if_statement; 42, 43; 42, 48; 42, 53; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:type; 46, identifier:multi_occurrence; 47, argument_list; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:value; 52, list:[]; 53, else_clause; 53, 54; 54, block; 54, 55; 55, if_statement; 55, 56; 55, 62; 56, comparison_operator:>; 56, 57; 56, 61; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, identifier:resolved; 61, integer:0; 62, block; 62, 63; 63, if_statement; 63, 64; 63, 69; 63, 93; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:resolved; 67, identifier:mixed; 68, argument_list; 69, block; 69, 70; 69, 81; 69, 87; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:value; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:Factory; 76, identifier:property; 77, argument_list; 77, 78; 78, attribute; 78, 79; 78, 80; 79, identifier:resolved; 80, identifier:name; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:md; 84, attribute; 84, 85; 84, 86; 85, identifier:value; 86, identifier:__metadata__; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:md; 91, identifier:sxtype; 92, identifier:resolved; 93, else_clause; 93, 94; 94, block; 94, 95; 94, 106; 94, 112; 94, 118; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:value; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:Factory; 101, identifier:object; 102, argument_list; 102, 103; 103, attribute; 103, 104; 103, 105; 104, identifier:resolved; 105, identifier:name; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:md; 109, attribute; 109, 110; 109, 111; 110, identifier:value; 111, identifier:__metadata__; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:md; 116, identifier:sxtype; 117, identifier:resolved; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:md; 122, identifier:ordering; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:ordering; 127, argument_list; 127, 128; 128, identifier:resolved; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:setattr; 132, argument_list; 132, 133; 132, 134; 132, 137; 133, identifier:data; 134, attribute; 134, 135; 134, 136; 135, identifier:type; 136, identifier:name; 137, identifier:value; 138, if_statement; 138, 139; 138, 142; 139, comparison_operator:is; 139, 140; 139, 141; 140, identifier:value; 141, None; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:data; 146, identifier:value; 147, if_statement; 147, 148; 147, 154; 148, not_operator; 148, 149; 149, call; 149, 150; 149, 151; 150, identifier:isinstance; 151, argument_list; 151, 152; 151, 153; 152, identifier:data; 153, identifier:list; 154, block; 154, 155; 154, 163; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:add_attributes; 160, argument_list; 160, 161; 160, 162; 161, identifier:data; 162, identifier:resolved; 163, for_statement; 163, 164; 163, 167; 163, 172; 164, pattern_list; 164, 165; 164, 166; 165, identifier:child; 166, identifier:ancestry; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:resolved; 170, identifier:children; 171, argument_list; 172, block; 172, 173; 172, 183; 173, if_statement; 173, 174; 173, 181; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:skip_child; 178, argument_list; 178, 179; 178, 180; 179, identifier:child; 180, identifier:ancestry; 181, block; 181, 182; 182, continue_statement; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:process; 188, argument_list; 188, 189; 188, 190; 188, 191; 189, identifier:data; 190, identifier:child; 191, subscript; 191, 192; 191, 193; 192, identifier:history; 193, slice; 193, 194; 194, colon | def process(self, data, type, history):
if type in history:
return
if type.enum():
return
history.append(type)
resolved = type.resolve()
value = None
if type.multi_occurrence():
value = []
else:
if len(resolved) > 0:
if resolved.mixed():
value = Factory.property(resolved.name)
md = value.__metadata__
md.sxtype = resolved
else:
value = Factory.object(resolved.name)
md = value.__metadata__
md.sxtype = resolved
md.ordering = self.ordering(resolved)
setattr(data, type.name, value)
if value is not None:
data = value
if not isinstance(data, list):
self.add_attributes(data, resolved)
for child, ancestry in resolved.children():
if self.skip_child(child, ancestry):
continue
self.process(data, child, history[:]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_process_tz; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:dt; 6, identifier:naive; 7, identifier:tz; 8, block; 8, 9; 8, 98; 8, 105; 8, 112; 8, 149; 8, 155; 8, 203; 9, function_definition; 9, 10; 9, 11; 9, 13; 10, function_name:_tz; 11, parameters; 11, 12; 12, identifier:t; 13, block; 13, 14; 13, 23; 13, 43; 13, 74; 13, 96; 14, if_statement; 14, 15; 14, 20; 15, comparison_operator:in; 15, 16; 15, 17; 16, identifier:t; 17, tuple; 17, 18; 17, 19; 18, None; 19, string:'naive'; 20, block; 20, 21; 21, return_statement; 21, 22; 22, identifier:t; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:==; 24, 25; 24, 26; 25, identifier:t; 26, string:'local'; 27, block; 27, 28; 27, 39; 28, if_statement; 28, 29; 28, 33; 29, boolean_operator:and; 29, 30; 29, 31; 30, identifier:__debug__; 31, not_operator; 31, 32; 32, identifier:localtz; 33, block; 33, 34; 34, raise_statement; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:ValueError; 37, argument_list; 37, 38; 38, string:"Requested conversion to local timezone, but `localtz` not installed."; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:t; 42, identifier:localtz; 43, if_statement; 43, 44; 43, 50; 44, not_operator; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:isinstance; 47, argument_list; 47, 48; 47, 49; 48, identifier:t; 49, identifier:tzinfo; 50, block; 50, 51; 50, 67; 51, if_statement; 51, 52; 51, 56; 52, boolean_operator:and; 52, 53; 52, 54; 53, identifier:__debug__; 54, not_operator; 54, 55; 55, identifier:localtz; 56, block; 56, 57; 57, raise_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:ValueError; 60, argument_list; 60, 61; 61, binary_operator:+; 61, 62; 61, 63; 62, string:"The `pytz` package must be installed to look up timezone: "; 63, call; 63, 64; 63, 65; 64, identifier:repr; 65, argument_list; 65, 66; 66, identifier:t; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:t; 70, call; 70, 71; 70, 72; 71, identifier:get_tz; 72, argument_list; 72, 73; 73, identifier:t; 74, if_statement; 74, 75; 74, 83; 75, boolean_operator:and; 75, 76; 75, 82; 76, not_operator; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:hasattr; 79, argument_list; 79, 80; 79, 81; 80, identifier:t; 81, string:'normalize'; 82, identifier:get_tz; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:t; 87, call; 87, 88; 87, 89; 88, identifier:get_tz; 89, argument_list; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:t; 93, identifier:tzname; 94, argument_list; 94, 95; 95, identifier:dt; 96, return_statement; 96, 97; 97, identifier:t; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:naive; 101, call; 101, 102; 101, 103; 102, identifier:_tz; 103, argument_list; 103, 104; 104, identifier:naive; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:tz; 108, call; 108, 109; 108, 110; 109, identifier:_tz; 110, argument_list; 110, 111; 111, identifier:tz; 112, if_statement; 112, 113; 112, 119; 113, boolean_operator:and; 113, 114; 113, 118; 114, not_operator; 114, 115; 115, attribute; 115, 116; 115, 117; 116, identifier:dt; 117, identifier:tzinfo; 118, identifier:naive; 119, block; 119, 120; 120, if_statement; 120, 121; 120, 126; 120, 136; 121, call; 121, 122; 121, 123; 122, identifier:hasattr; 123, argument_list; 123, 124; 123, 125; 124, identifier:naive; 125, string:'localize'; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:dt; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:naive; 133, identifier:localize; 134, argument_list; 134, 135; 135, identifier:dt; 136, else_clause; 136, 137; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:dt; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:dt; 144, identifier:replace; 145, argument_list; 145, 146; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:tzinfo; 148, identifier:naive; 149, if_statement; 149, 150; 149, 152; 150, not_operator; 150, 151; 151, identifier:tz; 152, block; 152, 153; 153, return_statement; 153, 154; 154, identifier:dt; 155, if_statement; 155, 156; 155, 161; 155, 176; 155, 192; 156, call; 156, 157; 156, 158; 157, identifier:hasattr; 158, argument_list; 158, 159; 158, 160; 159, identifier:tz; 160, string:'normalize'; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:dt; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:tz; 168, identifier:normalize; 169, argument_list; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:dt; 173, identifier:astimezone; 174, argument_list; 174, 175; 175, identifier:tz; 176, elif_clause; 176, 177; 176, 180; 177, comparison_operator:==; 177, 178; 177, 179; 178, identifier:tz; 179, string:'naive'; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:dt; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:dt; 187, identifier:replace; 188, argument_list; 188, 189; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:tzinfo; 191, None; 192, else_clause; 192, 193; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:dt; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:dt; 200, identifier:astimezone; 201, argument_list; 201, 202; 202, identifier:tz; 203, return_statement; 203, 204; 204, identifier:dt | def _process_tz(self, dt, naive, tz):
def _tz(t):
if t in (None, 'naive'):
return t
if t == 'local':
if __debug__ and not localtz:
raise ValueError("Requested conversion to local timezone, but `localtz` not installed.")
t = localtz
if not isinstance(t, tzinfo):
if __debug__ and not localtz:
raise ValueError("The `pytz` package must be installed to look up timezone: " + repr(t))
t = get_tz(t)
if not hasattr(t, 'normalize') and get_tz:
t = get_tz(t.tzname(dt))
return t
naive = _tz(naive)
tz = _tz(tz)
if not dt.tzinfo and naive:
if hasattr(naive, 'localize'):
dt = naive.localize(dt)
else:
dt = dt.replace(tzinfo=naive)
if not tz:
return dt
if hasattr(tz, 'normalize'):
dt = tz.normalize(dt.astimezone(tz))
elif tz == 'naive':
dt = dt.replace(tzinfo=None)
else:
dt = dt.astimezone(tz)
return dt |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:__dfs; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:v; 6, identifier:index; 7, identifier:layers; 8, block; 8, 9; 8, 58; 8, 151; 9, if_statement; 9, 10; 9, 13; 10, comparison_operator:==; 10, 11; 10, 12; 11, identifier:index; 12, integer:0; 13, block; 13, 14; 13, 19; 13, 47; 13, 56; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:path; 17, list:[v]; 17, 18; 18, identifier:v; 19, while_statement; 19, 20; 19, 27; 20, comparison_operator:!=; 20, 21; 20, 26; 21, subscript; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_dfs_parent; 25, identifier:v; 26, identifier:v; 27, block; 27, 28; 27, 39; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:path; 32, identifier:append; 33, argument_list; 33, 34; 34, subscript; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_dfs_parent; 38, identifier:v; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:v; 42, subscript; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_dfs_parent; 46, identifier:v; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 54; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:_dfs_paths; 53, identifier:append; 54, argument_list; 54, 55; 55, identifier:path; 56, return_statement; 56, 57; 57, True; 58, for_statement; 58, 59; 58, 60; 58, 65; 59, identifier:neighbour; 60, subscript; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:_graph; 64, identifier:v; 65, block; 65, 66; 66, if_statement; 66, 67; 66, 74; 67, comparison_operator:in; 67, 68; 67, 69; 68, identifier:neighbour; 69, subscript; 69, 70; 69, 71; 70, identifier:layers; 71, binary_operator:-; 71, 72; 71, 73; 72, identifier:index; 73, integer:1; 74, block; 74, 75; 74, 83; 75, if_statement; 75, 76; 75, 81; 76, comparison_operator:in; 76, 77; 76, 78; 77, identifier:neighbour; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_dfs_parent; 81, block; 81, 82; 82, continue_statement; 83, if_statement; 83, 84; 83, 128; 84, boolean_operator:or; 84, 85; 84, 106; 84, 107; 85, parenthesized_expression; 85, 86; 86, boolean_operator:and; 86, 87; 86, 92; 87, comparison_operator:in; 87, 88; 87, 89; 88, identifier:neighbour; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:_left; 92, parenthesized_expression; 92, 93; 93, boolean_operator:or; 93, 94; 93, 99; 94, comparison_operator:not; 94, 95; 94, 96; 95, identifier:v; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:_matching; 99, comparison_operator:!=; 99, 100; 99, 101; 100, identifier:neighbour; 101, subscript; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:_matching; 105, identifier:v; 106, line_continuation:\; 107, parenthesized_expression; 107, 108; 108, boolean_operator:and; 108, 109; 108, 114; 109, comparison_operator:in; 109, 110; 109, 111; 110, identifier:neighbour; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:_right; 114, parenthesized_expression; 114, 115; 115, boolean_operator:and; 115, 116; 115, 121; 116, comparison_operator:in; 116, 117; 116, 118; 117, identifier:v; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:_matching; 121, comparison_operator:==; 121, 122; 121, 123; 122, identifier:neighbour; 123, subscript; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:_matching; 127, identifier:v; 128, block; 128, 129; 128, 137; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 136; 131, subscript; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:_dfs_parent; 135, identifier:neighbour; 136, identifier:v; 137, if_statement; 137, 138; 137, 148; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:__dfs; 142, argument_list; 142, 143; 142, 144; 142, 147; 143, identifier:neighbour; 144, binary_operator:-; 144, 145; 144, 146; 145, identifier:index; 146, integer:1; 147, identifier:layers; 148, block; 148, 149; 149, return_statement; 149, 150; 150, True; 151, return_statement; 151, 152; 152, False | def __dfs(self, v, index, layers):
if index == 0:
path = [v]
while self._dfs_parent[v] != v:
path.append(self._dfs_parent[v])
v = self._dfs_parent[v]
self._dfs_paths.append(path)
return True
for neighbour in self._graph[v]:
if neighbour in layers[index - 1]:
if neighbour in self._dfs_parent:
continue
if (neighbour in self._left and (v not in self._matching or neighbour != self._matching[v])) or \
(neighbour in self._right and (v in self._matching and neighbour == self._matching[v])):
self._dfs_parent[neighbour] = v
if self.__dfs(neighbour, index-1, layers):
return True
return False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:login; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:username; 6, identifier:password; 7, default_parameter; 7, 8; 7, 9; 8, identifier:login_token; 9, None; 10, block; 10, 11; 10, 43; 10, 66; 10, 103; 11, if_statement; 11, 12; 11, 15; 12, comparison_operator:is; 12, 13; 12, 14; 13, identifier:login_token; 14, None; 15, block; 15, 16; 15, 33; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:token_doc; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:post; 23, argument_list; 23, 24; 23, 27; 23, 30; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:action; 26, string:'query'; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:meta; 29, string:'tokens'; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:type; 32, string:'login'; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:login_token; 36, subscript; 36, 37; 36, 42; 37, subscript; 37, 38; 37, 41; 38, subscript; 38, 39; 38, 40; 39, identifier:token_doc; 40, string:'query'; 41, string:'tokens'; 42, string:'logintoken'; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:login_doc; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:post; 50, argument_list; 50, 51; 50, 54; 50, 57; 50, 60; 50, 63; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:action; 53, string:"clientlogin"; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:username; 56, identifier:username; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:password; 59, identifier:password; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:logintoken; 62, identifier:login_token; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:loginreturnurl; 65, string:"http://example.org/"; 66, if_statement; 66, 67; 66, 74; 66, 85; 67, comparison_operator:==; 67, 68; 67, 73; 68, subscript; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:login_doc; 71, string:'clientlogin'; 72, string:'status'; 73, string:"UI"; 74, block; 74, 75; 75, raise_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:ClientInteractionRequest; 79, identifier:from_doc; 80, argument_list; 80, 81; 80, 82; 81, identifier:login_token; 82, subscript; 82, 83; 82, 84; 83, identifier:login_doc; 84, string:'clientlogin'; 85, elif_clause; 85, 86; 85, 93; 86, comparison_operator:!=; 86, 87; 86, 92; 87, subscript; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:login_doc; 90, string:'clientlogin'; 91, string:'status'; 92, string:'PASS'; 93, block; 93, 94; 94, raise_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:LoginError; 98, identifier:from_doc; 99, argument_list; 99, 100; 100, subscript; 100, 101; 100, 102; 101, identifier:login_doc; 102, string:'clientlogin'; 103, return_statement; 103, 104; 104, subscript; 104, 105; 104, 106; 105, identifier:login_doc; 106, string:'clientlogin' | def login(self, username, password, login_token=None):
if login_token is None:
token_doc = self.post(action='query', meta='tokens', type='login')
login_token = token_doc['query']['tokens']['logintoken']
login_doc = self.post(
action="clientlogin", username=username, password=password,
logintoken=login_token, loginreturnurl="http://example.org/")
if login_doc['clientlogin']['status'] == "UI":
raise ClientInteractionRequest.from_doc(
login_token, login_doc['clientlogin'])
elif login_doc['clientlogin']['status'] != 'PASS':
raise LoginError.from_doc(login_doc['clientlogin'])
return login_doc['clientlogin'] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:cut_levels; 3, parameters; 3, 4; 3, 5; 4, identifier:nodes; 5, identifier:start_level; 6, block; 6, 7; 6, 11; 6, 15; 6, 146; 6, 162; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:final; 10, list:[]; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:removed; 14, list:[]; 15, for_statement; 15, 16; 15, 17; 15, 18; 16, identifier:node; 17, identifier:nodes; 18, block; 18, 19; 18, 34; 18, 52; 18, 112; 19, if_statement; 19, 20; 19, 26; 20, not_operator; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:hasattr; 23, argument_list; 23, 24; 23, 25; 24, identifier:node; 25, string:'level'; 26, block; 26, 27; 26, 33; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:remove; 30, argument_list; 30, 31; 30, 32; 31, identifier:node; 32, identifier:removed; 33, continue_statement; 34, if_statement; 34, 35; 34, 44; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:node; 39, identifier:attr; 40, identifier:get; 41, argument_list; 41, 42; 41, 43; 42, string:'soft_root'; 43, False; 44, block; 44, 45; 44, 51; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:remove; 48, argument_list; 48, 49; 48, 50; 49, identifier:node; 50, identifier:removed; 51, continue_statement; 52, if_statement; 52, 53; 52, 58; 52, 89; 52, 104; 53, comparison_operator:==; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:node; 56, identifier:level; 57, identifier:start_level; 58, block; 58, 59; 58, 66; 58, 72; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:final; 63, identifier:append; 64, argument_list; 64, 65; 65, identifier:node; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:node; 70, identifier:parent; 71, None; 72, if_statement; 72, 73; 72, 82; 73, boolean_operator:and; 73, 74; 73, 78; 74, not_operator; 74, 75; 75, attribute; 75, 76; 75, 77; 76, identifier:node; 77, identifier:visible; 78, not_operator; 78, 79; 79, attribute; 79, 80; 79, 81; 80, identifier:node; 81, identifier:children; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:remove; 86, argument_list; 86, 87; 86, 88; 87, identifier:node; 88, identifier:removed; 89, elif_clause; 89, 90; 89, 97; 90, comparison_operator:==; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:node; 93, identifier:level; 94, binary_operator:+; 94, 95; 94, 96; 95, identifier:start_level; 96, integer:1; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:node; 102, identifier:children; 103, list:[]; 104, else_clause; 104, 105; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:remove; 109, argument_list; 109, 110; 109, 111; 110, identifier:node; 111, identifier:removed; 112, if_statement; 112, 113; 112, 117; 113, not_operator; 113, 114; 114, attribute; 114, 115; 114, 116; 115, identifier:node; 116, identifier:visible; 117, block; 117, 118; 117, 122; 117, 136; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:keep_node; 121, False; 122, for_statement; 122, 123; 122, 124; 122, 127; 123, identifier:child; 124, attribute; 124, 125; 124, 126; 125, identifier:node; 126, identifier:children; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:keep_node; 131, boolean_operator:or; 131, 132; 131, 133; 132, identifier:keep_node; 133, attribute; 133, 134; 133, 135; 134, identifier:child; 135, identifier:visible; 136, if_statement; 136, 137; 136, 139; 137, not_operator; 137, 138; 138, identifier:keep_node; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 143; 142, identifier:remove; 143, argument_list; 143, 144; 143, 145; 144, identifier:node; 145, identifier:removed; 146, for_statement; 146, 147; 146, 148; 146, 149; 147, identifier:node; 148, identifier:removed; 149, block; 149, 150; 150, if_statement; 150, 151; 150, 154; 151, comparison_operator:in; 151, 152; 151, 153; 152, identifier:node; 153, identifier:final; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:final; 159, identifier:remove; 160, argument_list; 160, 161; 161, identifier:node; 162, return_statement; 162, 163; 163, identifier:final | def cut_levels(nodes, start_level):
final = []
removed = []
for node in nodes:
if not hasattr(node, 'level'):
remove(node, removed)
continue
if node.attr.get('soft_root', False):
remove(node, removed)
continue
if node.level == start_level:
final.append(node)
node.parent = None
if not node.visible and not node.children:
remove(node, removed)
elif node.level == start_level + 1:
node.children = []
else:
remove(node, removed)
if not node.visible:
keep_node = False
for child in node.children:
keep_node = keep_node or child.visible
if not keep_node:
remove(node, removed)
for node in removed:
if node in final:
final.remove(node)
return final |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:S; 3, parameters; 3, 4; 3, 5; 4, identifier:Document; 5, list_splat_pattern; 5, 6; 6, identifier:fields; 7, block; 7, 8; 7, 12; 7, 115; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:result; 11, list:[]; 12, for_statement; 12, 13; 12, 14; 12, 15; 13, identifier:field; 14, identifier:fields; 15, block; 15, 16; 15, 39; 15, 43; 15, 62; 15, 73; 15, 90; 15, 101; 16, if_statement; 16, 17; 16, 22; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 21; 20, identifier:field; 21, identifier:tuple; 22, block; 22, 23; 22, 29; 22, 38; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, pattern_list; 25, 26; 25, 27; 26, identifier:field; 27, identifier:direction; 28, identifier:field; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:result; 33, identifier:append; 34, argument_list; 34, 35; 35, tuple; 35, 36; 35, 37; 36, identifier:field; 37, identifier:direction; 38, continue_statement; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:direction; 42, identifier:ASCENDING; 43, if_statement; 43, 44; 43, 51; 44, not_operator; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:field; 48, identifier:startswith; 49, argument_list; 49, 50; 50, string:'__'; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:field; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:field; 58, identifier:replace; 59, argument_list; 59, 60; 59, 61; 60, string:'__'; 61, string:'.'; 62, if_statement; 62, 63; 62, 68; 63, comparison_operator:==; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:field; 66, integer:0; 67, string:'-'; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:direction; 72, identifier:DESCENDING; 73, if_statement; 73, 74; 73, 81; 74, comparison_operator:in; 74, 75; 74, 78; 75, subscript; 75, 76; 75, 77; 76, identifier:field; 77, integer:0; 78, tuple; 78, 79; 78, 80; 79, string:'+'; 80, string:'-'; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:field; 85, subscript; 85, 86; 85, 87; 86, identifier:field; 87, slice; 87, 88; 87, 89; 88, integer:1; 89, colon; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:_field; 93, call; 93, 94; 93, 95; 94, identifier:traverse; 95, argument_list; 95, 96; 95, 97; 95, 98; 96, identifier:Document; 97, identifier:field; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:default; 100, None; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:result; 105, identifier:append; 106, argument_list; 106, 107; 107, tuple; 107, 108; 107, 114; 108, conditional_expression:if; 108, 109; 108, 112; 108, 113; 109, parenthesized_expression; 109, 110; 110, unary_operator:~; 110, 111; 111, identifier:_field; 112, identifier:_field; 113, identifier:field; 114, identifier:direction; 115, return_statement; 115, 116; 116, identifier:result | def S(Document, *fields):
result = []
for field in fields:
if isinstance(field, tuple):
field, direction = field
result.append((field, direction))
continue
direction = ASCENDING
if not field.startswith('__'):
field = field.replace('__', '.')
if field[0] == '-':
direction = DESCENDING
if field[0] in ('+', '-'):
field = field[1:]
_field = traverse(Document, field, default=None)
result.append(((~_field) if _field else field, direction))
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:valid; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:cnpj; 6, block; 6, 7; 6, 17; 6, 21; 6, 29; 6, 37; 6, 41; 6, 47; 6, 87; 6, 103; 6, 115; 6, 121; 6, 129; 6, 133; 6, 139; 6, 179; 6, 195; 6, 207; 7, if_statement; 7, 8; 7, 14; 8, comparison_operator:!=; 8, 9; 8, 13; 9, call; 9, 10; 9, 11; 10, identifier:len; 11, argument_list; 11, 12; 12, identifier:cnpj; 13, integer:14; 14, block; 14, 15; 15, return_statement; 15, 16; 16, False; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:tam; 20, integer:12; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:nums; 24, subscript; 24, 25; 24, 26; 25, identifier:cnpj; 26, slice; 26, 27; 26, 28; 27, colon; 28, identifier:tam; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:digs; 32, subscript; 32, 33; 32, 34; 33, identifier:cnpj; 34, slice; 34, 35; 34, 36; 35, identifier:tam; 36, colon; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:tot; 40, integer:0; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:pos; 44, binary_operator:-; 44, 45; 44, 46; 45, identifier:tam; 46, integer:7; 47, for_statement; 47, 48; 47, 49; 47, 56; 48, identifier:i; 49, call; 49, 50; 49, 51; 50, identifier:range; 51, argument_list; 51, 52; 51, 53; 51, 54; 52, identifier:tam; 53, integer:0; 54, unary_operator:-; 54, 55; 55, integer:1; 56, block; 56, 57; 56, 72; 56, 78; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:tot; 60, binary_operator:+; 60, 61; 60, 62; 61, identifier:tot; 62, binary_operator:*; 62, 63; 62, 71; 63, call; 63, 64; 63, 65; 64, identifier:int; 65, argument_list; 65, 66; 66, subscript; 66, 67; 66, 68; 67, identifier:nums; 68, binary_operator:-; 68, 69; 68, 70; 69, identifier:tam; 70, identifier:i; 71, identifier:pos; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:pos; 75, binary_operator:-; 75, 76; 75, 77; 76, identifier:pos; 77, integer:1; 78, if_statement; 78, 79; 78, 82; 79, comparison_operator:<; 79, 80; 79, 81; 80, identifier:pos; 81, integer:2; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:pos; 86, integer:9; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:res; 90, conditional_expression:if; 90, 91; 90, 92; 90, 97; 91, integer:0; 92, comparison_operator:<; 92, 93; 92, 96; 93, binary_operator:%; 93, 94; 93, 95; 94, identifier:tot; 95, integer:11; 96, integer:2; 97, binary_operator:-; 97, 98; 97, 99; 98, integer:11; 99, parenthesized_expression; 99, 100; 100, binary_operator:%; 100, 101; 100, 102; 101, identifier:tot; 102, integer:11; 103, if_statement; 103, 104; 103, 112; 104, comparison_operator:!=; 104, 105; 104, 106; 105, identifier:res; 106, call; 106, 107; 106, 108; 107, identifier:int; 108, argument_list; 108, 109; 109, subscript; 109, 110; 109, 111; 110, identifier:digs; 111, integer:0; 112, block; 112, 113; 113, return_statement; 113, 114; 114, False; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:tam; 118, binary_operator:+; 118, 119; 118, 120; 119, identifier:tam; 120, integer:1; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:nums; 124, subscript; 124, 125; 124, 126; 125, identifier:cnpj; 126, slice; 126, 127; 126, 128; 127, colon; 128, identifier:tam; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:tot; 132, integer:0; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:pos; 136, binary_operator:-; 136, 137; 136, 138; 137, identifier:tam; 138, integer:7; 139, for_statement; 139, 140; 139, 141; 139, 148; 140, identifier:i; 141, call; 141, 142; 141, 143; 142, identifier:range; 143, argument_list; 143, 144; 143, 145; 143, 146; 144, identifier:tam; 145, integer:0; 146, unary_operator:-; 146, 147; 147, integer:1; 148, block; 148, 149; 148, 164; 148, 170; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:tot; 152, binary_operator:+; 152, 153; 152, 154; 153, identifier:tot; 154, binary_operator:*; 154, 155; 154, 163; 155, call; 155, 156; 155, 157; 156, identifier:int; 157, argument_list; 157, 158; 158, subscript; 158, 159; 158, 160; 159, identifier:nums; 160, binary_operator:-; 160, 161; 160, 162; 161, identifier:tam; 162, identifier:i; 163, identifier:pos; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:pos; 167, binary_operator:-; 167, 168; 167, 169; 168, identifier:pos; 169, integer:1; 170, if_statement; 170, 171; 170, 174; 171, comparison_operator:<; 171, 172; 171, 173; 172, identifier:pos; 173, integer:2; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:pos; 178, integer:9; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:res; 182, conditional_expression:if; 182, 183; 182, 184; 182, 189; 183, integer:0; 184, comparison_operator:<; 184, 185; 184, 188; 185, binary_operator:%; 185, 186; 185, 187; 186, identifier:tot; 187, integer:11; 188, integer:2; 189, binary_operator:-; 189, 190; 189, 191; 190, integer:11; 191, parenthesized_expression; 191, 192; 192, binary_operator:%; 192, 193; 192, 194; 193, identifier:tot; 194, integer:11; 195, if_statement; 195, 196; 195, 204; 196, comparison_operator:!=; 196, 197; 196, 198; 197, identifier:res; 198, call; 198, 199; 198, 200; 199, identifier:int; 200, argument_list; 200, 201; 201, subscript; 201, 202; 201, 203; 202, identifier:digs; 203, integer:1; 204, block; 204, 205; 205, return_statement; 205, 206; 206, False; 207, return_statement; 207, 208; 208, True | def valid(self, cnpj):
if len(cnpj) != 14:
return False
tam = 12
nums = cnpj[:tam]
digs = cnpj[tam:]
tot = 0
pos = tam-7
for i in range(tam, 0, -1):
tot = tot + int(nums[tam-i])*pos
pos = pos - 1
if pos < 2:
pos = 9
res = 0 if tot % 11 < 2 else 11 - (tot % 11)
if res != int(digs[0]):
return False
tam = tam + 1
nums = cnpj[:tam]
tot = 0
pos = tam-7
for i in range(tam, 0, -1):
tot = tot + int(nums[tam-i])*pos
pos = pos - 1
if pos < 2:
pos = 9
res = 0 if tot % 11 < 2 else 11 - (tot % 11)
if res != int(digs[1]):
return False
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:arrayuniqify; 3, parameters; 3, 4; 3, 5; 4, identifier:X; 5, default_parameter; 5, 6; 5, 7; 6, identifier:retainorder; 7, False; 8, block; 8, 9; 8, 17; 8, 23; 8, 45; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:s; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:X; 15, identifier:argsort; 16, argument_list; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:X; 20, subscript; 20, 21; 20, 22; 21, identifier:X; 22, identifier:s; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:D; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:np; 29, identifier:append; 30, argument_list; 30, 31; 30, 33; 31, list:[True]; 31, 32; 32, True; 33, comparison_operator:!=; 33, 34; 33, 39; 34, subscript; 34, 35; 34, 36; 35, identifier:X; 36, slice; 36, 37; 36, 38; 37, integer:1; 38, colon; 39, subscript; 39, 40; 39, 41; 40, identifier:X; 41, slice; 41, 42; 41, 43; 42, colon; 43, unary_operator:-; 43, 44; 44, integer:1; 45, if_statement; 45, 46; 45, 47; 45, 105; 46, identifier:retainorder; 47, block; 47, 48; 47, 67; 47, 97; 47, 103; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:DD; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:np; 54, identifier:append; 55, argument_list; 55, 56; 55, 63; 56, subscript; 56, 57; 56, 62; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:D; 60, identifier:nonzero; 61, argument_list; 62, integer:0; 63, call; 63, 64; 63, 65; 64, identifier:len; 65, argument_list; 65, 66; 66, identifier:X; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:ind; 70, list_comprehension; 70, 71; 70, 84; 71, call; 71, 72; 71, 73; 72, identifier:min; 73, argument_list; 73, 74; 74, subscript; 74, 75; 74, 76; 75, identifier:s; 76, slice; 76, 77; 76, 78; 76, 79; 77, identifier:x; 78, colon; 79, subscript; 79, 80; 79, 81; 80, identifier:DD; 81, binary_operator:+; 81, 82; 81, 83; 82, identifier:i; 83, integer:1; 84, for_in_clause; 84, 85; 84, 88; 85, tuple_pattern; 85, 86; 85, 87; 86, identifier:i; 87, identifier:x; 88, call; 88, 89; 88, 90; 89, identifier:enumerate; 90, argument_list; 90, 91; 91, subscript; 91, 92; 91, 93; 92, identifier:DD; 93, slice; 93, 94; 93, 95; 94, colon; 95, unary_operator:-; 95, 96; 96, integer:1; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:ind; 101, identifier:sort; 102, argument_list; 103, return_statement; 103, 104; 104, identifier:ind; 105, else_clause; 105, 106; 106, block; 106, 107; 107, return_statement; 107, 108; 108, list:[D,s]; 108, 109; 108, 110; 109, identifier:D; 110, identifier:s | def arrayuniqify(X, retainorder=False):
s = X.argsort()
X = X[s]
D = np.append([True],X[1:] != X[:-1])
if retainorder:
DD = np.append(D.nonzero()[0],len(X))
ind = [min(s[x:DD[i+1]]) for (i,x) in enumerate(DD[:-1])]
ind.sort()
return ind
else:
return [D,s] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:equalspairs; 3, parameters; 3, 4; 3, 5; 4, identifier:X; 5, identifier:Y; 6, block; 6, 7; 6, 15; 6, 37; 6, 58; 6, 75; 6, 84; 6, 100; 6, 116; 6, 127; 6, 143; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:T; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:Y; 13, identifier:copy; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:R; 18, subscript; 18, 19; 18, 36; 19, call; 19, 20; 19, 35; 20, attribute; 20, 21; 20, 34; 21, parenthesized_expression; 21, 22; 22, comparison_operator:!=; 22, 23; 22, 28; 23, subscript; 23, 24; 23, 25; 24, identifier:T; 25, slice; 25, 26; 25, 27; 26, integer:1; 27, colon; 28, subscript; 28, 29; 28, 30; 29, identifier:T; 30, slice; 30, 31; 30, 32; 31, colon; 32, unary_operator:-; 32, 33; 33, integer:1; 34, identifier:nonzero; 35, argument_list; 36, integer:0; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:R; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:np; 43, identifier:append; 44, argument_list; 44, 45; 44, 46; 45, identifier:R; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:np; 49, identifier:array; 50, argument_list; 50, 51; 51, list:[len(T)-1]; 51, 52; 52, binary_operator:-; 52, 53; 52, 57; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, identifier:T; 57, integer:1; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:M; 61, subscript; 61, 62; 61, 63; 62, identifier:R; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:R; 66, identifier:searchsorted; 67, argument_list; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:range; 70, argument_list; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:len; 73, argument_list; 73, 74; 74, identifier:T; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:D; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:T; 81, identifier:searchsorted; 82, argument_list; 82, 83; 83, identifier:X; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:T; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:np; 90, identifier:append; 91, argument_list; 91, 92; 91, 93; 92, identifier:T; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:np; 96, identifier:array; 97, argument_list; 97, 98; 98, list:[0]; 98, 99; 99, integer:0; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:M; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:np; 106, identifier:append; 107, argument_list; 107, 108; 107, 109; 108, identifier:M; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:np; 112, identifier:array; 113, argument_list; 113, 114; 114, list:[0]; 114, 115; 115, integer:0; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:A; 119, binary_operator:*; 119, 120; 119, 126; 120, parenthesized_expression; 120, 121; 121, comparison_operator:==; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:T; 124, identifier:D; 125, identifier:X; 126, identifier:D; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:B; 130, binary_operator:*; 130, 131; 130, 137; 131, parenthesized_expression; 131, 132; 132, comparison_operator:==; 132, 133; 132, 136; 133, subscript; 133, 134; 133, 135; 134, identifier:T; 135, identifier:D; 136, identifier:X; 137, parenthesized_expression; 137, 138; 138, binary_operator:+; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:M; 141, identifier:D; 142, integer:1; 143, return_statement; 143, 144; 144, list:[A,B]; 144, 145; 144, 146; 145, identifier:A; 146, identifier:B | def equalspairs(X, Y):
T = Y.copy()
R = (T[1:] != T[:-1]).nonzero()[0]
R = np.append(R,np.array([len(T)-1]))
M = R[R.searchsorted(range(len(T)))]
D = T.searchsorted(X)
T = np.append(T,np.array([0]))
M = np.append(M,np.array([0]))
A = (T[D] == X) * D
B = (T[D] == X) * (M[D] + 1)
return [A,B] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:loadSV; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:fname; 5, default_parameter; 5, 6; 5, 7; 6, identifier:shape; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:titles; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:aligned; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:byteorder; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:renamer; 19, None; 20, dictionary_splat_pattern; 20, 21; 21, identifier:kwargs; 22, block; 22, 23; 22, 34; 22, 55; 22, 76; 22, 97; 22, 135; 22, 157; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, list_pattern; 25, 26; 25, 27; 26, identifier:columns; 27, identifier:metadata; 28, call; 28, 29; 28, 30; 29, identifier:loadSVcols; 30, argument_list; 30, 31; 30, 32; 31, identifier:fname; 32, dictionary_splat; 32, 33; 33, identifier:kwargs; 34, if_statement; 34, 35; 34, 42; 34, 49; 35, comparison_operator:in; 35, 36; 35, 37; 36, string:'names'; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:metadata; 40, identifier:keys; 41, argument_list; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:names; 46, subscript; 46, 47; 46, 48; 47, identifier:metadata; 48, string:'names'; 49, else_clause; 49, 50; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:names; 54, None; 55, if_statement; 55, 56; 55, 63; 55, 70; 56, comparison_operator:in; 56, 57; 56, 58; 57, string:'formats'; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:metadata; 61, identifier:keys; 62, argument_list; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:formats; 67, subscript; 67, 68; 67, 69; 68, identifier:metadata; 69, string:'formats'; 70, else_clause; 70, 71; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:formats; 75, None; 76, if_statement; 76, 77; 76, 84; 76, 91; 77, comparison_operator:in; 77, 78; 77, 79; 78, string:'dtype'; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:metadata; 82, identifier:keys; 83, argument_list; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:dtype; 88, subscript; 88, 89; 88, 90; 89, identifier:metadata; 90, string:'dtype'; 91, else_clause; 91, 92; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:dtype; 96, None; 97, if_statement; 97, 98; 97, 101; 98, comparison_operator:is; 98, 99; 98, 100; 99, identifier:renamer; 100, None; 101, block; 101, 102; 101, 104; 101, 111; 102, print_statement; 102, 103; 103, string:'Trying user-given renamer ...'; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:renamed; 107, call; 107, 108; 107, 109; 108, identifier:renamer; 109, argument_list; 109, 110; 110, identifier:names; 111, if_statement; 111, 112; 111, 124; 111, 131; 112, comparison_operator:==; 112, 113; 112, 117; 113, call; 113, 114; 113, 115; 114, identifier:len; 115, argument_list; 115, 116; 116, identifier:renamed; 117, call; 117, 118; 117, 119; 118, identifier:len; 119, argument_list; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:uniqify; 122, argument_list; 122, 123; 123, identifier:renamed; 124, block; 124, 125; 124, 129; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:names; 128, identifier:renamed; 129, print_statement; 129, 130; 130, string:'''... using renamed names (original names will be in return
metadata)'''; 131, else_clause; 131, 132; 132, block; 132, 133; 133, print_statement; 133, 134; 134, string:'... renamer failed to produce unique names, not using.'; 135, if_statement; 135, 136; 135, 150; 136, boolean_operator:and; 136, 137; 136, 138; 137, identifier:names; 138, comparison_operator:!=; 138, 139; 138, 143; 139, call; 139, 140; 139, 141; 140, identifier:len; 141, argument_list; 141, 142; 142, identifier:names; 143, call; 143, 144; 143, 145; 144, identifier:len; 145, argument_list; 145, 146; 146, call; 146, 147; 146, 148; 147, identifier:uniqify; 148, argument_list; 148, 149; 149, identifier:names; 150, block; 150, 151; 150, 153; 151, print_statement; 151, 152; 152, string:'Names are not unique, reverting to default naming scheme.'; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:names; 156, None; 157, return_statement; 157, 158; 158, list:[utils.fromarrays(columns, type=np.ndarray, dtype=dtype,
shape=shape, formats=formats, names=names,
titles=titles, aligned=aligned,
byteorder=byteorder), metadata]; 158, 159; 158, 191; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:utils; 162, identifier:fromarrays; 163, argument_list; 163, 164; 163, 165; 163, 170; 163, 173; 163, 176; 163, 179; 163, 182; 163, 185; 163, 188; 164, identifier:columns; 165, keyword_argument; 165, 166; 165, 167; 166, identifier:type; 167, attribute; 167, 168; 167, 169; 168, identifier:np; 169, identifier:ndarray; 170, keyword_argument; 170, 171; 170, 172; 171, identifier:dtype; 172, identifier:dtype; 173, keyword_argument; 173, 174; 173, 175; 174, identifier:shape; 175, identifier:shape; 176, keyword_argument; 176, 177; 176, 178; 177, identifier:formats; 178, identifier:formats; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:names; 181, identifier:names; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:titles; 184, identifier:titles; 185, keyword_argument; 185, 186; 185, 187; 186, identifier:aligned; 187, identifier:aligned; 188, keyword_argument; 188, 189; 188, 190; 189, identifier:byteorder; 190, identifier:byteorder; 191, identifier:metadata | def loadSV(fname, shape=None, titles=None, aligned=False, byteorder=None,
renamer=None, **kwargs):
[columns, metadata] = loadSVcols(fname, **kwargs)
if 'names' in metadata.keys():
names = metadata['names']
else:
names = None
if 'formats' in metadata.keys():
formats = metadata['formats']
else:
formats = None
if 'dtype' in metadata.keys():
dtype = metadata['dtype']
else:
dtype = None
if renamer is not None:
print 'Trying user-given renamer ...'
renamed = renamer(names)
if len(renamed) == len(uniqify(renamed)):
names = renamed
print '''... using renamed names (original names will be in return
metadata)'''
else:
print '... renamer failed to produce unique names, not using.'
if names and len(names) != len(uniqify(names)):
print 'Names are not unique, reverting to default naming scheme.'
names = None
return [utils.fromarrays(columns, type=np.ndarray, dtype=dtype,
shape=shape, formats=formats, names=names,
titles=titles, aligned=aligned,
byteorder=byteorder), metadata] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:loadSVrecs; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:fname; 5, default_parameter; 5, 6; 5, 7; 6, identifier:uselines; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:skiprows; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:linefixer; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:delimiter_regex; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:verbosity; 19, identifier:DEFAULT_VERBOSITY; 20, dictionary_splat_pattern; 20, 21; 21, identifier:metadata; 22, block; 22, 23; 22, 46; 22, 70; 22, 81; 22, 113; 22, 134; 22, 224; 22, 238; 22, 283; 22, 289; 22, 305; 23, if_statement; 23, 24; 23, 33; 24, boolean_operator:and; 24, 25; 24, 26; 25, identifier:delimiter_regex; 26, call; 26, 27; 26, 28; 27, identifier:isinstance; 28, argument_list; 28, 29; 28, 30; 29, identifier:delimiter_regex; 30, attribute; 30, 31; 30, 32; 31, identifier:types; 32, identifier:StringType; 33, block; 33, 34; 33, 37; 34, import_statement; 34, 35; 35, dotted_name; 35, 36; 36, identifier:re; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:delimiter_regex; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:re; 43, identifier:compile; 44, argument_list; 44, 45; 45, identifier:delimiter_regex; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 52; 48, list_pattern; 48, 49; 48, 50; 48, 51; 49, identifier:metadata; 50, identifier:inferedlines; 51, identifier:WHOLETHING; 52, call; 52, 53; 52, 54; 53, identifier:getmetadata; 54, argument_list; 54, 55; 54, 56; 54, 59; 54, 62; 54, 65; 54, 68; 55, identifier:fname; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:skiprows; 58, identifier:skiprows; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:linefixer; 61, identifier:linefixer; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:delimiter_regex; 64, identifier:delimiter_regex; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:verbosity; 67, identifier:verbosity; 68, dictionary_splat; 68, 69; 69, identifier:metadata; 70, if_statement; 70, 71; 70, 74; 71, comparison_operator:is; 71, 72; 71, 73; 72, identifier:uselines; 73, None; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:uselines; 78, tuple; 78, 79; 78, 80; 79, integer:0; 80, False; 81, if_statement; 81, 82; 81, 86; 81, 95; 81, 106; 82, call; 82, 83; 82, 84; 83, identifier:is_string_like; 84, argument_list; 84, 85; 85, identifier:fname; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:fh; 90, call; 90, 91; 90, 92; 91, identifier:file; 92, argument_list; 92, 93; 92, 94; 93, identifier:fname; 94, string:'rU'; 95, elif_clause; 95, 96; 95, 101; 96, call; 96, 97; 96, 98; 97, identifier:hasattr; 98, argument_list; 98, 99; 98, 100; 99, identifier:fname; 100, string:'readline'; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:fh; 105, identifier:fname; 106, else_clause; 106, 107; 107, block; 107, 108; 108, raise_statement; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:ValueError; 111, argument_list; 111, 112; 112, string:'fname must be a string or file handle'; 113, for_statement; 113, 114; 113, 115; 113, 127; 114, identifier:_ind; 115, call; 115, 116; 115, 117; 116, identifier:range; 117, argument_list; 117, 118; 118, binary_operator:+; 118, 119; 118, 124; 119, binary_operator:+; 119, 120; 119, 121; 120, identifier:skiprows; 121, subscript; 121, 122; 121, 123; 122, identifier:uselines; 123, integer:0; 124, subscript; 124, 125; 124, 126; 125, identifier:metadata; 126, string:'headerlines'; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:fh; 132, identifier:readline; 133, argument_list; 134, if_statement; 134, 135; 134, 138; 135, boolean_operator:or; 135, 136; 135, 137; 136, identifier:linefixer; 137, identifier:delimiter_regex; 138, block; 138, 139; 138, 148; 138, 166; 138, 177; 138, 201; 138, 213; 138, 220; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:fh2; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:tempfile; 145, identifier:TemporaryFile; 146, argument_list; 146, 147; 147, string:'w+b'; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:F; 151, call; 151, 152; 151, 164; 152, attribute; 152, 153; 152, 163; 153, call; 153, 154; 153, 161; 154, attribute; 154, 155; 154, 160; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:fh; 158, identifier:read; 159, argument_list; 160, identifier:strip; 161, argument_list; 161, 162; 162, string:'\n'; 163, identifier:split; 164, argument_list; 164, 165; 165, string:'\n'; 166, if_statement; 166, 167; 166, 168; 167, identifier:linefixer; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:F; 172, call; 172, 173; 172, 174; 173, identifier:map; 174, argument_list; 174, 175; 174, 176; 175, identifier:linefixer; 176, identifier:F; 177, if_statement; 177, 178; 177, 179; 178, identifier:delimiter_regex; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:F; 183, call; 183, 184; 183, 185; 184, identifier:map; 185, argument_list; 185, 186; 185, 200; 186, lambda; 186, 187; 186, 189; 187, lambda_parameters; 187, 188; 188, identifier:line; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:delimiter_regex; 192, identifier:sub; 193, argument_list; 193, 194; 193, 199; 194, attribute; 194, 195; 194, 198; 195, subscript; 195, 196; 195, 197; 196, identifier:metadata; 197, string:'dialect'; 198, identifier:delimiter; 199, identifier:line; 200, identifier:F; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:fh2; 205, identifier:write; 206, argument_list; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, string:'\n'; 210, identifier:join; 211, argument_list; 211, 212; 212, identifier:F; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:fh2; 217, identifier:seek; 218, argument_list; 218, 219; 219, integer:0; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:fh; 223, identifier:fh2; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:reader; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:csv; 230, identifier:reader; 231, argument_list; 231, 232; 231, 233; 232, identifier:fh; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:dialect; 235, subscript; 235, 236; 235, 237; 236, identifier:metadata; 237, string:'dialect'; 238, if_statement; 238, 239; 238, 242; 238, 274; 239, subscript; 239, 240; 239, 241; 240, identifier:uselines; 241, integer:1; 242, block; 242, 243; 242, 247; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:linelist; 246, list:[]; 247, for_statement; 247, 248; 247, 249; 247, 250; 248, identifier:ln; 249, identifier:reader; 250, block; 250, 251; 251, if_statement; 251, 252; 251, 263; 251, 271; 252, comparison_operator:<=; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:reader; 255, identifier:line_num; 256, binary_operator:-; 256, 257; 256, 260; 257, subscript; 257, 258; 257, 259; 258, identifier:uselines; 259, integer:1; 260, subscript; 260, 261; 260, 262; 261, identifier:uselines; 262, integer:0; 263, block; 263, 264; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:linelist; 268, identifier:append; 269, argument_list; 269, 270; 270, identifier:ln; 271, else_clause; 271, 272; 272, block; 272, 273; 273, break_statement; 274, else_clause; 274, 275; 275, block; 275, 276; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:linelist; 279, call; 279, 280; 279, 281; 280, identifier:list; 281, argument_list; 281, 282; 282, identifier:reader; 283, expression_statement; 283, 284; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:fh; 287, identifier:close; 288, argument_list; 289, if_statement; 289, 290; 289, 296; 290, comparison_operator:==; 290, 291; 290, 295; 291, subscript; 291, 292; 291, 293; 292, identifier:linelist; 293, unary_operator:-; 293, 294; 294, integer:1; 295, list:[]; 296, block; 296, 297; 297, expression_statement; 297, 298; 298, call; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:linelist; 301, identifier:pop; 302, argument_list; 302, 303; 303, unary_operator:-; 303, 304; 304, integer:1; 305, return_statement; 305, 306; 306, list:[linelist,metadata]; 306, 307; 306, 308; 307, identifier:linelist; 308, identifier:metadata | def loadSVrecs(fname, uselines=None, skiprows=0, linefixer=None,
delimiter_regex=None, verbosity=DEFAULT_VERBOSITY, **metadata):
if delimiter_regex and isinstance(delimiter_regex, types.StringType):
import re
delimiter_regex = re.compile(delimiter_regex)
[metadata, inferedlines, WHOLETHING] = getmetadata(fname, skiprows=skiprows,
linefixer=linefixer,
delimiter_regex=delimiter_regex,
verbosity=verbosity, **metadata)
if uselines is None:
uselines = (0,False)
if is_string_like(fname):
fh = file(fname, 'rU')
elif hasattr(fname, 'readline'):
fh = fname
else:
raise ValueError('fname must be a string or file handle')
for _ind in range(skiprows+uselines[0] + metadata['headerlines']):
fh.readline()
if linefixer or delimiter_regex:
fh2 = tempfile.TemporaryFile('w+b')
F = fh.read().strip('\n').split('\n')
if linefixer:
F = map(linefixer,F)
if delimiter_regex:
F = map(lambda line:
delimiter_regex.sub(metadata['dialect'].delimiter, line), F)
fh2.write('\n'.join(F))
fh2.seek(0)
fh = fh2
reader = csv.reader(fh, dialect=metadata['dialect'])
if uselines[1]:
linelist = []
for ln in reader:
if reader.line_num <= uselines[1] - uselines[0]:
linelist.append(ln)
else:
break
else:
linelist = list(reader)
fh.close()
if linelist[-1] == []:
linelist.pop(-1)
return [linelist,metadata] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 1, 13; 2, function_name:dflt_interval; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:cd_id; 7, type; 7, 8; 8, identifier:str; 9, type; 9, 10; 10, tuple; 10, 11; 10, 12; 11, identifier:int; 12, identifier:int; 13, block; 13, 14; 13, 21; 13, 25; 13, 29; 13, 82; 13, 107; 13, 113; 13, 121; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:LOGGER; 18, identifier:debug; 19, argument_list; 19, 20; 20, string:'RevocationCache.dflt_interval >>>'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:fro; 24, None; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:to; 28, None; 29, for_statement; 29, 30; 29, 31; 29, 32; 30, identifier:rr_id; 31, identifier:self; 32, block; 32, 33; 32, 42; 32, 48; 33, if_statement; 33, 34; 33, 40; 34, comparison_operator:!=; 34, 35; 34, 36; 35, identifier:cd_id; 36, call; 36, 37; 36, 38; 37, identifier:rev_reg_id2cred_def_id; 38, argument_list; 38, 39; 39, identifier:rr_id; 40, block; 40, 41; 41, continue_statement; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:entry; 45, subscript; 45, 46; 45, 47; 46, identifier:self; 47, identifier:rr_id; 48, if_statement; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:entry; 51, identifier:rr_delta_frames; 52, block; 52, 53; 52, 72; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:to; 56, attribute; 56, 57; 56, 71; 57, call; 57, 58; 57, 59; 58, identifier:max; 59, argument_list; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:entry; 62, identifier:rr_delta_frames; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:key; 65, lambda; 65, 66; 65, 68; 66, lambda_parameters; 66, 67; 67, identifier:f; 68, attribute; 68, 69; 68, 70; 69, identifier:f; 70, identifier:to; 71, identifier:to; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:fro; 75, call; 75, 76; 75, 77; 76, identifier:min; 77, argument_list; 77, 78; 77, 81; 78, boolean_operator:or; 78, 79; 78, 80; 79, identifier:fro; 80, identifier:to; 81, identifier:to; 82, if_statement; 82, 83; 82, 88; 83, not_operator; 83, 84; 84, parenthesized_expression; 84, 85; 85, boolean_operator:and; 85, 86; 85, 87; 86, identifier:fro; 87, identifier:to; 88, block; 88, 89; 88, 97; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:LOGGER; 93, identifier:debug; 94, argument_list; 94, 95; 94, 96; 95, string:'RevocationCache.dflt_interval <!< No data for default non-revoc interval on cred def id %s'; 96, identifier:cd_id; 97, raise_statement; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:CacheIndex; 100, argument_list; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, string:'No data for default non-revoc interval on cred def id {}'; 104, identifier:format; 105, argument_list; 105, 106; 106, identifier:cd_id; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:rv; 110, tuple; 110, 111; 110, 112; 111, identifier:fro; 112, identifier:to; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:LOGGER; 117, identifier:debug; 118, argument_list; 118, 119; 118, 120; 119, string:'RevocationCache.dflt_interval <<< %s'; 120, identifier:rv; 121, return_statement; 121, 122; 122, identifier:rv | def dflt_interval(self, cd_id: str) -> (int, int):
LOGGER.debug('RevocationCache.dflt_interval >>>')
fro = None
to = None
for rr_id in self:
if cd_id != rev_reg_id2cred_def_id(rr_id):
continue
entry = self[rr_id]
if entry.rr_delta_frames:
to = max(entry.rr_delta_frames, key=lambda f: f.to).to
fro = min(fro or to, to)
if not (fro and to):
LOGGER.debug(
'RevocationCache.dflt_interval <!< No data for default non-revoc interval on cred def id %s',
cd_id)
raise CacheIndex('No data for default non-revoc interval on cred def id {}'.format(cd_id))
rv = (fro, to)
LOGGER.debug('RevocationCache.dflt_interval <<< %s', rv)
return rv |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 1, 15; 2, function_name:parse; 3, parameters; 3, 4; 3, 8; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:base_dir; 6, type; 6, 7; 7, identifier:str; 8, typed_default_parameter; 8, 9; 8, 10; 8, 12; 9, identifier:timestamp; 10, type; 10, 11; 11, identifier:int; 12, None; 13, type; 13, 14; 14, identifier:int; 15, block; 15, 16; 15, 25; 15, 48; 15, 100; 15, 111; 15, 135; 15, 178; 15, 249; 15, 393; 15, 401; 16, expression_statement; 16, 17; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:LOGGER; 20, identifier:debug; 21, argument_list; 21, 22; 21, 23; 21, 24; 22, string:'parse >>> base_dir: %s, timestamp: %s'; 23, identifier:base_dir; 24, identifier:timestamp; 25, if_statement; 25, 26; 25, 31; 26, not_operator; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:isdir; 29, argument_list; 29, 30; 30, identifier:base_dir; 31, block; 31, 32; 31, 39; 31, 46; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:LOGGER; 36, identifier:info; 37, argument_list; 37, 38; 38, string:'No cache archives available: not feeding cache'; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:LOGGER; 43, identifier:debug; 44, argument_list; 44, 45; 45, string:'parse <<< None'; 46, return_statement; 46, 47; 47, None; 48, if_statement; 48, 49; 48, 51; 49, not_operator; 49, 50; 50, identifier:timestamp; 51, block; 51, 52; 51, 72; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:timestamps; 55, list_comprehension; 55, 56; 55, 60; 55, 66; 56, call; 56, 57; 56, 58; 57, identifier:int; 58, argument_list; 58, 59; 59, identifier:t; 60, for_in_clause; 60, 61; 60, 62; 61, identifier:t; 62, call; 62, 63; 62, 64; 63, identifier:listdir; 64, argument_list; 64, 65; 65, identifier:base_dir; 66, if_clause; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:t; 70, identifier:isdigit; 71, argument_list; 72, if_statement; 72, 73; 72, 74; 72, 82; 73, identifier:timestamps; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:timestamp; 78, call; 78, 79; 78, 80; 79, identifier:max; 80, argument_list; 80, 81; 81, identifier:timestamps; 82, else_clause; 82, 83; 83, block; 83, 84; 83, 91; 83, 98; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:LOGGER; 88, identifier:info; 89, argument_list; 89, 90; 90, string:'No cache archives available: not feeding cache'; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:LOGGER; 95, identifier:debug; 96, argument_list; 96, 97; 97, string:'parse <<< None'; 98, return_statement; 98, 99; 99, None; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:timestamp_dir; 103, call; 103, 104; 103, 105; 104, identifier:join; 105, argument_list; 105, 106; 105, 107; 106, identifier:base_dir; 107, call; 107, 108; 107, 109; 108, identifier:str; 109, argument_list; 109, 110; 110, identifier:timestamp; 111, if_statement; 111, 112; 111, 117; 112, not_operator; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:isdir; 115, argument_list; 115, 116; 116, identifier:timestamp_dir; 117, block; 117, 118; 117, 126; 117, 133; 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; 123, 125; 124, string:'No such archived cache directory: %s'; 125, identifier:timestamp_dir; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:LOGGER; 130, identifier:debug; 131, argument_list; 131, 132; 132, string:'parse <<< None'; 133, return_statement; 133, 134; 134, None; 135, with_statement; 135, 136; 135, 141; 136, with_clause; 136, 137; 137, with_item; 137, 138; 138, attribute; 138, 139; 138, 140; 139, identifier:SCHEMA_CACHE; 140, identifier:lock; 141, block; 141, 142; 142, with_statement; 142, 143; 142, 157; 143, with_clause; 143, 144; 144, with_item; 144, 145; 145, as_pattern; 145, 146; 145, 155; 146, call; 146, 147; 146, 148; 147, identifier:open; 148, argument_list; 148, 149; 148, 154; 149, call; 149, 150; 149, 151; 150, identifier:join; 151, argument_list; 151, 152; 151, 153; 152, identifier:timestamp_dir; 153, string:'schema'; 154, string:'r'; 155, as_pattern_target; 155, 156; 156, identifier:archive; 157, block; 157, 158; 157, 171; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:schemata; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:json; 164, identifier:loads; 165, argument_list; 165, 166; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:archive; 169, identifier:read; 170, argument_list; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:SCHEMA_CACHE; 175, identifier:feed; 176, argument_list; 176, 177; 177, identifier:schemata; 178, with_statement; 178, 179; 178, 184; 179, with_clause; 179, 180; 180, with_item; 180, 181; 181, attribute; 181, 182; 181, 183; 182, identifier:CRED_DEF_CACHE; 183, identifier:lock; 184, block; 184, 185; 185, with_statement; 185, 186; 185, 200; 186, with_clause; 186, 187; 187, with_item; 187, 188; 188, as_pattern; 188, 189; 188, 198; 189, call; 189, 190; 189, 191; 190, identifier:open; 191, argument_list; 191, 192; 191, 197; 192, call; 192, 193; 192, 194; 193, identifier:join; 194, argument_list; 194, 195; 194, 196; 195, identifier:timestamp_dir; 196, string:'cred_def'; 197, string:'r'; 198, as_pattern_target; 198, 199; 199, identifier:archive; 200, block; 200, 201; 200, 214; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:cred_defs; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:json; 207, identifier:loads; 208, argument_list; 208, 209; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:archive; 212, identifier:read; 213, argument_list; 214, for_statement; 214, 215; 214, 216; 214, 217; 215, identifier:cd_id; 216, identifier:cred_defs; 217, block; 217, 218; 218, if_statement; 218, 219; 218, 222; 218, 231; 219, comparison_operator:in; 219, 220; 219, 221; 220, identifier:cd_id; 221, identifier:CRED_DEF_CACHE; 222, block; 222, 223; 223, expression_statement; 223, 224; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:LOGGER; 227, identifier:warning; 228, argument_list; 228, 229; 228, 230; 229, string:'Cred def cache already has cred def on %s: skipping'; 230, identifier:cd_id; 231, else_clause; 231, 232; 232, block; 232, 233; 232, 241; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 238; 235, subscript; 235, 236; 235, 237; 236, identifier:CRED_DEF_CACHE; 237, identifier:cd_id; 238, subscript; 238, 239; 238, 240; 239, identifier:cred_defs; 240, identifier:cd_id; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:LOGGER; 245, identifier:info; 246, argument_list; 246, 247; 246, 248; 247, string:'Cred def cache imported cred def for cred def id %s'; 248, identifier:cd_id; 249, with_statement; 249, 250; 249, 255; 250, with_clause; 250, 251; 251, with_item; 251, 252; 252, attribute; 252, 253; 252, 254; 253, identifier:REVO_CACHE; 254, identifier:lock; 255, block; 255, 256; 256, with_statement; 256, 257; 256, 271; 257, with_clause; 257, 258; 258, with_item; 258, 259; 259, as_pattern; 259, 260; 259, 269; 260, call; 260, 261; 260, 262; 261, identifier:open; 262, argument_list; 262, 263; 262, 268; 263, call; 263, 264; 263, 265; 264, identifier:join; 265, argument_list; 265, 266; 265, 267; 266, identifier:timestamp_dir; 267, string:'revocation'; 268, string:'r'; 269, as_pattern_target; 269, 270; 270, identifier:archive; 271, block; 271, 272; 271, 285; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:rr_cache_entries; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:json; 278, identifier:loads; 279, argument_list; 279, 280; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:archive; 283, identifier:read; 284, argument_list; 285, for_statement; 285, 286; 285, 289; 285, 294; 286, tuple_pattern; 286, 287; 286, 288; 287, identifier:rr_id; 288, identifier:entry; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:rr_cache_entries; 292, identifier:items; 293, argument_list; 294, block; 294, 295; 295, if_statement; 295, 296; 295, 299; 295, 308; 296, comparison_operator:in; 296, 297; 296, 298; 297, identifier:rr_id; 298, identifier:REVO_CACHE; 299, block; 299, 300; 300, expression_statement; 300, 301; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:LOGGER; 304, identifier:warning; 305, argument_list; 305, 306; 305, 307; 306, string:'Revocation cache already has entry on %s: skipping'; 307, identifier:rr_id; 308, else_clause; 308, 309; 309, block; 309, 310; 309, 319; 309, 342; 309, 349; 309, 372; 309, 379; 309, 385; 310, expression_statement; 310, 311; 311, assignment; 311, 312; 311, 313; 312, identifier:rr_cache_entry; 313, call; 313, 314; 313, 315; 314, identifier:RevoCacheEntry; 315, argument_list; 315, 316; 316, subscript; 316, 317; 316, 318; 317, identifier:entry; 318, string:'rev_reg_def'; 319, expression_statement; 319, 320; 320, assignment; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:rr_cache_entry; 323, identifier:rr_delta_frames; 324, list_comprehension; 324, 325; 324, 337; 325, call; 325, 326; 325, 327; 326, identifier:RevRegUpdateFrame; 327, argument_list; 327, 328; 327, 331; 327, 334; 328, subscript; 328, 329; 328, 330; 329, identifier:f; 330, string:'_to'; 331, subscript; 331, 332; 331, 333; 332, identifier:f; 333, string:'_timestamp'; 334, subscript; 334, 335; 334, 336; 335, identifier:f; 336, string:'_rr_update'; 337, for_in_clause; 337, 338; 337, 339; 338, identifier:f; 339, subscript; 339, 340; 339, 341; 340, identifier:entry; 341, string:'rr_delta_frames'; 342, expression_statement; 342, 343; 343, call; 343, 344; 343, 347; 344, attribute; 344, 345; 344, 346; 345, identifier:rr_cache_entry; 346, identifier:cull; 347, argument_list; 347, 348; 348, True; 349, expression_statement; 349, 350; 350, assignment; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:rr_cache_entry; 353, identifier:rr_state_frames; 354, list_comprehension; 354, 355; 354, 367; 355, call; 355, 356; 355, 357; 356, identifier:RevRegUpdateFrame; 357, argument_list; 357, 358; 357, 361; 357, 364; 358, subscript; 358, 359; 358, 360; 359, identifier:f; 360, string:'_to'; 361, subscript; 361, 362; 361, 363; 362, identifier:f; 363, string:'_timestamp'; 364, subscript; 364, 365; 364, 366; 365, identifier:f; 366, string:'_rr_update'; 367, for_in_clause; 367, 368; 367, 369; 368, identifier:f; 369, subscript; 369, 370; 369, 371; 370, identifier:entry; 371, string:'rr_state_frames'; 372, expression_statement; 372, 373; 373, call; 373, 374; 373, 377; 374, attribute; 374, 375; 374, 376; 375, identifier:rr_cache_entry; 376, identifier:cull; 377, argument_list; 377, 378; 378, False; 379, expression_statement; 379, 380; 380, assignment; 380, 381; 380, 384; 381, subscript; 381, 382; 381, 383; 382, identifier:REVO_CACHE; 383, identifier:rr_id; 384, identifier:rr_cache_entry; 385, expression_statement; 385, 386; 386, call; 386, 387; 386, 390; 387, attribute; 387, 388; 387, 389; 388, identifier:LOGGER; 389, identifier:info; 390, argument_list; 390, 391; 390, 392; 391, string:'Revocation cache imported entry for rev reg id %s'; 392, identifier:rr_id; 393, expression_statement; 393, 394; 394, call; 394, 395; 394, 398; 395, attribute; 395, 396; 395, 397; 396, identifier:LOGGER; 397, identifier:debug; 398, argument_list; 398, 399; 398, 400; 399, string:'parse <<< %s'; 400, identifier:timestamp; 401, return_statement; 401, 402; 402, identifier:timestamp | def parse(base_dir: str, timestamp: int = None) -> int:
LOGGER.debug('parse >>> base_dir: %s, timestamp: %s', base_dir, timestamp)
if not isdir(base_dir):
LOGGER.info('No cache archives available: not feeding cache')
LOGGER.debug('parse <<< None')
return None
if not timestamp:
timestamps = [int(t) for t in listdir(base_dir) if t.isdigit()]
if timestamps:
timestamp = max(timestamps)
else:
LOGGER.info('No cache archives available: not feeding cache')
LOGGER.debug('parse <<< None')
return None
timestamp_dir = join(base_dir, str(timestamp))
if not isdir(timestamp_dir):
LOGGER.error('No such archived cache directory: %s', timestamp_dir)
LOGGER.debug('parse <<< None')
return None
with SCHEMA_CACHE.lock:
with open(join(timestamp_dir, 'schema'), 'r') as archive:
schemata = json.loads(archive.read())
SCHEMA_CACHE.feed(schemata)
with CRED_DEF_CACHE.lock:
with open(join(timestamp_dir, 'cred_def'), 'r') as archive:
cred_defs = json.loads(archive.read())
for cd_id in cred_defs:
if cd_id in CRED_DEF_CACHE:
LOGGER.warning('Cred def cache already has cred def on %s: skipping', cd_id)
else:
CRED_DEF_CACHE[cd_id] = cred_defs[cd_id]
LOGGER.info('Cred def cache imported cred def for cred def id %s', cd_id)
with REVO_CACHE.lock:
with open(join(timestamp_dir, 'revocation'), 'r') as archive:
rr_cache_entries = json.loads(archive.read())
for (rr_id, entry) in rr_cache_entries.items():
if rr_id in REVO_CACHE:
LOGGER.warning('Revocation cache already has entry on %s: skipping', rr_id)
else:
rr_cache_entry = RevoCacheEntry(entry['rev_reg_def'])
rr_cache_entry.rr_delta_frames = [
RevRegUpdateFrame(
f['_to'],
f['_timestamp'],
f['_rr_update']) for f in entry['rr_delta_frames']
]
rr_cache_entry.cull(True)
rr_cache_entry.rr_state_frames = [
RevRegUpdateFrame(
f['_to'],
f['_timestamp'],
f['_rr_update']) for f in entry['rr_state_frames']
]
rr_cache_entry.cull(False)
REVO_CACHE[rr_id] = rr_cache_entry
LOGGER.info('Revocation cache imported entry for rev reg id %s', rr_id)
LOGGER.debug('parse <<< %s', timestamp)
return timestamp |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_convert_hbf_meta_val_for_xml; 3, parameters; 3, 4; 3, 5; 4, identifier:key; 5, identifier:val; 6, block; 6, 7; 6, 24; 6, 28; 6, 32; 6, 89; 6, 153; 7, if_statement; 7, 8; 7, 13; 8, call; 8, 9; 8, 10; 9, identifier:isinstance; 10, argument_list; 10, 11; 10, 12; 11, identifier:val; 12, identifier:list; 13, block; 13, 14; 14, return_statement; 14, 15; 15, list_comprehension; 15, 16; 15, 21; 16, call; 16, 17; 16, 18; 17, identifier:_convert_hbf_meta_val_for_xml; 18, argument_list; 18, 19; 18, 20; 19, identifier:key; 20, identifier:i; 21, for_in_clause; 21, 22; 21, 23; 22, identifier:i; 23, identifier:val; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:is_literal; 27, True; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:content; 31, None; 32, if_statement; 32, 33; 32, 38; 32, 79; 33, call; 33, 34; 33, 35; 34, identifier:isinstance; 35, argument_list; 35, 36; 35, 37; 36, identifier:val; 37, identifier:dict; 38, block; 38, 39; 38, 43; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:ret; 42, identifier:val; 43, if_statement; 43, 44; 43, 47; 43, 52; 44, comparison_operator:in; 44, 45; 44, 46; 45, string:'@href'; 46, identifier:val; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:is_literal; 51, False; 52, else_clause; 52, 53; 53, block; 53, 54; 53, 63; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:content; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:val; 60, identifier:get; 61, argument_list; 61, 62; 62, string:'$'; 63, if_statement; 63, 64; 63, 74; 64, boolean_operator:and; 64, 65; 64, 70; 65, call; 65, 66; 65, 67; 66, identifier:isinstance; 67, argument_list; 67, 68; 67, 69; 68, identifier:content; 69, identifier:dict; 70, call; 70, 71; 70, 72; 71, identifier:_contains_hbf_meta_keys; 72, argument_list; 72, 73; 73, identifier:val; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:is_literal; 78, False; 79, else_clause; 79, 80; 80, block; 80, 81; 80, 85; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:ret; 84, dictionary; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:content; 88, identifier:val; 89, if_statement; 89, 90; 89, 91; 89, 135; 90, identifier:is_literal; 91, block; 91, 92; 91, 100; 91, 108; 91, 124; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:ret; 96, identifier:setdefault; 97, argument_list; 97, 98; 97, 99; 98, string:'@xsi:type'; 99, string:'nex:LiteralMeta'; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:ret; 104, identifier:setdefault; 105, argument_list; 105, 106; 105, 107; 106, string:'@property'; 107, identifier:key; 108, if_statement; 108, 109; 108, 112; 109, comparison_operator:is; 109, 110; 109, 111; 110, identifier:content; 111, None; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:ret; 117, identifier:setdefault; 118, argument_list; 118, 119; 118, 120; 119, string:'@datatype'; 120, call; 120, 121; 120, 122; 121, identifier:_python_instance_to_nexml_meta_datatype; 122, argument_list; 122, 123; 123, identifier:content; 124, if_statement; 124, 125; 124, 128; 125, comparison_operator:is; 125, 126; 125, 127; 126, identifier:ret; 127, identifier:val; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 134; 131, subscript; 131, 132; 131, 133; 132, identifier:ret; 133, string:'$'; 134, identifier:content; 135, else_clause; 135, 136; 136, block; 136, 137; 136, 145; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:ret; 141, identifier:setdefault; 142, argument_list; 142, 143; 142, 144; 143, string:'@xsi:type'; 144, string:'nex:ResourceMeta'; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:ret; 149, identifier:setdefault; 150, argument_list; 150, 151; 150, 152; 151, string:'@rel'; 152, identifier:key; 153, return_statement; 153, 154; 154, identifier:ret | def _convert_hbf_meta_val_for_xml(key, val):
if isinstance(val, list):
return [_convert_hbf_meta_val_for_xml(key, i) for i in val]
is_literal = True
content = None
if isinstance(val, dict):
ret = val
if '@href' in val:
is_literal = False
else:
content = val.get('$')
if isinstance(content, dict) and _contains_hbf_meta_keys(val):
is_literal = False
else:
ret = {}
content = val
if is_literal:
ret.setdefault('@xsi:type', 'nex:LiteralMeta')
ret.setdefault('@property', key)
if content is not None:
ret.setdefault('@datatype', _python_instance_to_nexml_meta_datatype(content))
if ret is not val:
ret['$'] = content
else:
ret.setdefault('@xsi:type', 'nex:ResourceMeta')
ret.setdefault('@rel', key)
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:validate_params_match; 3, parameters; 3, 4; 3, 5; 4, identifier:method; 5, identifier:parameters; 6, block; 6, 7; 6, 16; 6, 32; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:argspec; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:inspect; 13, identifier:getargspec; 14, argument_list; 14, 15; 15, identifier:method; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:default_length; 19, conditional_expression:if; 19, 20; 19, 26; 19, 31; 20, call; 20, 21; 20, 22; 21, identifier:len; 22, argument_list; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:argspec; 25, identifier:defaults; 26, comparison_operator:is; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:argspec; 29, identifier:defaults; 30, None; 31, integer:0; 32, if_statement; 32, 33; 32, 38; 32, 87; 33, call; 33, 34; 33, 35; 34, identifier:isinstance; 35, argument_list; 35, 36; 35, 37; 36, identifier:parameters; 37, identifier:list; 38, block; 38, 39; 38, 63; 38, 77; 39, if_statement; 39, 40; 39, 57; 40, boolean_operator:and; 40, 41; 40, 52; 41, comparison_operator:>; 41, 42; 41, 46; 42, call; 42, 43; 42, 44; 43, identifier:len; 44, argument_list; 44, 45; 45, identifier:parameters; 46, call; 46, 47; 46, 48; 47, identifier:len; 48, argument_list; 48, 49; 49, attribute; 49, 50; 49, 51; 50, identifier:argspec; 51, identifier:args; 52, comparison_operator:is; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:argspec; 55, identifier:varargs; 56, None; 57, block; 57, 58; 58, raise_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:InvalidParamsError; 61, argument_list; 61, 62; 62, string:"Too many parameters"; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:remaining_parameters; 66, binary_operator:-; 66, 67; 66, 73; 67, call; 67, 68; 67, 69; 68, identifier:len; 69, argument_list; 69, 70; 70, attribute; 70, 71; 70, 72; 71, identifier:argspec; 72, identifier:args; 73, call; 73, 74; 73, 75; 74, identifier:len; 75, argument_list; 75, 76; 76, identifier:parameters; 77, if_statement; 77, 78; 77, 81; 78, comparison_operator:>; 78, 79; 78, 80; 79, identifier:remaining_parameters; 80, identifier:default_length; 81, block; 81, 82; 82, raise_statement; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:InvalidParamsError; 85, argument_list; 85, 86; 86, string:"Not enough parameters"; 87, elif_clause; 87, 88; 87, 93; 88, call; 88, 89; 88, 90; 89, identifier:isinstance; 90, argument_list; 90, 91; 90, 92; 91, identifier:parameters; 92, identifier:dict; 93, block; 93, 94; 93, 108; 93, 128; 93, 147; 93, 161; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:missing_parameters; 97, list_comprehension; 97, 98; 97, 99; 97, 104; 98, identifier:key; 99, for_in_clause; 99, 100; 99, 101; 100, identifier:key; 101, attribute; 101, 102; 101, 103; 102, identifier:argspec; 103, identifier:args; 104, if_clause; 104, 105; 105, comparison_operator:not; 105, 106; 105, 107; 106, identifier:key; 107, identifier:parameters; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:default_parameters; 111, call; 111, 112; 111, 113; 112, identifier:set; 113, argument_list; 113, 114; 114, subscript; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:argspec; 117, identifier:args; 118, slice; 118, 119; 118, 127; 119, binary_operator:-; 119, 120; 119, 126; 120, call; 120, 121; 120, 122; 121, identifier:len; 122, argument_list; 122, 123; 123, attribute; 123, 124; 123, 125; 124, identifier:argspec; 125, identifier:args; 126, identifier:default_length; 127, colon; 128, for_statement; 128, 129; 128, 130; 128, 131; 129, identifier:key; 130, identifier:missing_parameters; 131, block; 131, 132; 132, if_statement; 132, 133; 132, 136; 133, comparison_operator:not; 133, 134; 133, 135; 134, identifier:key; 135, identifier:default_parameters; 136, block; 136, 137; 137, raise_statement; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:InvalidParamsError; 140, argument_list; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, string:"Parameter {} has not been satisfied"; 144, identifier:format; 145, argument_list; 145, 146; 146, identifier:key; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:extra_params; 150, list_comprehension; 150, 151; 150, 152; 150, 155; 151, identifier:key; 152, for_in_clause; 152, 153; 152, 154; 153, identifier:key; 154, identifier:parameters; 155, if_clause; 155, 156; 156, comparison_operator:not; 156, 157; 156, 158; 157, identifier:key; 158, attribute; 158, 159; 158, 160; 159, identifier:argspec; 160, identifier:args; 161, if_statement; 161, 162; 161, 174; 162, boolean_operator:and; 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:extra_params; 168, integer:0; 169, comparison_operator:is; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:argspec; 172, identifier:keywords; 173, None; 174, block; 174, 175; 175, raise_statement; 175, 176; 176, call; 176, 177; 176, 178; 177, identifier:InvalidParamsError; 178, argument_list; 178, 179; 179, string:"Too many parameters" | def validate_params_match(method, parameters):
argspec = inspect.getargspec(method)
default_length = len(argspec.defaults) if argspec.defaults is not None else 0
if isinstance(parameters, list):
if len(parameters) > len(argspec.args) and argspec.varargs is None:
raise InvalidParamsError("Too many parameters")
remaining_parameters = len(argspec.args) - len(parameters)
if remaining_parameters > default_length:
raise InvalidParamsError("Not enough parameters")
elif isinstance(parameters, dict):
missing_parameters = [key for key in argspec.args if key not in parameters]
default_parameters = set(argspec.args[len(argspec.args) - default_length:])
for key in missing_parameters:
if key not in default_parameters:
raise InvalidParamsError("Parameter {} has not been satisfied".format(key))
extra_params = [key for key in parameters if key not in argspec.args]
if len(extra_params) > 0 and argspec.keywords is None:
raise InvalidParamsError("Too many parameters") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:addcols; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:X; 5, identifier:cols; 6, default_parameter; 6, 7; 6, 8; 7, identifier:names; 8, None; 9, block; 9, 10; 9, 34; 9, 188; 9, 208; 9, 238; 10, if_statement; 10, 11; 10, 16; 11, call; 11, 12; 11, 13; 12, identifier:isinstance; 13, argument_list; 13, 14; 13, 15; 14, identifier:names; 15, identifier:str; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:names; 20, list_comprehension; 20, 21; 20, 26; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:n; 24, identifier:strip; 25, argument_list; 26, for_in_clause; 26, 27; 26, 28; 27, identifier:n; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:names; 31, identifier:split; 32, argument_list; 32, 33; 33, string:','; 34, if_statement; 34, 35; 34, 40; 34, 151; 35, call; 35, 36; 35, 37; 36, identifier:isinstance; 37, argument_list; 37, 38; 37, 39; 38, identifier:cols; 39, identifier:list; 40, block; 40, 41; 41, if_statement; 41, 42; 41, 69; 41, 120; 42, call; 42, 43; 42, 44; 43, identifier:any; 44, argument_list; 44, 45; 45, list_comprehension; 45, 46; 45, 66; 46, boolean_operator:or; 46, 47; 46, 60; 46, 61; 47, boolean_operator:or; 47, 48; 47, 55; 48, call; 48, 49; 48, 50; 49, identifier:isinstance; 50, argument_list; 50, 51; 50, 52; 51, identifier:x; 52, attribute; 52, 53; 52, 54; 53, identifier:np; 54, identifier:ndarray; 55, call; 55, 56; 55, 57; 56, identifier:isinstance; 57, argument_list; 57, 58; 57, 59; 58, identifier:x; 59, identifier:list; 60, line_continuation:\; 61, call; 61, 62; 61, 63; 62, identifier:isinstance; 63, argument_list; 63, 64; 63, 65; 64, identifier:x; 65, identifier:tuple; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:x; 68, identifier:cols; 69, block; 69, 70; 69, 88; 69, 103; 70, assert_statement; 70, 71; 70, 87; 71, call; 71, 72; 71, 73; 72, identifier:all; 73, argument_list; 73, 74; 74, list_comprehension; 74, 75; 74, 84; 75, comparison_operator:==; 75, 76; 75, 80; 76, call; 76, 77; 76, 78; 77, identifier:len; 78, argument_list; 78, 79; 79, identifier:x; 80, call; 80, 81; 80, 82; 81, identifier:len; 82, argument_list; 82, 83; 83, identifier:X; 84, for_in_clause; 84, 85; 84, 86; 85, identifier:x; 86, identifier:cols; 87, string:'Trying to add columns of wrong length.'; 88, assert_statement; 88, 89; 88, 102; 89, boolean_operator:and; 89, 90; 89, 93; 90, comparison_operator:!=; 90, 91; 90, 92; 91, identifier:names; 92, None; 93, comparison_operator:==; 93, 94; 93, 98; 94, call; 94, 95; 94, 96; 95, identifier:len; 96, argument_list; 96, 97; 97, identifier:cols; 98, call; 98, 99; 98, 100; 99, identifier:len; 100, argument_list; 100, 101; 101, identifier:names; 102, string:'Number of columns to add must equal number of new names.'; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:cols; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:utils; 109, identifier:fromarrays; 110, argument_list; 110, 111; 110, 112; 110, 117; 111, identifier:cols; 112, keyword_argument; 112, 113; 112, 114; 113, identifier:type; 114, attribute; 114, 115; 114, 116; 115, identifier:np; 116, identifier:ndarray; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:names; 119, identifier:names; 120, else_clause; 120, 121; 121, block; 121, 122; 121, 133; 122, assert_statement; 122, 123; 122, 132; 123, comparison_operator:==; 123, 124; 123, 128; 124, call; 124, 125; 124, 126; 125, identifier:len; 126, argument_list; 126, 127; 127, identifier:cols; 128, call; 128, 129; 128, 130; 129, identifier:len; 130, argument_list; 130, 131; 131, identifier:X; 132, string:'Trying to add column of wrong length.'; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:cols; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:utils; 139, identifier:fromarrays; 140, argument_list; 140, 141; 140, 143; 140, 148; 141, list:[cols]; 141, 142; 142, identifier:cols; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:type; 145, attribute; 145, 146; 145, 147; 146, identifier:np; 147, identifier:ndarray; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:names; 150, identifier:names; 151, else_clause; 151, 152; 152, block; 152, 153; 152, 161; 153, assert_statement; 153, 154; 154, call; 154, 155; 154, 156; 155, identifier:isinstance; 156, argument_list; 156, 157; 156, 158; 157, identifier:cols; 158, attribute; 158, 159; 158, 160; 159, identifier:np; 160, identifier:ndarray; 161, if_statement; 161, 162; 161, 169; 162, comparison_operator:==; 162, 163; 162, 168; 163, attribute; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:cols; 166, identifier:dtype; 167, identifier:names; 168, None; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:cols; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:utils; 176, identifier:fromarrays; 177, argument_list; 177, 178; 177, 180; 177, 185; 178, list:[cols]; 178, 179; 179, identifier:cols; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:type; 182, attribute; 182, 183; 182, 184; 183, identifier:np; 184, identifier:ndarray; 185, keyword_argument; 185, 186; 185, 187; 186, identifier:names; 187, identifier:names; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:Replacements; 191, list_comprehension; 191, 192; 191, 193; 191, 200; 192, identifier:a; 193, for_in_clause; 193, 194; 193, 195; 194, identifier:a; 195, attribute; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:cols; 198, identifier:dtype; 199, identifier:names; 200, if_clause; 200, 201; 201, comparison_operator:in; 201, 202; 201, 203; 202, identifier:a; 203, attribute; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:X; 206, identifier:dtype; 207, identifier:names; 208, if_statement; 208, 209; 208, 215; 209, comparison_operator:>; 209, 210; 209, 214; 210, call; 210, 211; 210, 212; 211, identifier:len; 212, argument_list; 212, 213; 213, identifier:Replacements; 214, integer:0; 215, block; 215, 216; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 219; 218, identifier:print; 219, argument_list; 219, 220; 219, 221; 220, string:'Replacing columns'; 221, list_comprehension; 221, 222; 221, 223; 221, 230; 222, identifier:a; 223, for_in_clause; 223, 224; 223, 225; 224, identifier:a; 225, attribute; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:cols; 228, identifier:dtype; 229, identifier:names; 230, if_clause; 230, 231; 231, comparison_operator:in; 231, 232; 231, 233; 232, identifier:a; 233, attribute; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:X; 236, identifier:dtype; 237, identifier:names; 238, return_statement; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:utils; 242, identifier:fromarrays; 243, argument_list; 243, 244; 243, 286; 243, 291; 244, binary_operator:+; 244, 245; 244, 267; 245, list_comprehension; 245, 246; 245, 260; 246, conditional_expression:if; 246, 247; 246, 250; 246, 257; 247, subscript; 247, 248; 247, 249; 248, identifier:X; 249, identifier:a; 250, comparison_operator:not; 250, 251; 250, 252; 251, identifier:a; 252, attribute; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:cols; 255, identifier:dtype; 256, identifier:names; 257, subscript; 257, 258; 257, 259; 258, identifier:cols; 259, identifier:a; 260, for_in_clause; 260, 261; 260, 262; 261, identifier:a; 262, attribute; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:X; 265, identifier:dtype; 266, identifier:names; 267, list_comprehension; 267, 268; 267, 271; 267, 278; 268, subscript; 268, 269; 268, 270; 269, identifier:cols; 270, identifier:a; 271, for_in_clause; 271, 272; 271, 273; 272, identifier:a; 273, attribute; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:cols; 276, identifier:dtype; 277, identifier:names; 278, if_clause; 278, 279; 279, comparison_operator:not; 279, 280; 279, 281; 280, identifier:a; 281, attribute; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:X; 284, identifier:dtype; 285, identifier:names; 286, keyword_argument; 286, 287; 286, 288; 287, identifier:type; 288, attribute; 288, 289; 288, 290; 289, identifier:np; 290, identifier:ndarray; 291, keyword_argument; 291, 292; 291, 293; 292, identifier:names; 293, binary_operator:+; 293, 294; 293, 302; 294, call; 294, 295; 294, 296; 295, identifier:list; 296, argument_list; 296, 297; 297, attribute; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:X; 300, identifier:dtype; 301, identifier:names; 302, list_comprehension; 302, 303; 302, 304; 302, 311; 303, identifier:a; 304, for_in_clause; 304, 305; 304, 306; 305, identifier:a; 306, attribute; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:cols; 309, identifier:dtype; 310, identifier:names; 311, if_clause; 311, 312; 312, comparison_operator:not; 312, 313; 312, 314; 313, identifier:a; 314, attribute; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, identifier:X; 317, identifier:dtype; 318, identifier:names | def addcols(X, cols, names=None):
if isinstance(names,str):
names = [n.strip() for n in names.split(',')]
if isinstance(cols, list):
if any([isinstance(x,np.ndarray) or isinstance(x,list) or \
isinstance(x,tuple) for x in cols]):
assert all([len(x) == len(X) for x in cols]), \
'Trying to add columns of wrong length.'
assert names != None and len(cols) == len(names), \
'Number of columns to add must equal number of new names.'
cols = utils.fromarrays(cols,type=np.ndarray,names = names)
else:
assert len(cols) == len(X), 'Trying to add column of wrong length.'
cols = utils.fromarrays([cols], type=np.ndarray,names=names)
else:
assert isinstance(cols, np.ndarray)
if cols.dtype.names == None:
cols = utils.fromarrays([cols],type=np.ndarray, names=names)
Replacements = [a for a in cols.dtype.names if a in X.dtype.names]
if len(Replacements) > 0:
print('Replacing columns',
[a for a in cols.dtype.names if a in X.dtype.names])
return utils.fromarrays(
[X[a] if a not in cols.dtype.names else cols[a] for a in X.dtype.names] +
[cols[a] for a in cols.dtype.names if a not in X.dtype.names],
type=np.ndarray,
names=list(X.dtype.names) + [a for a in cols.dtype.names
if a not in X.dtype.names]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:replace; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 4, identifier:X; 5, identifier:old; 6, identifier:new; 7, default_parameter; 7, 8; 7, 9; 8, identifier:strict; 9, True; 10, default_parameter; 10, 11; 10, 12; 11, identifier:cols; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:rows; 15, None; 16, block; 16, 17; 16, 46; 16, 65; 17, if_statement; 17, 18; 17, 21; 17, 30; 18, comparison_operator:==; 18, 19; 18, 20; 19, identifier:cols; 20, None; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:cols; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:X; 28, identifier:dtype; 29, identifier:names; 30, elif_clause; 30, 31; 30, 36; 31, call; 31, 32; 31, 33; 32, identifier:isinstance; 33, argument_list; 33, 34; 33, 35; 34, identifier:cols; 35, identifier:str; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:cols; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:cols; 43, identifier:split; 44, argument_list; 44, 45; 45, string:','; 46, if_statement; 46, 47; 46, 50; 47, comparison_operator:==; 47, 48; 47, 49; 48, identifier:rows; 49, None; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:rows; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:np; 57, identifier:ones; 58, argument_list; 58, 59; 58, 64; 59, tuple; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:len; 62, argument_list; 62, 63; 63, identifier:X; 64, identifier:bool; 65, if_statement; 65, 66; 65, 67; 65, 127; 66, identifier:strict; 67, block; 67, 68; 67, 77; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:new; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:np; 74, identifier:array; 75, argument_list; 75, 76; 76, identifier:new; 77, for_statement; 77, 78; 77, 79; 77, 80; 78, identifier:a; 79, identifier:cols; 80, block; 80, 81; 80, 101; 81, if_statement; 81, 82; 81, 91; 82, comparison_operator:<; 82, 83; 82, 88; 83, subscript; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:X; 86, identifier:dtype; 87, identifier:a; 88, attribute; 88, 89; 88, 90; 89, identifier:new; 90, identifier:dtype; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 95; 94, identifier:print; 95, argument_list; 95, 96; 95, 97; 95, 98; 95, 99; 95, 100; 96, string:'WARNING: dtype of column'; 97, identifier:a; 98, string:'is inferior to dtype of '; 99, identifier:new; 100, string:'which may cause problems.'; 101, try_statement; 101, 102; 101, 118; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 117; 105, subscript; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:X; 108, identifier:a; 109, subscript; 109, 110; 109, 116; 110, parenthesized_expression; 110, 111; 111, comparison_operator:==; 111, 112; 111, 115; 112, subscript; 112, 113; 112, 114; 113, identifier:X; 114, identifier:a; 115, identifier:old; 116, identifier:rows; 117, identifier:new; 118, except_clause; 118, 119; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:print; 123, argument_list; 123, 124; 123, 125; 123, 126; 124, string:'Replacement not made on column'; 125, identifier:a; 126, string:'.'; 127, else_clause; 127, 128; 128, block; 128, 129; 129, for_statement; 129, 130; 129, 131; 129, 132; 130, identifier:a; 131, identifier:cols; 132, block; 132, 133; 132, 137; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:QuickRep; 136, True; 137, try_statement; 137, 138; 137, 152; 137, 162; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:colstr; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, string:''; 145, identifier:join; 146, argument_list; 146, 147; 147, subscript; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:X; 150, identifier:a; 151, identifier:rows; 152, except_clause; 152, 153; 152, 154; 153, identifier:TypeError; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 158; 157, identifier:print; 158, argument_list; 158, 159; 158, 160; 158, 161; 159, string:'Not replacing in column'; 160, identifier:a; 161, string:'due to type mismatch.'; 162, else_clause; 162, 163; 163, block; 163, 164; 163, 184; 163, 199; 163, 269; 163, 326; 163, 345; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:avoid; 167, list_comprehension; 167, 168; 167, 172; 168, call; 168, 169; 168, 170; 169, identifier:ord; 170, argument_list; 170, 171; 171, identifier:o; 172, for_in_clause; 172, 173; 172, 174; 173, identifier:o; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:utils; 177, identifier:uniqify; 178, argument_list; 178, 179; 179, binary_operator:+; 179, 180; 179, 183; 180, binary_operator:+; 180, 181; 180, 182; 181, identifier:old; 182, identifier:new; 183, identifier:colstr; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:ok; 187, call; 187, 188; 187, 197; 188, attribute; 188, 189; 188, 196; 189, call; 189, 190; 189, 191; 190, identifier:set; 191, argument_list; 191, 192; 192, call; 192, 193; 192, 194; 193, identifier:range; 194, argument_list; 194, 195; 195, integer:256; 196, identifier:difference; 197, argument_list; 197, 198; 198, identifier:avoid; 199, if_statement; 199, 200; 199, 206; 199, 219; 200, comparison_operator:>; 200, 201; 200, 205; 201, call; 201, 202; 201, 203; 202, identifier:len; 203, argument_list; 203, 204; 204, identifier:ok; 205, integer:0; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:sep; 210, call; 210, 211; 210, 212; 211, identifier:chr; 212, argument_list; 212, 213; 213, subscript; 213, 214; 213, 218; 214, call; 214, 215; 214, 216; 215, identifier:list; 216, argument_list; 216, 217; 217, identifier:ok; 218, integer:0; 219, else_clause; 219, 220; 220, block; 220, 221; 220, 236; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:ok; 224, call; 224, 225; 224, 234; 225, attribute; 225, 226; 225, 233; 226, call; 226, 227; 226, 228; 227, identifier:set; 228, argument_list; 228, 229; 229, call; 229, 230; 229, 231; 230, identifier:range; 231, argument_list; 231, 232; 232, integer:65536; 233, identifier:difference; 234, argument_list; 234, 235; 235, identifier:avoid; 236, if_statement; 236, 237; 236, 243; 236, 256; 237, comparison_operator:>; 237, 238; 237, 242; 238, call; 238, 239; 238, 240; 239, identifier:len; 240, argument_list; 240, 241; 241, identifier:ok; 242, integer:0; 243, block; 243, 244; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 247; 246, identifier:sep; 247, call; 247, 248; 247, 249; 248, identifier:unichr; 249, argument_list; 249, 250; 250, subscript; 250, 251; 250, 255; 251, call; 251, 252; 251, 253; 252, identifier:list; 253, argument_list; 253, 254; 254, identifier:ok; 255, integer:0; 256, else_clause; 256, 257; 257, block; 257, 258; 257, 265; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 261; 260, identifier:print; 261, argument_list; 261, 262; 261, 263; 261, 264; 262, string:'All unicode characters represented in column'; 263, identifier:a; 264, string:', can\t replace quickly.'; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:QuickRep; 268, False; 269, if_statement; 269, 270; 269, 271; 269, 301; 270, identifier:QuickRep; 271, block; 271, 272; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:newrows; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:np; 278, identifier:array; 279, argument_list; 279, 280; 280, call; 280, 281; 280, 299; 281, attribute; 281, 282; 281, 298; 282, call; 282, 283; 282, 295; 283, attribute; 283, 284; 283, 294; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:sep; 287, identifier:join; 288, argument_list; 288, 289; 289, subscript; 289, 290; 289, 293; 290, subscript; 290, 291; 290, 292; 291, identifier:X; 292, identifier:a; 293, identifier:rows; 294, identifier:replace; 295, argument_list; 295, 296; 295, 297; 296, identifier:old; 297, identifier:new; 298, identifier:split; 299, argument_list; 299, 300; 300, identifier:sep; 301, else_clause; 301, 302; 302, block; 302, 303; 303, expression_statement; 303, 304; 304, assignment; 304, 305; 304, 306; 305, identifier:newrows; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:np; 309, identifier:array; 310, argument_list; 310, 311; 311, list_comprehension; 311, 312; 311, 319; 312, call; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:aa; 315, identifier:replace; 316, argument_list; 316, 317; 316, 318; 317, identifier:old; 318, identifier:new; 319, for_in_clause; 319, 320; 319, 321; 320, identifier:aa; 321, subscript; 321, 322; 321, 325; 322, subscript; 322, 323; 322, 324; 323, identifier:X; 324, identifier:a; 325, identifier:rows; 326, expression_statement; 326, 327; 327, assignment; 327, 328; 327, 333; 328, subscript; 328, 329; 328, 332; 329, subscript; 329, 330; 329, 331; 330, identifier:X; 331, identifier:a; 332, identifier:rows; 333, call; 333, 334; 333, 343; 334, subscript; 334, 335; 334, 338; 335, attribute; 335, 336; 335, 337; 336, identifier:np; 337, identifier:cast; 338, subscript; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, identifier:X; 341, identifier:dtype; 342, identifier:a; 343, argument_list; 343, 344; 344, identifier:newrows; 345, if_statement; 345, 346; 345, 355; 346, comparison_operator:>; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, identifier:newrows; 349, identifier:dtype; 350, subscript; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:X; 353, identifier:dtype; 354, identifier:a; 355, block; 355, 356; 356, expression_statement; 356, 357; 357, call; 357, 358; 357, 359; 358, identifier:print; 359, argument_list; 359, 360; 359, 361; 359, 362; 360, string:'WARNING: dtype of column'; 361, identifier:a; 362, concatenated_string; 362, 363; 362, 364; 362, 365; 363, string:'is inferior to the '; 364, string:'dtype of its replacement which may cause problems '; 365, string:'(ends of strings might get chopped off).' | def replace(X, old, new, strict=True, cols=None, rows=None):
if cols == None:
cols = X.dtype.names
elif isinstance(cols, str):
cols = cols.split(',')
if rows == None:
rows = np.ones((len(X),), bool)
if strict:
new = np.array(new)
for a in cols:
if X.dtype[a] < new.dtype:
print('WARNING: dtype of column', a,
'is inferior to dtype of ', new,
'which may cause problems.')
try:
X[a][(X[a] == old)[rows]] = new
except:
print('Replacement not made on column', a, '.')
else:
for a in cols:
QuickRep = True
try:
colstr = ''.join(X[a][rows])
except TypeError:
print('Not replacing in column', a, 'due to type mismatch.')
else:
avoid = [ord(o) for o in utils.uniqify(old + new + colstr)]
ok = set(range(256)).difference(avoid)
if len(ok) > 0:
sep = chr(list(ok)[0])
else:
ok = set(range(65536)).difference(avoid)
if len(ok) > 0:
sep = unichr(list(ok)[0])
else:
print('All unicode characters represented in column',
a, ', can\t replace quickly.')
QuickRep = False
if QuickRep:
newrows = np.array(sep.join(X[a][rows])
.replace(old, new).split(sep))
else:
newrows = np.array([aa.replace(old,new) for aa in
X[a][rows]])
X[a][rows] = np.cast[X.dtype[a]](newrows)
if newrows.dtype > X.dtype[a]:
print('WARNING: dtype of column', a, 'is inferior to the '
'dtype of its replacement which may cause problems '
'(ends of strings might get chopped off).') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:rowstack; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:seq; 5, default_parameter; 5, 6; 5, 7; 6, identifier:mode; 7, string:'nulls'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:nullvals; 10, None; 11, block; 11, 12; 11, 14; 11, 25; 12, expression_statement; 12, 13; 13, string:'''
Vertically stack a sequence of numpy ndarrays with structured dtype
Analog of numpy.vstack
Implemented by the tabarray method
:func:`tabular.tab.tabarray.rowstack` which uses
:func:`tabular.tabarray.tab_rowstack`.
**Parameters**
**seq** : sequence of numpy recarrays
List, tuple, etc. of numpy recarrays to stack vertically.
**mode** : string in ['nulls', 'commons', 'abort']
Denotes how to proceed if the recarrays have different
dtypes, e.g. different sets of named columns.
* if `mode` == ``nulls``, the resulting set of columns is
determined by the union of the dtypes of all recarrays
to be stacked, and missing data is filled with null
values as defined by
:func:`tabular.spreadsheet.nullvalue`; this is the
default mode.
* elif `mode` == ``commons``, the resulting set of
columns is determined by the intersection of the dtypes
of all recarrays to be stacked, e.g. common columns.
* elif `mode` == ``abort``, raise an error when the
recarrays to stack have different dtypes.
**Returns**
**out** : numpy ndarray with structured dtype
Result of vertically stacking the arrays in `seq`.
**See also:** `numpy.vstack
<http://docs.scipy.org/doc/numpy/reference/generated/numpy.vstack.html>`_.
'''; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:==; 15, 16; 15, 17; 16, identifier:nullvals; 17, None; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:nullvals; 22, attribute; 22, 23; 22, 24; 23, identifier:utils; 24, identifier:DEFAULT_NULLVALUEFORMAT; 25, if_statement; 25, 26; 25, 32; 25, 333; 26, comparison_operator:>; 26, 27; 26, 31; 27, call; 27, 28; 27, 29; 28, identifier:len; 29, argument_list; 29, 30; 30, identifier:seq; 31, integer:1; 32, block; 32, 33; 32, 43; 32, 88; 33, assert_statement; 33, 34; 33, 40; 33, 41; 34, comparison_operator:in; 34, 35; 34, 36; 35, identifier:mode; 36, list:['commons','nulls','abort']; 36, 37; 36, 38; 36, 39; 37, string:'commons'; 38, string:'nulls'; 39, string:'abort'; 40, line_continuation:\; 41, parenthesized_expression; 41, 42; 42, string:'"mode" argument must either by "commons", "abort", or "nulls".'; 43, if_statement; 43, 44; 43, 47; 44, comparison_operator:==; 44, 45; 44, 46; 45, identifier:mode; 46, string:'abort'; 47, block; 47, 48; 48, if_statement; 48, 49; 48, 76; 48, 82; 49, not_operator; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:all; 52, argument_list; 52, 53; 53, list_comprehension; 53, 54; 53, 73; 54, comparison_operator:==; 54, 55; 54, 63; 55, call; 55, 56; 55, 57; 56, identifier:set; 57, argument_list; 57, 58; 58, attribute; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:l; 61, identifier:dtype; 62, identifier:names; 63, call; 63, 64; 63, 65; 64, identifier:set; 65, argument_list; 65, 66; 66, attribute; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:seq; 70, integer:0; 71, identifier:dtype; 72, identifier:names; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:l; 75, identifier:seq; 76, block; 76, 77; 77, raise_statement; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:ValueError; 80, argument_list; 80, 81; 81, string:'Some column names are different.'; 82, else_clause; 82, 83; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:mode; 87, string:'commons'; 88, if_statement; 88, 89; 88, 92; 88, 243; 89, comparison_operator:==; 89, 90; 89, 91; 90, identifier:mode; 91, string:'nulls'; 92, block; 92, 93; 92, 126; 92, 163; 92, 176; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:names; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:utils; 99, identifier:uniqify; 100, argument_list; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:utils; 104, identifier:listunion; 105, argument_list; 105, 106; 106, list_comprehension; 106, 107; 106, 115; 106, 118; 107, call; 107, 108; 107, 109; 108, identifier:list; 109, argument_list; 109, 110; 110, attribute; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:s; 113, identifier:dtype; 114, identifier:names; 115, for_in_clause; 115, 116; 115, 117; 116, identifier:s; 117, identifier:seq; 118, if_clause; 118, 119; 119, comparison_operator:!=; 119, 120; 119, 125; 120, attribute; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:s; 123, identifier:dtype; 124, identifier:names; 125, None; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:formats; 129, list_comprehension; 129, 130; 129, 160; 130, attribute; 130, 131; 130, 159; 131, call; 131, 132; 131, 133; 132, identifier:max; 133, argument_list; 133, 134; 134, list_comprehension; 134, 135; 134, 140; 134, 143; 135, subscript; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:s; 138, identifier:dtype; 139, identifier:att; 140, for_in_clause; 140, 141; 140, 142; 141, identifier:s; 142, identifier:seq; 143, if_clause; 143, 144; 144, boolean_operator:and; 144, 145; 144, 152; 145, comparison_operator:!=; 145, 146; 145, 151; 146, attribute; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:s; 149, identifier:dtype; 150, identifier:names; 151, None; 152, comparison_operator:in; 152, 153; 152, 154; 153, identifier:att; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:s; 157, identifier:dtype; 158, identifier:names; 159, identifier:str; 160, for_in_clause; 160, 161; 160, 162; 161, identifier:att; 162, identifier:names; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:dtype; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:np; 169, identifier:dtype; 170, argument_list; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:zip; 173, argument_list; 173, 174; 173, 175; 174, identifier:names; 175, identifier:formats; 176, return_statement; 176, 177; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:utils; 180, identifier:fromarrays; 181, argument_list; 181, 182; 181, 235; 181, 240; 182, list_comprehension; 182, 183; 182, 226; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:utils; 186, identifier:listunion; 187, argument_list; 187, 188; 188, list_comprehension; 188, 189; 188, 223; 189, conditional_expression:if; 189, 190; 189, 197; 189, 213; 190, call; 190, 191; 190, 196; 191, attribute; 191, 192; 191, 195; 192, subscript; 192, 193; 192, 194; 193, identifier:s; 194, identifier:att; 195, identifier:tolist; 196, argument_list; 197, parenthesized_expression; 197, 198; 198, boolean_operator:and; 198, 199; 198, 206; 199, comparison_operator:!=; 199, 200; 199, 205; 200, attribute; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:s; 203, identifier:dtype; 204, identifier:names; 205, None; 206, comparison_operator:in; 206, 207; 206, 208; 207, identifier:att; 208, attribute; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:s; 211, identifier:dtype; 212, identifier:names; 213, binary_operator:*; 213, 214; 213, 219; 214, list:[nullvals(format)]; 214, 215; 215, call; 215, 216; 215, 217; 216, identifier:nullvals; 217, argument_list; 217, 218; 218, identifier:format; 219, call; 219, 220; 219, 221; 220, identifier:len; 221, argument_list; 221, 222; 222, identifier:s; 223, for_in_clause; 223, 224; 223, 225; 224, identifier:s; 225, identifier:seq; 226, for_in_clause; 226, 227; 226, 230; 227, tuple_pattern; 227, 228; 227, 229; 228, identifier:att; 229, identifier:format; 230, call; 230, 231; 230, 232; 231, identifier:zip; 232, argument_list; 232, 233; 232, 234; 233, identifier:names; 234, identifier:formats; 235, keyword_argument; 235, 236; 235, 237; 236, identifier:type; 237, attribute; 237, 238; 237, 239; 238, identifier:np; 239, identifier:ndarray; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:dtype; 242, identifier:dtype; 243, elif_clause; 243, 244; 243, 247; 244, comparison_operator:==; 244, 245; 244, 246; 245, identifier:mode; 246, string:'commons'; 247, block; 247, 248; 247, 281; 247, 302; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 251; 250, identifier:names; 251, list_comprehension; 251, 252; 251, 253; 251, 262; 252, identifier:x; 253, for_in_clause; 253, 254; 253, 255; 254, identifier:x; 255, attribute; 255, 256; 255, 261; 256, attribute; 256, 257; 256, 260; 257, subscript; 257, 258; 257, 259; 258, identifier:seq; 259, integer:0; 260, identifier:dtype; 261, identifier:names; 262, if_clause; 262, 263; 263, call; 263, 264; 263, 265; 264, identifier:all; 265, argument_list; 265, 266; 266, list_comprehension; 266, 267; 266, 274; 267, comparison_operator:in; 267, 268; 267, 269; 268, identifier:x; 269, attribute; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:l; 272, identifier:dtype; 273, identifier:names; 274, for_in_clause; 274, 275; 274, 276; 275, identifier:l; 276, subscript; 276, 277; 276, 278; 277, identifier:seq; 278, slice; 278, 279; 278, 280; 279, integer:1; 280, colon; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:formats; 284, list_comprehension; 284, 285; 284, 299; 285, attribute; 285, 286; 285, 298; 286, call; 286, 287; 286, 288; 287, identifier:max; 288, argument_list; 288, 289; 289, list_comprehension; 289, 290; 289, 295; 290, subscript; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:a; 293, identifier:dtype; 294, identifier:att; 295, for_in_clause; 295, 296; 295, 297; 296, identifier:a; 297, identifier:seq; 298, identifier:str; 299, for_in_clause; 299, 300; 299, 301; 300, identifier:att; 301, identifier:names; 302, return_statement; 302, 303; 303, call; 303, 304; 303, 307; 304, attribute; 304, 305; 304, 306; 305, identifier:utils; 306, identifier:fromrecords; 307, argument_list; 307, 308; 307, 322; 307, 327; 307, 330; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:utils; 311, identifier:listunion; 312, argument_list; 312, 313; 313, list_comprehension; 313, 314; 313, 319; 314, call; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, identifier:ar; 317, identifier:tolist; 318, argument_list; 319, for_in_clause; 319, 320; 319, 321; 320, identifier:ar; 321, identifier:seq; 322, keyword_argument; 322, 323; 322, 324; 323, identifier:type; 324, attribute; 324, 325; 324, 326; 325, identifier:np; 326, identifier:ndarray; 327, keyword_argument; 327, 328; 327, 329; 328, identifier:names; 329, identifier:names; 330, keyword_argument; 330, 331; 330, 332; 331, identifier:formats; 332, identifier:formats; 333, else_clause; 333, 334; 334, block; 334, 335; 335, return_statement; 335, 336; 336, subscript; 336, 337; 336, 338; 337, identifier:seq; 338, integer:0 | def rowstack(seq, mode='nulls', nullvals=None):
'''
Vertically stack a sequence of numpy ndarrays with structured dtype
Analog of numpy.vstack
Implemented by the tabarray method
:func:`tabular.tab.tabarray.rowstack` which uses
:func:`tabular.tabarray.tab_rowstack`.
**Parameters**
**seq** : sequence of numpy recarrays
List, tuple, etc. of numpy recarrays to stack vertically.
**mode** : string in ['nulls', 'commons', 'abort']
Denotes how to proceed if the recarrays have different
dtypes, e.g. different sets of named columns.
* if `mode` == ``nulls``, the resulting set of columns is
determined by the union of the dtypes of all recarrays
to be stacked, and missing data is filled with null
values as defined by
:func:`tabular.spreadsheet.nullvalue`; this is the
default mode.
* elif `mode` == ``commons``, the resulting set of
columns is determined by the intersection of the dtypes
of all recarrays to be stacked, e.g. common columns.
* elif `mode` == ``abort``, raise an error when the
recarrays to stack have different dtypes.
**Returns**
**out** : numpy ndarray with structured dtype
Result of vertically stacking the arrays in `seq`.
**See also:** `numpy.vstack
<http://docs.scipy.org/doc/numpy/reference/generated/numpy.vstack.html>`_.
'''
if nullvals == None:
nullvals = utils.DEFAULT_NULLVALUEFORMAT
if len(seq) > 1:
assert mode in ['commons','nulls','abort'], \
('"mode" argument must either by "commons", "abort", or "nulls".')
if mode == 'abort':
if not all([set(l.dtype.names) == set(seq[0].dtype.names)
for l in seq]):
raise ValueError('Some column names are different.')
else:
mode = 'commons'
if mode == 'nulls':
names = utils.uniqify(utils.listunion([list(s.dtype.names)
for s in seq if s.dtype.names != None]))
formats = [max([s.dtype[att] for s in seq if s.dtype.names != None
and att in s.dtype.names]).str for att in names]
dtype = np.dtype(zip(names,formats))
return utils.fromarrays([utils.listunion([s[att].tolist()
if (s.dtype.names != None and att in s.dtype.names)
else [nullvals(format)] * len(s) for s in seq])
for (att, format) in zip(names, formats)], type=np.ndarray,
dtype=dtype)
elif mode == 'commons':
names = [x for x in seq[0].dtype.names
if all([x in l.dtype.names for l in seq[1:]])]
formats = [max([a.dtype[att] for a in seq]).str for att in names]
return utils.fromrecords(utils.listunion(
[ar.tolist() for ar in seq]), type=np.ndarray,
names=names, formats=formats)
else:
return seq[0] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:colstack; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:seq; 5, default_parameter; 5, 6; 5, 7; 6, identifier:mode; 7, string:'abort'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:returnnaming; 10, False; 11, block; 11, 12; 11, 21; 11, 46; 11, 76; 11, 95; 11, 223; 12, assert_statement; 12, 13; 12, 20; 13, comparison_operator:in; 13, 14; 13, 15; 14, identifier:mode; 15, list:['first','drop','abort','rename']; 15, 16; 15, 17; 15, 18; 15, 19; 16, string:'first'; 17, string:'drop'; 18, string:'abort'; 19, string:'rename'; 20, string:'mode argument must take on value "first","drop", "rename", or "abort".'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:AllNames; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:utils; 27, identifier:uniqify; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:utils; 32, identifier:listunion; 33, argument_list; 33, 34; 34, list_comprehension; 34, 35; 34, 43; 35, call; 35, 36; 35, 37; 36, identifier:list; 37, argument_list; 37, 38; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:l; 41, identifier:dtype; 42, identifier:names; 43, for_in_clause; 43, 44; 43, 45; 44, identifier:l; 45, identifier:seq; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:NameList; 49, list_comprehension; 49, 50; 49, 73; 50, tuple; 50, 51; 50, 52; 51, identifier:x; 52, list_comprehension; 52, 53; 52, 54; 52, 63; 53, identifier:i; 54, for_in_clause; 54, 55; 54, 56; 55, identifier:i; 56, call; 56, 57; 56, 58; 57, identifier:range; 58, argument_list; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:len; 61, argument_list; 61, 62; 62, identifier:seq; 63, if_clause; 63, 64; 64, comparison_operator:in; 64, 65; 64, 66; 65, identifier:x; 66, attribute; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:seq; 70, identifier:i; 71, identifier:dtype; 72, identifier:names; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:x; 75, identifier:AllNames; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:Commons; 79, list_comprehension; 79, 80; 79, 83; 79, 86; 80, subscript; 80, 81; 80, 82; 81, identifier:x; 82, integer:0; 83, for_in_clause; 83, 84; 83, 85; 84, identifier:x; 85, identifier:NameList; 86, if_clause; 86, 87; 87, comparison_operator:>; 87, 88; 87, 94; 88, call; 88, 89; 88, 90; 89, identifier:len; 90, argument_list; 90, 91; 91, subscript; 91, 92; 91, 93; 92, identifier:x; 93, integer:1; 94, integer:1; 95, if_statement; 95, 96; 95, 106; 95, 206; 96, boolean_operator:or; 96, 97; 96, 103; 97, comparison_operator:>; 97, 98; 97, 102; 98, call; 98, 99; 98, 100; 99, identifier:len; 100, argument_list; 100, 101; 101, identifier:Commons; 102, integer:0; 103, comparison_operator:==; 103, 104; 103, 105; 104, identifier:mode; 105, string:'first'; 106, block; 106, 107; 107, if_statement; 107, 108; 107, 111; 107, 119; 107, 143; 108, comparison_operator:==; 108, 109; 108, 110; 109, identifier:mode; 110, string:'abort'; 111, block; 111, 112; 112, raise_statement; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:ValueError; 115, argument_list; 115, 116; 116, binary_operator:+; 116, 117; 116, 118; 117, string:'There are common column names with differing '; 118, string:'values in the columns'; 119, elif_clause; 119, 120; 119, 123; 120, comparison_operator:==; 120, 121; 120, 122; 121, identifier:mode; 122, string:'drop'; 123, block; 123, 124; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:Names; 127, list_comprehension; 127, 128; 127, 134; 127, 139; 128, tuple; 128, 129; 128, 132; 128, 133; 129, subscript; 129, 130; 129, 131; 130, identifier:L; 131, integer:0; 132, identifier:x; 133, identifier:x; 134, for_in_clause; 134, 135; 134, 138; 135, tuple_pattern; 135, 136; 135, 137; 136, identifier:x; 137, identifier:L; 138, identifier:NameList; 139, if_clause; 139, 140; 140, comparison_operator:not; 140, 141; 140, 142; 141, identifier:x; 142, identifier:Commons; 143, elif_clause; 143, 144; 143, 147; 144, comparison_operator:==; 144, 145; 144, 146; 145, identifier:mode; 146, string:'rename'; 147, block; 147, 148; 147, 155; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:NameDict; 151, call; 151, 152; 151, 153; 152, identifier:dict; 153, argument_list; 153, 154; 154, identifier:NameList; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:Names; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:utils; 161, identifier:listunion; 162, argument_list; 162, 163; 163, list_comprehension; 163, 164; 163, 197; 163, 198; 164, list_comprehension; 164, 165; 164, 190; 165, conditional_expression:if; 165, 166; 165, 170; 165, 178; 165, 179; 166, tuple; 166, 167; 166, 168; 166, 169; 167, identifier:i; 168, identifier:n; 169, identifier:n; 170, comparison_operator:==; 170, 171; 170, 177; 171, call; 171, 172; 171, 173; 172, identifier:len; 173, argument_list; 173, 174; 174, subscript; 174, 175; 174, 176; 175, identifier:NameDict; 176, identifier:n; 177, integer:1; 178, line_continuation:\; 179, tuple; 179, 180; 179, 181; 179, 182; 180, identifier:i; 181, identifier:n; 182, binary_operator:+; 182, 183; 182, 186; 183, binary_operator:+; 183, 184; 183, 185; 184, identifier:n; 185, string:'_'; 186, call; 186, 187; 186, 188; 187, identifier:str; 188, argument_list; 188, 189; 189, identifier:i; 190, for_in_clause; 190, 191; 190, 192; 191, identifier:n; 192, attribute; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:s; 195, identifier:dtype; 196, identifier:names; 197, line_continuation:\; 198, for_in_clause; 198, 199; 198, 202; 199, tuple_pattern; 199, 200; 199, 201; 200, identifier:i; 201, identifier:s; 202, call; 202, 203; 202, 204; 203, identifier:enumerate; 204, argument_list; 204, 205; 205, identifier:seq; 206, else_clause; 206, 207; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:Names; 211, list_comprehension; 211, 212; 211, 218; 212, tuple; 212, 213; 212, 216; 212, 217; 213, subscript; 213, 214; 213, 215; 214, identifier:L; 215, integer:0; 216, identifier:x; 217, identifier:x; 218, for_in_clause; 218, 219; 218, 222; 219, tuple_pattern; 219, 220; 219, 221; 220, identifier:x; 221, identifier:L; 222, identifier:NameList; 223, if_statement; 223, 224; 223, 225; 223, 260; 224, identifier:returnnaming; 225, block; 225, 226; 226, return_statement; 226, 227; 227, expression_list; 227, 228; 227, 259; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:utils; 231, identifier:fromarrays; 232, argument_list; 232, 233; 232, 245; 232, 250; 233, list_comprehension; 233, 234; 233, 239; 234, subscript; 234, 235; 234, 238; 235, subscript; 235, 236; 235, 237; 236, identifier:seq; 237, identifier:i; 238, identifier:x; 239, for_in_clause; 239, 240; 239, 244; 240, tuple_pattern; 240, 241; 240, 242; 240, 243; 241, identifier:i; 242, identifier:x; 243, identifier:y; 244, identifier:Names; 245, keyword_argument; 245, 246; 245, 247; 246, identifier:type; 247, attribute; 247, 248; 247, 249; 248, identifier:np; 249, identifier:ndarray; 250, keyword_argument; 250, 251; 250, 252; 251, identifier:names; 252, subscript; 252, 253; 252, 258; 253, call; 253, 254; 253, 255; 254, identifier:zip; 255, argument_list; 255, 256; 256, list_splat; 256, 257; 257, identifier:Names; 258, integer:2; 259, identifier:Names; 260, else_clause; 260, 261; 261, block; 261, 262; 262, return_statement; 262, 263; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:utils; 266, identifier:fromarrays; 267, argument_list; 267, 268; 267, 280; 267, 285; 268, list_comprehension; 268, 269; 268, 274; 269, subscript; 269, 270; 269, 273; 270, subscript; 270, 271; 270, 272; 271, identifier:seq; 272, identifier:i; 273, identifier:x; 274, for_in_clause; 274, 275; 274, 279; 275, tuple_pattern; 275, 276; 275, 277; 275, 278; 276, identifier:i; 277, identifier:x; 278, identifier:y; 279, identifier:Names; 280, keyword_argument; 280, 281; 280, 282; 281, identifier:type; 282, attribute; 282, 283; 282, 284; 283, identifier:np; 284, identifier:ndarray; 285, keyword_argument; 285, 286; 285, 287; 286, identifier:names; 287, subscript; 287, 288; 287, 293; 288, call; 288, 289; 288, 290; 289, identifier:zip; 290, argument_list; 290, 291; 291, list_splat; 291, 292; 292, identifier:Names; 293, integer:2 | def colstack(seq, mode='abort',returnnaming=False):
assert mode in ['first','drop','abort','rename'], \
'mode argument must take on value "first","drop", "rename", or "abort".'
AllNames = utils.uniqify(utils.listunion(
[list(l.dtype.names) for l in seq]))
NameList = [(x, [i for i in range(len(seq)) if x in seq[i].dtype.names])
for x in AllNames]
Commons = [x[0] for x in NameList if len(x[1]) > 1]
if len(Commons) > 0 or mode == 'first':
if mode == 'abort':
raise ValueError('There are common column names with differing ' +
'values in the columns')
elif mode == 'drop':
Names = [(L[0], x,x) for (x, L) in NameList if x not in Commons]
elif mode == 'rename':
NameDict = dict(NameList)
Names = utils.listunion([[(i,n,n) if len(NameDict[n]) == 1 else \
(i,n,n + '_' + str(i)) for n in s.dtype.names] \
for (i,s) in enumerate(seq)])
else:
Names = [(L[0], x,x) for (x, L) in NameList]
if returnnaming:
return utils.fromarrays([seq[i][x] for (i, x,y) in Names],
type= np.ndarray,names=zip(*Names)[2]),Names
else:
return utils.fromarrays([seq[i][x] for (i, x,y) in Names],
type= np.ndarray,names=zip(*Names)[2]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:getjp2image; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:date; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sourceId; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:observatory; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:instrument; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:detector; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:measurement; 19, None; 20, block; 20, 21; 20, 23; 20, 27; 20, 31; 20, 66; 20, 97; 20, 125; 20, 153; 20, 181; 20, 209; 20, 215; 21, expression_statement; 21, 22; 22, string:'''
Helioviewer.org and JHelioviewer operate off of JPEG2000 formatted image data generated from science-quality FITS files. Use the APIs below to interact directly with these intermediary JPEG2000 files.
Download a JP2 image for the specified datasource that is the closest match in time to the `date` requested.
Either `sourceId` must be specified, or the combination of `observatory`, `instrument`, `detector`, and `measurement`.
Request Parameters:
Parameter Required Type Example Description
date Required string 2014-01-01T23:59:59Z Desired date/time of the JP2 image. ISO 8601 combined UTC date and time UTC format.
sourceId Optional number 14 Unique image datasource identifier.
observatory Optional string SDO Observatory name.
instrument Optional string AIA Instrument name.
detector Optional string AIA Detector name.
measurement Optional string 335 Measurement name.
jpip Optional boolean false Optionally return a JPIP URI instead of the binary data of the image itself.
json Optional boolean false Optionally return a JSON object.
EXAMPLE: http://helioviewer.org/api/v1/getJP2Image/?date=2014-01-01T23:59:59Z&sourceId=14&jpip=true
'''; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:base_url; 26, string:'http://helioviewer.org/api/v1/getJP2Image/?'; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:req_url; 30, string:''; 31, try_statement; 31, 32; 31, 59; 32, block; 32, 33; 32, 38; 32, 53; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:validate_iso8601; 36, argument_list; 36, 37; 37, identifier:date; 38, if_statement; 38, 39; 38, 48; 39, not_operator; 39, 40; 40, comparison_operator:==; 40, 41; 40, 47; 41, subscript; 41, 42; 41, 43; 42, identifier:date; 43, slice; 43, 44; 43, 46; 44, unary_operator:-; 44, 45; 45, integer:1; 46, colon; 47, string:'Z'; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, augmented_assignment:+=; 50, 51; 50, 52; 51, identifier:date; 52, string:'Z'; 53, expression_statement; 53, 54; 54, augmented_assignment:+=; 54, 55; 54, 56; 55, identifier:base_url; 56, binary_operator:+; 56, 57; 56, 58; 57, string:'date='; 58, identifier:date; 59, except_clause; 59, 60; 60, block; 60, 61; 61, raise_statement; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:ValueError; 64, argument_list; 64, 65; 65, string:"Your date input is not in iso8601 format. ex: 2014-01-01T23:59:59"; 66, if_statement; 66, 67; 66, 68; 67, identifier:sourceId; 68, block; 68, 69; 69, if_statement; 69, 70; 69, 76; 69, 84; 70, not_operator; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:isinstance; 73, argument_list; 73, 74; 73, 75; 74, identifier:sourceId; 75, identifier:int; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:logger; 81, identifier:error; 82, argument_list; 82, 83; 83, string:"The sourceId argument should be an int, ignoring it"; 84, else_clause; 84, 85; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, augmented_assignment:+=; 87, 88; 87, 89; 88, identifier:base_url; 89, binary_operator:+; 89, 90; 89, 96; 90, binary_operator:+; 90, 91; 90, 92; 91, string:"sourceId="; 92, call; 92, 93; 92, 94; 93, identifier:str; 94, argument_list; 94, 95; 95, identifier:sourceId; 96, string:"&"; 97, if_statement; 97, 98; 97, 99; 98, identifier:observatory; 99, block; 99, 100; 100, if_statement; 100, 101; 100, 107; 100, 115; 101, not_operator; 101, 102; 102, call; 102, 103; 102, 104; 103, identifier:isinstance; 104, argument_list; 104, 105; 104, 106; 105, identifier:observatory; 106, identifier:str; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:logger; 112, identifier:error; 113, argument_list; 113, 114; 114, string:"The observatory argument should be a str, ignoring it"; 115, else_clause; 115, 116; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, augmented_assignment:+=; 118, 119; 118, 120; 119, identifier:base_url; 120, binary_operator:+; 120, 121; 120, 124; 121, binary_operator:+; 121, 122; 121, 123; 122, string:"observatory="; 123, identifier:observatory; 124, string:"&"; 125, if_statement; 125, 126; 125, 127; 126, identifier:instrument; 127, block; 127, 128; 128, if_statement; 128, 129; 128, 135; 128, 143; 129, not_operator; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:isinstance; 132, argument_list; 132, 133; 132, 134; 133, identifier:instrument; 134, identifier:str; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:logger; 140, identifier:error; 141, argument_list; 141, 142; 142, string:"The instrument argument should be a str, ignoring it"; 143, else_clause; 143, 144; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, augmented_assignment:+=; 146, 147; 146, 148; 147, identifier:base_url; 148, binary_operator:+; 148, 149; 148, 152; 149, binary_operator:+; 149, 150; 149, 151; 150, string:"instrument="; 151, identifier:instrument; 152, string:"&"; 153, if_statement; 153, 154; 153, 155; 154, identifier:detector; 155, block; 155, 156; 156, if_statement; 156, 157; 156, 163; 156, 171; 157, not_operator; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:isinstance; 160, argument_list; 160, 161; 160, 162; 161, identifier:detector; 162, identifier:str; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:logger; 168, identifier:error; 169, argument_list; 169, 170; 170, string:"The detector argument should be a str, ignoring it"; 171, else_clause; 171, 172; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, augmented_assignment:+=; 174, 175; 174, 176; 175, identifier:base_url; 176, binary_operator:+; 176, 177; 176, 180; 177, binary_operator:+; 177, 178; 177, 179; 178, string:"detector="; 179, identifier:detector; 180, string:"&"; 181, if_statement; 181, 182; 181, 183; 182, identifier:measurement; 183, block; 183, 184; 184, if_statement; 184, 185; 184, 191; 184, 199; 185, not_operator; 185, 186; 186, call; 186, 187; 186, 188; 187, identifier:isinstance; 188, argument_list; 188, 189; 188, 190; 189, identifier:measurement; 190, identifier:str; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:logger; 196, identifier:error; 197, argument_list; 197, 198; 198, string:"The measurement argument should be a str, ignoring it"; 199, else_clause; 199, 200; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, augmented_assignment:+=; 202, 203; 202, 204; 203, identifier:base_url; 204, binary_operator:+; 204, 205; 204, 208; 205, binary_operator:+; 205, 206; 205, 207; 206, string:"measurement="; 207, identifier:detector; 208, string:"&"; 209, expression_statement; 209, 210; 210, augmented_assignment:+=; 210, 211; 210, 212; 211, identifier:req_url; 212, binary_operator:+; 212, 213; 212, 214; 213, identifier:base_url; 214, string:"jpip=true"; 215, return_statement; 215, 216; 216, call; 216, 217; 216, 218; 217, identifier:dispatch_http_get; 218, argument_list; 218, 219; 219, identifier:req_url | def getjp2image(date,
sourceId=None,
observatory=None,
instrument=None,
detector=None,
measurement=None):
'''
Helioviewer.org and JHelioviewer operate off of JPEG2000 formatted image data generated from science-quality FITS files. Use the APIs below to interact directly with these intermediary JPEG2000 files.
Download a JP2 image for the specified datasource that is the closest match in time to the `date` requested.
Either `sourceId` must be specified, or the combination of `observatory`, `instrument`, `detector`, and `measurement`.
Request Parameters:
Parameter Required Type Example Description
date Required string 2014-01-01T23:59:59Z Desired date/time of the JP2 image. ISO 8601 combined UTC date and time UTC format.
sourceId Optional number 14 Unique image datasource identifier.
observatory Optional string SDO Observatory name.
instrument Optional string AIA Instrument name.
detector Optional string AIA Detector name.
measurement Optional string 335 Measurement name.
jpip Optional boolean false Optionally return a JPIP URI instead of the binary data of the image itself.
json Optional boolean false Optionally return a JSON object.
EXAMPLE: http://helioviewer.org/api/v1/getJP2Image/?date=2014-01-01T23:59:59Z&sourceId=14&jpip=true
'''
base_url = 'http://helioviewer.org/api/v1/getJP2Image/?'
req_url = ''
try:
validate_iso8601(date)
if not date[-1:] == 'Z':
date += 'Z'
base_url += 'date=' + date
except:
raise ValueError(
"Your date input is not in iso8601 format. ex: 2014-01-01T23:59:59")
if sourceId:
if not isinstance(sourceId, int):
logger.error("The sourceId argument should be an int, ignoring it")
else:
base_url += "sourceId=" + str(sourceId) + "&"
if observatory:
if not isinstance(observatory, str):
logger.error(
"The observatory argument should be a str, ignoring it")
else:
base_url += "observatory=" + observatory + "&"
if instrument:
if not isinstance(instrument, str):
logger.error(
"The instrument argument should be a str, ignoring it")
else:
base_url += "instrument=" + instrument + "&"
if detector:
if not isinstance(detector, str):
logger.error("The detector argument should be a str, ignoring it")
else:
base_url += "detector=" + detector + "&"
if measurement:
if not isinstance(measurement, str):
logger.error(
"The measurement argument should be a str, ignoring it")
else:
base_url += "measurement=" + detector + "&"
req_url += base_url + "jpip=true"
return dispatch_http_get(req_url) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 1, 26; 2, function_name:loads_loader; 3, parameters; 3, 4; 3, 10; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:load_module; 6, type; 6, 7; 7, attribute; 7, 8; 7, 9; 8, identifier:types; 9, identifier:ModuleType; 10, typed_parameter; 10, 11; 10, 12; 11, identifier:pairs; 12, type; 12, 13; 13, generic_type; 13, 14; 13, 15; 14, identifier:Dict; 15, type_parameter; 15, 16; 15, 18; 16, type; 16, 17; 17, identifier:str; 18, type; 18, 19; 19, identifier:str; 20, type; 20, 21; 21, generic_type; 21, 22; 21, 23; 22, identifier:Optional; 23, type_parameter; 23, 24; 24, type; 24, 25; 25, identifier:JSGValidateable; 26, block; 26, 27; 26, 33; 26, 48; 26, 64; 26, 73; 26, 143; 26, 167; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:cntxt; 30, attribute; 30, 31; 30, 32; 31, identifier:load_module; 32, identifier:_CONTEXT; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:possible_type; 36, conditional_expression:if; 36, 37; 36, 42; 36, 47; 37, subscript; 37, 38; 37, 39; 38, identifier:pairs; 39, attribute; 39, 40; 39, 41; 40, identifier:cntxt; 41, identifier:TYPE; 42, comparison_operator:in; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:cntxt; 45, identifier:TYPE; 46, identifier:pairs; 47, None; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:target_class; 51, conditional_expression:if; 51, 52; 51, 58; 51, 63; 52, call; 52, 53; 52, 54; 53, identifier:getattr; 54, argument_list; 54, 55; 54, 56; 54, 57; 55, identifier:load_module; 56, identifier:possible_type; 57, None; 58, call; 58, 59; 58, 60; 59, identifier:isinstance; 60, argument_list; 60, 61; 60, 62; 61, identifier:possible_type; 62, identifier:str; 63, None; 64, if_statement; 64, 65; 64, 66; 65, identifier:target_class; 66, block; 66, 67; 67, return_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:target_class; 70, argument_list; 70, 71; 71, dictionary_splat; 71, 72; 72, identifier:pairs; 73, for_statement; 73, 74; 73, 75; 73, 78; 74, identifier:type_exception; 75, attribute; 75, 76; 75, 77; 76, identifier:cntxt; 77, identifier:TYPE_EXCEPTIONS; 78, block; 78, 79; 78, 97; 78, 105; 78, 111; 78, 117; 78, 135; 79, if_statement; 79, 80; 79, 86; 80, not_operator; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:hasattr; 83, argument_list; 83, 84; 83, 85; 84, identifier:load_module; 85, identifier:type_exception; 86, block; 86, 87; 87, raise_statement; 87, 88; 88, call; 88, 89; 88, 90; 89, identifier:ValueError; 90, argument_list; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:UNKNOWN_TYPE_EXCEPTION; 94, identifier:format; 95, argument_list; 95, 96; 96, identifier:type_exception; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:target_class; 100, call; 100, 101; 100, 102; 101, identifier:getattr; 102, argument_list; 102, 103; 102, 104; 103, identifier:load_module; 104, identifier:type_exception; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:target_strict; 108, attribute; 108, 109; 108, 110; 109, identifier:target_class; 110, identifier:_strict; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:target_class; 115, identifier:_strict; 116, False; 117, try_statement; 117, 118; 117, 127; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:rval; 122, call; 122, 123; 122, 124; 123, identifier:target_class; 124, argument_list; 124, 125; 125, dictionary_splat; 125, 126; 126, identifier:pairs; 127, finally_clause; 127, 128; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:target_class; 133, identifier:_strict; 134, identifier:target_strict; 135, if_statement; 135, 136; 135, 140; 136, call; 136, 137; 136, 138; 137, identifier:is_valid; 138, argument_list; 138, 139; 139, identifier:rval; 140, block; 140, 141; 141, return_statement; 141, 142; 142, identifier:rval; 143, if_statement; 143, 144; 143, 152; 144, boolean_operator:and; 144, 145; 144, 149; 145, not_operator; 145, 146; 146, attribute; 146, 147; 146, 148; 147, identifier:cntxt; 148, identifier:TYPE; 149, attribute; 149, 150; 149, 151; 150, identifier:cntxt; 151, identifier:TYPE_EXCEPTIONS; 152, block; 152, 153; 153, return_statement; 153, 154; 154, call; 154, 155; 154, 164; 155, call; 155, 156; 155, 157; 156, identifier:getattr; 157, argument_list; 157, 158; 157, 159; 158, identifier:load_module; 159, subscript; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:cntxt; 162, identifier:TYPE_EXCEPTIONS; 163, integer:0; 164, argument_list; 164, 165; 165, dictionary_splat; 165, 166; 166, identifier:pairs; 167, if_statement; 167, 168; 167, 173; 167, 179; 168, comparison_operator:in; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:cntxt; 171, identifier:TYPE; 172, identifier:pairs; 173, block; 173, 174; 174, raise_statement; 174, 175; 175, call; 175, 176; 175, 177; 176, identifier:ValueError; 177, argument_list; 177, 178; 178, string:f'Unknown reference type: "{cntxt.TYPE}": "{pairs[cntxt.TYPE]}"'; 179, else_clause; 179, 180; 180, block; 180, 181; 181, raise_statement; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:ValueError; 184, argument_list; 184, 185; 185, string:f'Missing "{cntxt.TYPE}" element' | def loads_loader(load_module: types.ModuleType, pairs: Dict[str, str]) -> Optional[JSGValidateable]:
cntxt = load_module._CONTEXT
possible_type = pairs[cntxt.TYPE] if cntxt.TYPE in pairs else None
target_class = getattr(load_module, possible_type, None) if isinstance(possible_type, str) else None
if target_class:
return target_class(**pairs)
for type_exception in cntxt.TYPE_EXCEPTIONS:
if not hasattr(load_module, type_exception):
raise ValueError(UNKNOWN_TYPE_EXCEPTION.format(type_exception))
target_class = getattr(load_module, type_exception)
target_strict = target_class._strict
target_class._strict = False
try:
rval = target_class(**pairs)
finally:
target_class._strict = target_strict
if is_valid(rval):
return rval
if not cntxt.TYPE and cntxt.TYPE_EXCEPTIONS:
return getattr(load_module, cntxt.TYPE_EXCEPTIONS[0])(**pairs)
if cntxt.TYPE in pairs:
raise ValueError(f'Unknown reference type: "{cntxt.TYPE}": "{pairs[cntxt.TYPE]}"')
else:
raise ValueError(f'Missing "{cntxt.TYPE}" element') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 1, 11; 2, function_name:get_cred_def; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:cd_id; 7, type; 7, 8; 8, identifier:str; 9, type; 9, 10; 10, identifier:str; 11, block; 11, 12; 11, 20; 11, 29; 11, 191; 11, 199; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:LOGGER; 16, identifier:debug; 17, argument_list; 17, 18; 17, 19; 18, string:'_BaseAgent.get_cred_def >>> cd_id: %s'; 19, identifier:cd_id; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:rv_json; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:json; 26, identifier:dumps; 27, argument_list; 27, 28; 28, dictionary; 29, with_statement; 29, 30; 29, 35; 30, with_clause; 30, 31; 31, with_item; 31, 32; 32, attribute; 32, 33; 32, 34; 33, identifier:CRED_DEF_CACHE; 34, identifier:lock; 35, block; 35, 36; 35, 70; 35, 83; 35, 93; 35, 102; 35, 137; 35, 172; 35, 183; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:in; 37, 38; 37, 39; 38, identifier:cd_id; 39, identifier:CRED_DEF_CACHE; 40, block; 40, 41; 40, 49; 40, 60; 40, 68; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:LOGGER; 45, identifier:info; 46, argument_list; 46, 47; 46, 48; 47, string:'_BaseAgent.get_cred_def: got cred def for %s from cache'; 48, identifier:cd_id; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:rv_json; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:json; 55, identifier:dumps; 56, argument_list; 56, 57; 57, subscript; 57, 58; 57, 59; 58, identifier:CRED_DEF_CACHE; 59, identifier:cd_id; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:LOGGER; 64, identifier:debug; 65, argument_list; 65, 66; 65, 67; 66, string:'_BaseAgent.get_cred_def <<< %s'; 67, identifier:rv_json; 68, return_statement; 68, 69; 69, identifier:rv_json; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:req_json; 73, await; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:ledger; 77, identifier:build_get_cred_def_request; 78, argument_list; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:did; 82, identifier:cd_id; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:resp_json; 86, await; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:_submit; 91, argument_list; 91, 92; 92, identifier:req_json; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:resp; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:json; 99, identifier:loads; 100, argument_list; 100, 101; 101, identifier:resp_json; 102, if_statement; 102, 103; 102, 118; 103, not_operator; 103, 104; 104, parenthesized_expression; 104, 105; 105, boolean_operator:and; 105, 106; 105, 109; 106, comparison_operator:in; 106, 107; 106, 108; 107, string:'result'; 108, identifier:resp; 109, call; 109, 110; 109, 115; 110, attribute; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:resp; 113, string:'result'; 114, identifier:get; 115, argument_list; 115, 116; 115, 117; 116, string:'data'; 117, None; 118, block; 118, 119; 118, 127; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:LOGGER; 123, identifier:debug; 124, argument_list; 124, 125; 124, 126; 125, string:'_BaseAgent.get_cred_def: <!< no cred def exists on %s'; 126, identifier:cd_id; 127, raise_statement; 127, 128; 128, call; 128, 129; 128, 130; 129, identifier:AbsentCredDef; 130, argument_list; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, string:'No cred def exists on {}'; 134, identifier:format; 135, argument_list; 135, 136; 136, identifier:cd_id; 137, try_statement; 137, 138; 137, 151; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 144; 141, tuple_pattern; 141, 142; 141, 143; 142, identifier:_; 143, identifier:rv_json; 144, await; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:ledger; 148, identifier:parse_get_cred_def_response; 149, argument_list; 149, 150; 150, identifier:resp_json; 151, except_clause; 151, 152; 151, 153; 152, identifier:IndyError; 153, block; 153, 154; 153, 162; 154, expression_statement; 154, 155; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:LOGGER; 158, identifier:debug; 159, argument_list; 159, 160; 159, 161; 160, string:'_BaseAgent.get_cred_def: <!< no cred def exists on %s'; 161, identifier:cd_id; 162, raise_statement; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:AbsentCredDef; 165, argument_list; 165, 166; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, string:'No cred def exists on {}'; 169, identifier:format; 170, argument_list; 170, 171; 171, identifier:cd_id; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:CRED_DEF_CACHE; 176, identifier:cd_id; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:json; 180, identifier:loads; 181, argument_list; 181, 182; 182, identifier:rv_json; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:LOGGER; 187, identifier:info; 188, argument_list; 188, 189; 188, 190; 189, string:'_BaseAgent.get_cred_def: got cred def %s from ledger'; 190, identifier:cd_id; 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; 196, 198; 197, string:'_BaseAgent.get_cred_def <<< %s'; 198, identifier:rv_json; 199, return_statement; 199, 200; 200, identifier:rv_json | async def get_cred_def(self, cd_id: str) -> str:
LOGGER.debug('_BaseAgent.get_cred_def >>> cd_id: %s', cd_id)
rv_json = json.dumps({})
with CRED_DEF_CACHE.lock:
if cd_id in CRED_DEF_CACHE:
LOGGER.info('_BaseAgent.get_cred_def: got cred def for %s from cache', cd_id)
rv_json = json.dumps(CRED_DEF_CACHE[cd_id])
LOGGER.debug('_BaseAgent.get_cred_def <<< %s', rv_json)
return rv_json
req_json = await ledger.build_get_cred_def_request(self.did, cd_id)
resp_json = await self._submit(req_json)
resp = json.loads(resp_json)
if not ('result' in resp and resp['result'].get('data', None)):
LOGGER.debug('_BaseAgent.get_cred_def: <!< no cred def exists on %s', cd_id)
raise AbsentCredDef('No cred def exists on {}'.format(cd_id))
try:
(_, rv_json) = await ledger.parse_get_cred_def_response(resp_json)
except IndyError:
LOGGER.debug('_BaseAgent.get_cred_def: <!< no cred def exists on %s', cd_id)
raise AbsentCredDef('No cred def exists on {}'.format(cd_id))
CRED_DEF_CACHE[cd_id] = json.loads(rv_json)
LOGGER.info('_BaseAgent.get_cred_def: got cred def %s from ledger', cd_id)
LOGGER.debug('_BaseAgent.get_cred_def <<< %s', rv_json)
return rv_json |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:convert_nexson_format; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:blob; 5, identifier:out_nexson_format; 6, default_parameter; 6, 7; 6, 8; 7, identifier:current_format; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:remove_old_structs; 11, True; 12, default_parameter; 12, 13; 12, 14; 13, identifier:pristine_if_invalid; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:sort_arbitrary; 17, False; 18, block; 18, 19; 18, 30; 18, 37; 18, 52; 18, 64; 18, 76; 18, 102; 18, 118; 18, 125; 18, 209; 18, 218; 18, 226; 19, if_statement; 19, 20; 19, 22; 20, not_operator; 20, 21; 21, identifier:current_format; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:current_format; 26, call; 26, 27; 26, 28; 27, identifier:detect_nexson_version; 28, argument_list; 28, 29; 29, identifier:blob; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:out_nexson_format; 33, call; 33, 34; 33, 35; 34, identifier:resolve_nexson_format; 35, argument_list; 35, 36; 36, identifier:out_nexson_format; 37, if_statement; 37, 38; 37, 41; 38, comparison_operator:==; 38, 39; 38, 40; 39, identifier:current_format; 40, identifier:out_nexson_format; 41, block; 41, 42; 41, 50; 42, if_statement; 42, 43; 42, 44; 43, identifier:sort_arbitrary; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:sort_arbitrarily_ordered_nexson; 48, argument_list; 48, 49; 49, identifier:blob; 50, return_statement; 50, 51; 51, identifier:blob; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:two2zero; 55, boolean_operator:and; 55, 56; 55, 60; 56, call; 56, 57; 56, 58; 57, identifier:_is_by_id_hbf; 58, argument_list; 58, 59; 59, identifier:out_nexson_format; 60, call; 60, 61; 60, 62; 61, identifier:_is_badgerfish_version; 62, argument_list; 62, 63; 63, identifier:current_format; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:zero2two; 67, boolean_operator:and; 67, 68; 67, 72; 68, call; 68, 69; 68, 70; 69, identifier:_is_by_id_hbf; 70, argument_list; 70, 71; 71, identifier:current_format; 72, call; 72, 73; 72, 74; 73, identifier:_is_badgerfish_version; 74, argument_list; 74, 75; 75, identifier:out_nexson_format; 76, if_statement; 76, 77; 76, 80; 77, boolean_operator:or; 77, 78; 77, 79; 78, identifier:two2zero; 79, identifier:zero2two; 80, block; 80, 81; 80, 98; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:blob; 84, call; 84, 85; 84, 86; 85, identifier:convert_nexson_format; 86, argument_list; 86, 87; 86, 88; 86, 89; 86, 92; 86, 95; 87, identifier:blob; 88, identifier:DIRECT_HONEY_BADGERFISH; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:current_format; 91, identifier:current_format; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:remove_old_structs; 94, identifier:remove_old_structs; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:pristine_if_invalid; 97, identifier:pristine_if_invalid; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:current_format; 101, identifier:DIRECT_HONEY_BADGERFISH; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:ccdict; 105, dictionary; 105, 106; 105, 109; 105, 112; 105, 115; 106, pair; 106, 107; 106, 108; 107, string:'output_format'; 108, identifier:out_nexson_format; 109, pair; 109, 110; 109, 111; 110, string:'input_format'; 111, identifier:current_format; 112, pair; 112, 113; 112, 114; 113, string:'remove_old_structs'; 114, identifier:remove_old_structs; 115, pair; 115, 116; 115, 117; 116, string:'pristine_if_invalid'; 117, identifier:pristine_if_invalid; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:ccfg; 121, call; 121, 122; 121, 123; 122, identifier:ConversionConfig; 123, argument_list; 123, 124; 124, identifier:ccdict; 125, if_statement; 125, 126; 125, 130; 125, 138; 125, 156; 125, 174; 125, 192; 126, call; 126, 127; 126, 128; 127, identifier:_is_badgerfish_version; 128, argument_list; 128, 129; 129, identifier:current_format; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:converter; 134, call; 134, 135; 134, 136; 135, identifier:Badgerfish2DirectNexson; 136, argument_list; 136, 137; 137, identifier:ccfg; 138, elif_clause; 138, 139; 138, 143; 139, call; 139, 140; 139, 141; 140, identifier:_is_badgerfish_version; 141, argument_list; 141, 142; 142, identifier:out_nexson_format; 143, block; 143, 144; 143, 149; 144, assert_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:_is_direct_hbf; 147, argument_list; 147, 148; 148, identifier:current_format; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:converter; 152, call; 152, 153; 152, 154; 153, identifier:Direct2BadgerfishNexson; 154, argument_list; 154, 155; 155, identifier:ccfg; 156, elif_clause; 156, 157; 156, 166; 157, boolean_operator:and; 157, 158; 157, 162; 158, call; 158, 159; 158, 160; 159, identifier:_is_direct_hbf; 160, argument_list; 160, 161; 161, identifier:current_format; 162, parenthesized_expression; 162, 163; 163, comparison_operator:==; 163, 164; 163, 165; 164, identifier:out_nexson_format; 165, identifier:BY_ID_HONEY_BADGERFISH; 166, block; 166, 167; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:converter; 170, call; 170, 171; 170, 172; 171, identifier:Direct2OptimalNexson; 172, argument_list; 172, 173; 173, identifier:ccfg; 174, elif_clause; 174, 175; 174, 184; 175, boolean_operator:and; 175, 176; 175, 180; 176, call; 176, 177; 176, 178; 177, identifier:_is_direct_hbf; 178, argument_list; 178, 179; 179, identifier:out_nexson_format; 180, parenthesized_expression; 180, 181; 181, comparison_operator:==; 181, 182; 181, 183; 182, identifier:current_format; 183, identifier:BY_ID_HONEY_BADGERFISH; 184, block; 184, 185; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:converter; 188, call; 188, 189; 188, 190; 189, identifier:Optimal2DirectNexson; 190, argument_list; 190, 191; 191, identifier:ccfg; 192, else_clause; 192, 193; 193, block; 193, 194; 194, raise_statement; 194, 195; 195, call; 195, 196; 195, 197; 196, identifier:NotImplementedError; 197, argument_list; 197, 198; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, string:'Conversion from {i} to {o}'; 201, identifier:format; 202, argument_list; 202, 203; 202, 206; 203, keyword_argument; 203, 204; 203, 205; 204, identifier:i; 205, identifier:current_format; 206, keyword_argument; 206, 207; 206, 208; 207, identifier:o; 208, identifier:out_nexson_format; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:blob; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:converter; 215, identifier:convert; 216, argument_list; 216, 217; 217, identifier:blob; 218, if_statement; 218, 219; 218, 220; 219, identifier:sort_arbitrary; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, call; 222, 223; 222, 224; 223, identifier:sort_arbitrarily_ordered_nexson; 224, argument_list; 224, 225; 225, identifier:blob; 226, return_statement; 226, 227; 227, identifier:blob | def convert_nexson_format(blob,
out_nexson_format,
current_format=None,
remove_old_structs=True,
pristine_if_invalid=False,
sort_arbitrary=False):
if not current_format:
current_format = detect_nexson_version(blob)
out_nexson_format = resolve_nexson_format(out_nexson_format)
if current_format == out_nexson_format:
if sort_arbitrary:
sort_arbitrarily_ordered_nexson(blob)
return blob
two2zero = _is_by_id_hbf(out_nexson_format) and _is_badgerfish_version(current_format)
zero2two = _is_by_id_hbf(current_format) and _is_badgerfish_version(out_nexson_format)
if two2zero or zero2two:
blob = convert_nexson_format(blob,
DIRECT_HONEY_BADGERFISH,
current_format=current_format,
remove_old_structs=remove_old_structs,
pristine_if_invalid=pristine_if_invalid)
current_format = DIRECT_HONEY_BADGERFISH
ccdict = {'output_format': out_nexson_format,
'input_format': current_format,
'remove_old_structs': remove_old_structs,
'pristine_if_invalid': pristine_if_invalid}
ccfg = ConversionConfig(ccdict)
if _is_badgerfish_version(current_format):
converter = Badgerfish2DirectNexson(ccfg)
elif _is_badgerfish_version(out_nexson_format):
assert _is_direct_hbf(current_format)
converter = Direct2BadgerfishNexson(ccfg)
elif _is_direct_hbf(current_format) and (out_nexson_format == BY_ID_HONEY_BADGERFISH):
converter = Direct2OptimalNexson(ccfg)
elif _is_direct_hbf(out_nexson_format) and (current_format == BY_ID_HONEY_BADGERFISH):
converter = Optimal2DirectNexson(ccfg)
else:
raise NotImplementedError('Conversion from {i} to {o}'.format(i=current_format, o=out_nexson_format))
blob = converter.convert(blob)
if sort_arbitrary:
sort_arbitrarily_ordered_nexson(blob)
return blob |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_inplace_sort_by_id; 3, parameters; 3, 4; 4, identifier:unsorted_list; 5, block; 5, 6; 5, 15; 5, 30; 5, 36; 5, 41; 6, if_statement; 6, 7; 6, 13; 7, not_operator; 7, 8; 8, call; 8, 9; 8, 10; 9, identifier:isinstance; 10, argument_list; 10, 11; 10, 12; 11, identifier:unsorted_list; 12, identifier:list; 13, block; 13, 14; 14, return_statement; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:sorted_list; 18, list_comprehension; 18, 19; 18, 27; 19, tuple; 19, 20; 19, 26; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:i; 23, identifier:get; 24, argument_list; 24, 25; 25, string:'@id'; 26, identifier:i; 27, for_in_clause; 27, 28; 27, 29; 28, identifier:i; 29, identifier:unsorted_list; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:sorted_list; 34, identifier:sort; 35, argument_list; 36, delete_statement; 36, 37; 37, subscript; 37, 38; 37, 39; 38, identifier:unsorted_list; 39, slice; 39, 40; 40, colon; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:unsorted_list; 45, identifier:extend; 46, argument_list; 46, 47; 47, list_comprehension; 47, 48; 47, 51; 48, subscript; 48, 49; 48, 50; 49, identifier:i; 50, integer:1; 51, for_in_clause; 51, 52; 51, 53; 52, identifier:i; 53, identifier:sorted_list | def _inplace_sort_by_id(unsorted_list):
if not isinstance(unsorted_list, list):
return
sorted_list = [(i.get('@id'), i) for i in unsorted_list]
sorted_list.sort()
del unsorted_list[:]
unsorted_list.extend([i[1] for i in sorted_list]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:cull_nonmatching_trees; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:nexson; 5, identifier:tree_id; 6, default_parameter; 6, 7; 6, 8; 7, identifier:curr_version; 8, None; 9, block; 9, 10; 9, 22; 9, 37; 9, 44; 9, 50; 9, 54; 9, 117; 9, 134; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:curr_version; 13, None; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:curr_version; 18, call; 18, 19; 18, 20; 19, identifier:detect_nexson_version; 20, argument_list; 20, 21; 21, identifier:nexson; 22, if_statement; 22, 23; 22, 28; 23, not_operator; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:_is_by_id_hbf; 26, argument_list; 26, 27; 27, identifier:curr_version; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:nexson; 32, call; 32, 33; 32, 34; 33, identifier:convert_nexson_format; 34, argument_list; 34, 35; 34, 36; 35, identifier:nexson; 36, identifier:BY_ID_HONEY_BADGERFISH; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:nexml_el; 40, call; 40, 41; 40, 42; 41, identifier:get_nexml_el; 42, argument_list; 42, 43; 43, identifier:nexson; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:tree_groups; 47, subscript; 47, 48; 47, 49; 48, identifier:nexml_el; 49, string:'treesById'; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:tree_groups_to_del; 53, list:[]; 54, for_statement; 54, 55; 54, 58; 54, 63; 55, pattern_list; 55, 56; 55, 57; 56, identifier:tgi; 57, identifier:tree_group; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:tree_groups; 61, identifier:items; 62, argument_list; 63, block; 63, 64; 63, 70; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:tbi; 67, subscript; 67, 68; 67, 69; 68, identifier:tree_group; 69, string:'treeById'; 70, if_statement; 70, 71; 70, 74; 70, 108; 71, comparison_operator:in; 71, 72; 71, 73; 72, identifier:tree_id; 73, identifier:tbi; 74, block; 74, 75; 74, 91; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:trees_to_del; 78, list_comprehension; 78, 79; 78, 80; 78, 87; 79, identifier:i; 80, for_in_clause; 80, 81; 80, 82; 81, identifier:i; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:tbi; 85, identifier:keys; 86, argument_list; 87, if_clause; 87, 88; 88, comparison_operator:!=; 88, 89; 88, 90; 89, identifier:i; 90, identifier:tree_id; 91, for_statement; 91, 92; 91, 93; 91, 94; 92, identifier:tid; 93, identifier:trees_to_del; 94, block; 94, 95; 94, 104; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 102; 97, attribute; 97, 98; 97, 101; 98, subscript; 98, 99; 98, 100; 99, identifier:tree_group; 100, string:'^ot:treeElementOrder'; 101, identifier:remove; 102, argument_list; 102, 103; 103, identifier:tid; 104, delete_statement; 104, 105; 105, subscript; 105, 106; 105, 107; 106, identifier:tbi; 107, identifier:tid; 108, else_clause; 108, 109; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:tree_groups_to_del; 114, identifier:append; 115, argument_list; 115, 116; 116, identifier:tgi; 117, for_statement; 117, 118; 117, 119; 117, 120; 118, identifier:tgid; 119, identifier:tree_groups_to_del; 120, block; 120, 121; 120, 130; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, subscript; 124, 125; 124, 126; 125, identifier:nexml_el; 126, string:'^ot:treesElementOrder'; 127, identifier:remove; 128, argument_list; 128, 129; 129, identifier:tgid; 130, delete_statement; 130, 131; 131, subscript; 131, 132; 131, 133; 132, identifier:tree_groups; 133, identifier:tgid; 134, return_statement; 134, 135; 135, identifier:nexson | def cull_nonmatching_trees(nexson, tree_id, curr_version=None):
if curr_version is None:
curr_version = detect_nexson_version(nexson)
if not _is_by_id_hbf(curr_version):
nexson = convert_nexson_format(nexson, BY_ID_HONEY_BADGERFISH)
nexml_el = get_nexml_el(nexson)
tree_groups = nexml_el['treesById']
tree_groups_to_del = []
for tgi, tree_group in tree_groups.items():
tbi = tree_group['treeById']
if tree_id in tbi:
trees_to_del = [i for i in tbi.keys() if i != tree_id]
for tid in trees_to_del:
tree_group['^ot:treeElementOrder'].remove(tid)
del tbi[tid]
else:
tree_groups_to_del.append(tgi)
for tgid in tree_groups_to_del:
nexml_el['^ot:treesElementOrder'].remove(tgid)
del tree_groups[tgid]
return nexson |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 1, 30; 2, function_name:_validate; 3, parameters; 3, 4; 3, 5; 3, 9; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:val; 7, type; 7, 8; 8, identifier:list; 9, typed_default_parameter; 9, 10; 9, 11; 9, 17; 10, identifier:log; 11, type; 11, 12; 12, generic_type; 12, 13; 12, 14; 13, identifier:Optional; 14, type_parameter; 14, 15; 15, type; 15, 16; 16, identifier:Logger; 17, None; 18, type; 18, 19; 19, generic_type; 19, 20; 19, 21; 20, identifier:Tuple; 21, type_parameter; 21, 22; 21, 24; 22, type; 22, 23; 23, identifier:bool; 24, type; 24, 25; 25, generic_type; 25, 26; 25, 27; 26, identifier:List; 27, type_parameter; 27, 28; 28, type; 28, 29; 29, identifier:str; 30, block; 30, 31; 30, 35; 30, 133; 30, 147; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:errors; 34, list:[]; 35, if_statement; 35, 36; 35, 42; 35, 50; 36, not_operator; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:isinstance; 39, argument_list; 39, 40; 39, 41; 40, identifier:val; 41, identifier:list; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:errors; 47, identifier:append; 48, argument_list; 48, 49; 49, string:f"{self._variable_name}: {repr(val)} is not an array"; 50, else_clause; 50, 51; 51, block; 51, 52; 51, 91; 51, 110; 52, for_statement; 52, 53; 52, 54; 52, 62; 53, identifier:i; 54, call; 54, 55; 54, 56; 55, identifier:range; 56, argument_list; 56, 57; 56, 58; 57, integer:0; 58, call; 58, 59; 58, 60; 59, identifier:len; 60, argument_list; 60, 61; 61, identifier:val; 62, block; 62, 63; 62, 69; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:v; 66, subscript; 66, 67; 66, 68; 67, identifier:val; 68, identifier:i; 69, if_statement; 69, 70; 69, 83; 70, not_operator; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:conforms; 73, argument_list; 73, 74; 73, 75; 73, 78; 74, identifier:v; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:_type; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:_context; 82, identifier:NAMESPACE; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:errors; 88, identifier:append; 89, argument_list; 89, 90; 90, string:f"{self._variable_name} element {i}: {v} is not a {self._type.__name__}"; 91, if_statement; 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:val; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:_min; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:errors; 105, identifier:append; 106, argument_list; 106, 107; 107, concatenated_string; 107, 108; 107, 109; 108, string:f"{self._variable_name}: at least {self._min} value{'s' if self._min > 1 else ''} required - "; 109, string:f"element has {len(val) if len(val) else 'none'}"; 110, if_statement; 110, 111; 110, 125; 111, boolean_operator:and; 111, 112; 111, 117; 112, comparison_operator:is; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:_max; 116, None; 117, comparison_operator:>; 117, 118; 117, 122; 118, call; 118, 119; 118, 120; 119, identifier:len; 120, argument_list; 120, 121; 121, identifier:val; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:_max; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:errors; 130, identifier:append; 131, argument_list; 131, 132; 132, string:f"{self._variable_name}: no more than {self._max} values permitted - element has {len(val)}"; 133, if_statement; 133, 134; 133, 135; 134, identifier:log; 135, block; 135, 136; 136, for_statement; 136, 137; 136, 138; 136, 139; 137, identifier:error; 138, identifier:errors; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:log; 144, identifier:log; 145, argument_list; 145, 146; 146, identifier:error; 147, return_statement; 147, 148; 148, expression_list; 148, 149; 148, 154; 149, not_operator; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:bool; 152, argument_list; 152, 153; 153, identifier:errors; 154, identifier:errors | def _validate(self, val: list, log: Optional[Logger] = None) -> Tuple[bool, List[str]]:
errors = []
if not isinstance(val, list):
errors.append(f"{self._variable_name}: {repr(val)} is not an array")
else:
for i in range(0, len(val)):
v = val[i]
if not conforms(v, self._type, self._context.NAMESPACE):
errors.append(f"{self._variable_name} element {i}: {v} is not a {self._type.__name__}")
if len(val) < self._min:
errors.append(
f"{self._variable_name}: at least {self._min} value{'s' if self._min > 1 else ''} required - "
f"element has {len(val) if len(val) else 'none'}")
if self._max is not None and len(val) > self._max:
errors.append(
f"{self._variable_name}: no more than {self._max} values permitted - element has {len(val)}")
if log:
for error in errors:
log.log(error)
return not bool(errors), errors |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 1, 16; 2, function_name:_sync_revoc; 3, parameters; 3, 4; 3, 5; 3, 9; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:rr_id; 7, type; 7, 8; 8, identifier:str; 9, typed_default_parameter; 9, 10; 9, 11; 9, 13; 10, identifier:rr_size; 11, type; 11, 12; 12, identifier:int; 13, None; 14, type; 14, 15; 15, None; 16, block; 16, 17; 16, 26; 16, 35; 16, 72; 16, 176; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:LOGGER; 21, identifier:debug; 22, argument_list; 22, 23; 22, 24; 22, 25; 23, string:'Issuer._sync_revoc >>> rr_id: %s, rr_size: %s'; 24, identifier:rr_id; 25, identifier:rr_size; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 31; 28, tuple_pattern; 28, 29; 28, 30; 29, identifier:cd_id; 30, identifier:tag; 31, call; 31, 32; 31, 33; 32, identifier:rev_reg_id2cred_def_id__tag; 33, argument_list; 33, 34; 34, identifier:rr_id; 35, try_statement; 35, 36; 35, 45; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, await; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:get_cred_def; 43, argument_list; 43, 44; 44, identifier:cd_id; 45, except_clause; 45, 46; 45, 47; 46, identifier:AbsentCredDef; 47, block; 47, 48; 47, 59; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:LOGGER; 52, identifier:debug; 53, argument_list; 53, 54; 53, 55; 53, 58; 54, string:'Issuer._sync_revoc: <!< tails tree %s may be for another ledger; no cred def found on %s'; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:_dir_tails; 58, identifier:cd_id; 59, raise_statement; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:AbsentCredDef; 62, argument_list; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, string:'Tails tree {} may be for another ledger; no cred def found on {}'; 66, identifier:format; 67, argument_list; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:_dir_tails; 71, identifier:cd_id; 72, with_statement; 72, 73; 72, 78; 73, with_clause; 73, 74; 74, with_item; 74, 75; 75, attribute; 75, 76; 75, 77; 76, identifier:REVO_CACHE; 77, identifier:lock; 78, block; 78, 79; 78, 89; 78, 100; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:revo_cache_entry; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:REVO_CACHE; 85, identifier:get; 86, argument_list; 86, 87; 86, 88; 87, identifier:rr_id; 88, None; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:tails; 92, conditional_expression:if; 92, 93; 92, 94; 92, 97; 93, None; 94, comparison_operator:is; 94, 95; 94, 96; 95, identifier:revo_cache_entry; 96, None; 97, attribute; 97, 98; 97, 99; 98, identifier:revo_cache_entry; 99, identifier:tails; 100, if_statement; 100, 101; 100, 104; 101, comparison_operator:is; 101, 102; 101, 103; 102, identifier:tails; 103, None; 104, block; 104, 105; 104, 151; 105, try_statement; 105, 106; 105, 123; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:tails; 110, await; 110, 111; 111, call; 111, 112; 111, 122; 112, attribute; 112, 113; 112, 121; 113, call; 113, 114; 113, 115; 114, identifier:Tails; 115, argument_list; 115, 116; 115, 119; 115, 120; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:_dir_tails; 119, identifier:cd_id; 120, identifier:tag; 121, identifier:open; 122, argument_list; 123, except_clause; 123, 124; 123, 125; 124, identifier:AbsentTails; 125, block; 125, 126; 125, 135; 126, expression_statement; 126, 127; 127, await; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:_create_rev_reg; 132, argument_list; 132, 133; 132, 134; 133, identifier:rr_id; 134, identifier:rr_size; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:tails; 138, await; 138, 139; 139, call; 139, 140; 139, 150; 140, attribute; 140, 141; 140, 149; 141, call; 141, 142; 141, 143; 142, identifier:Tails; 143, argument_list; 143, 144; 143, 147; 143, 148; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:_dir_tails; 147, identifier:cd_id; 148, identifier:tag; 149, identifier:open; 150, argument_list; 151, if_statement; 151, 152; 151, 155; 151, 166; 152, comparison_operator:is; 152, 153; 152, 154; 153, identifier:revo_cache_entry; 154, None; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 161; 158, subscript; 158, 159; 158, 160; 159, identifier:REVO_CACHE; 160, identifier:rr_id; 161, call; 161, 162; 161, 163; 162, identifier:RevoCacheEntry; 163, argument_list; 163, 164; 163, 165; 164, None; 165, identifier:tails; 166, else_clause; 166, 167; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 175; 170, attribute; 170, 171; 170, 174; 171, subscript; 171, 172; 171, 173; 172, identifier:REVO_CACHE; 173, identifier:rr_id; 174, identifier:tails; 175, identifier:tails; 176, expression_statement; 176, 177; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:LOGGER; 180, identifier:debug; 181, argument_list; 181, 182; 182, string:'Issuer._sync_revoc <<<' | async def _sync_revoc(self, rr_id: str, rr_size: int = None) -> None:
LOGGER.debug('Issuer._sync_revoc >>> rr_id: %s, rr_size: %s', rr_id, rr_size)
(cd_id, tag) = rev_reg_id2cred_def_id__tag(rr_id)
try:
await self.get_cred_def(cd_id)
except AbsentCredDef:
LOGGER.debug(
'Issuer._sync_revoc: <!< tails tree %s may be for another ledger; no cred def found on %s',
self._dir_tails,
cd_id)
raise AbsentCredDef('Tails tree {} may be for another ledger; no cred def found on {}'.format(
self._dir_tails,
cd_id))
with REVO_CACHE.lock:
revo_cache_entry = REVO_CACHE.get(rr_id, None)
tails = None if revo_cache_entry is None else revo_cache_entry.tails
if tails is None:
try:
tails = await Tails(self._dir_tails, cd_id, tag).open()
except AbsentTails:
await self._create_rev_reg(rr_id, rr_size)
tails = await Tails(self._dir_tails, cd_id, tag).open()
if revo_cache_entry is None:
REVO_CACHE[rr_id] = RevoCacheEntry(None, tails)
else:
REVO_CACHE[rr_id].tails = tails
LOGGER.debug('Issuer._sync_revoc <<<') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:add_namespace_uri; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:ns_uri; 6, default_parameter; 6, 7; 6, 8; 7, identifier:prefix; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:schema_location; 11, None; 12, block; 12, 13; 12, 15; 13, assert_statement; 13, 14; 14, identifier:ns_uri; 15, if_statement; 15, 16; 15, 21; 15, 92; 16, comparison_operator:in; 16, 17; 16, 18; 17, identifier:ns_uri; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:__ns_uri_map; 21, block; 21, 22; 21, 31; 21, 40; 21, 60; 21, 68; 21, 82; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:ni; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:__lookup_uri; 29, argument_list; 29, 30; 30, identifier:ns_uri; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:new_ni; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:copy; 37, identifier:deepcopy; 38, argument_list; 38, 39; 39, identifier:ni; 40, if_statement; 40, 41; 40, 42; 41, identifier:prefix; 42, block; 42, 43; 42, 51; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:__check_prefix_conflict; 48, argument_list; 48, 49; 48, 50; 49, identifier:ni; 50, identifier:prefix; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:new_ni; 56, identifier:prefixes; 57, identifier:add; 58, argument_list; 58, 59; 59, identifier:prefix; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:__merge_schema_locations; 65, argument_list; 65, 66; 65, 67; 66, identifier:new_ni; 67, identifier:schema_location; 68, for_statement; 68, 69; 68, 70; 68, 73; 69, identifier:p; 70, attribute; 70, 71; 70, 72; 71, identifier:new_ni; 72, identifier:prefixes; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 81; 76, subscript; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:__prefix_map; 80, identifier:p; 81, identifier:new_ni; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 91; 84, subscript; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:__ns_uri_map; 88, attribute; 88, 89; 88, 90; 89, identifier:new_ni; 90, identifier:uri; 91, identifier:new_ni; 92, else_clause; 92, 93; 93, block; 93, 94; 93, 105; 93, 114; 94, if_statement; 94, 95; 94, 96; 95, identifier:prefix; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:__check_prefix_conflict; 102, argument_list; 102, 103; 102, 104; 103, identifier:ns_uri; 104, identifier:prefix; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:ni; 108, call; 108, 109; 108, 110; 109, identifier:_NamespaceInfo; 110, argument_list; 110, 111; 110, 112; 110, 113; 111, identifier:ns_uri; 112, identifier:prefix; 113, identifier:schema_location; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:__add_namespaceinfo; 119, argument_list; 119, 120; 120, identifier:ni | def add_namespace_uri(self, ns_uri, prefix=None, schema_location=None):
assert ns_uri
if ns_uri in self.__ns_uri_map:
ni = self.__lookup_uri(ns_uri)
new_ni = copy.deepcopy(ni)
if prefix:
self.__check_prefix_conflict(ni, prefix)
new_ni.prefixes.add(prefix)
self.__merge_schema_locations(new_ni, schema_location)
for p in new_ni.prefixes:
self.__prefix_map[p] = new_ni
self.__ns_uri_map[new_ni.uri] = new_ni
else:
if prefix:
self.__check_prefix_conflict(ns_uri, prefix)
ni = _NamespaceInfo(ns_uri, prefix, schema_location)
self.__add_namespaceinfo(ni) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_schemaloc_string; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ns_uris; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:delim; 13, string:"\n"; 14, block; 14, 15; 14, 30; 14, 40; 14, 44; 14, 74; 14, 80; 15, if_statement; 15, 16; 15, 18; 16, not_operator; 16, 17; 17, identifier:ns_uris; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:ns_uris; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:six; 25, identifier:iterkeys; 26, argument_list; 26, 27; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:__ns_uri_map; 30, if_statement; 30, 31; 30, 32; 31, identifier:sort; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:ns_uris; 36, call; 36, 37; 36, 38; 37, identifier:sorted; 38, argument_list; 38, 39; 39, identifier:ns_uris; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:schemalocs; 43, list:[]; 44, for_statement; 44, 45; 44, 46; 44, 47; 45, identifier:ns_uri; 46, identifier:ns_uris; 47, block; 47, 48; 47, 57; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:ni; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:__lookup_uri; 55, argument_list; 55, 56; 56, identifier:ns_uri; 57, if_statement; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:ni; 60, identifier:schema_location; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:schemalocs; 66, identifier:append; 67, argument_list; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, string:"{0.uri} {0.schema_location}"; 71, identifier:format; 72, argument_list; 72, 73; 73, identifier:ni; 74, if_statement; 74, 75; 74, 77; 75, not_operator; 75, 76; 76, identifier:schemalocs; 77, block; 77, 78; 78, return_statement; 78, 79; 79, string:""; 80, return_statement; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, string:'xsi:schemaLocation="{0}"'; 84, identifier:format; 85, argument_list; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:delim; 89, identifier:join; 90, argument_list; 90, 91; 91, identifier:schemalocs | def get_schemaloc_string(self, ns_uris=None, sort=False, delim="\n"):
if not ns_uris:
ns_uris = six.iterkeys(self.__ns_uri_map)
if sort:
ns_uris = sorted(ns_uris)
schemalocs = []
for ns_uri in ns_uris:
ni = self.__lookup_uri(ns_uri)
if ni.schema_location:
schemalocs.append("{0.uri} {0.schema_location}".format(ni))
if not schemalocs:
return ""
return 'xsi:schemaLocation="{0}"'.format(delim.join(schemalocs)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:tab_join; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:ToMerge; 5, default_parameter; 5, 6; 5, 7; 6, identifier:keycols; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:nullvals; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:renamer; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:returnrenaming; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:Names; 19, None; 20, block; 20, 21; 20, 23; 20, 49; 20, 76; 20, 103; 20, 168; 20, 172; 20, 235; 20, 244; 20, 250; 21, expression_statement; 21, 22; 22, string:'''
Database-join for tabular arrays.
Wrapper for :func:`tabular.spreadsheet.join` that deals with the coloring
and returns the result as a tabarray.
Method calls::
data = tabular.spreadsheet.join
'''; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, list_pattern; 25, 26; 25, 27; 26, identifier:Result; 27, identifier:Renaming; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:spreadsheet; 31, identifier:join; 32, argument_list; 32, 33; 32, 34; 32, 37; 32, 40; 32, 43; 32, 46; 33, identifier:ToMerge; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:keycols; 36, identifier:keycols; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:nullvals; 39, identifier:nullvals; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:renamer; 42, identifier:renamer; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:returnrenaming; 45, True; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:Names; 48, identifier:Names; 49, if_statement; 49, 50; 49, 55; 49, 64; 50, call; 50, 51; 50, 52; 51, identifier:isinstance; 52, argument_list; 52, 53; 52, 54; 53, identifier:ToMerge; 54, identifier:dict; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:Names; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:ToMerge; 62, identifier:keys; 63, argument_list; 64, else_clause; 64, 65; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:Names; 69, call; 69, 70; 69, 71; 70, identifier:range; 71, argument_list; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:len; 74, argument_list; 74, 75; 75, identifier:ToMerge; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:Colorings; 79, call; 79, 80; 79, 81; 80, identifier:dict; 81, argument_list; 81, 82; 82, list_comprehension; 82, 83; 82, 100; 83, conditional_expression:if; 83, 84; 83, 91; 83, 99; 84, tuple; 84, 85; 84, 86; 85, identifier:k; 86, attribute; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:ToMerge; 89, identifier:k; 90, identifier:coloring; 91, comparison_operator:in; 91, 92; 91, 93; 92, string:'coloring'; 93, call; 93, 94; 93, 95; 94, identifier:dir; 95, argument_list; 95, 96; 96, subscript; 96, 97; 96, 98; 97, identifier:ToMerge; 98, identifier:k; 99, dictionary; 100, for_in_clause; 100, 101; 100, 102; 101, identifier:k; 102, identifier:Names; 103, for_statement; 103, 104; 103, 105; 103, 106; 104, identifier:k; 105, identifier:Names; 106, block; 106, 107; 107, if_statement; 107, 108; 107, 115; 108, comparison_operator:in; 108, 109; 108, 110; 109, identifier:k; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:Renaming; 113, identifier:keys; 114, argument_list; 115, block; 115, 116; 115, 122; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:l; 119, subscript; 119, 120; 119, 121; 120, identifier:ToMerge; 121, identifier:k; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 127; 123, 128; 124, subscript; 124, 125; 124, 126; 125, identifier:Colorings; 126, identifier:k; 127, line_continuation:\; 128, call; 128, 129; 128, 130; 129, identifier:dict; 130, argument_list; 130, 131; 131, list_comprehension; 131, 132; 131, 159; 132, tuple; 132, 133; 132, 134; 133, identifier:g; 134, list_comprehension; 134, 135; 134, 152; 135, conditional_expression:if; 135, 136; 135, 137; 135, 147; 136, identifier:n; 137, not_operator; 137, 138; 138, comparison_operator:in; 138, 139; 138, 140; 139, identifier:n; 140, call; 140, 141; 140, 146; 141, attribute; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:Renaming; 144, identifier:k; 145, identifier:keys; 146, argument_list; 147, subscript; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:Renaming; 150, identifier:k; 151, identifier:n; 152, for_in_clause; 152, 153; 152, 154; 153, identifier:n; 154, subscript; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:l; 157, identifier:coloring; 158, identifier:g; 159, for_in_clause; 159, 160; 159, 161; 160, identifier:g; 161, call; 161, 162; 161, 167; 162, attribute; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:Colorings; 165, identifier:k; 166, identifier:keys; 167, argument_list; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:Coloring; 171, dictionary; 172, for_statement; 172, 173; 172, 174; 172, 179; 173, identifier:k; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:Colorings; 177, identifier:keys; 178, argument_list; 179, block; 179, 180; 180, for_statement; 180, 181; 180, 182; 180, 189; 181, identifier:j; 182, call; 182, 183; 182, 188; 183, attribute; 183, 184; 183, 187; 184, subscript; 184, 185; 184, 186; 185, identifier:Colorings; 186, identifier:k; 187, identifier:keys; 188, argument_list; 189, block; 189, 190; 190, if_statement; 190, 191; 190, 198; 190, 218; 191, comparison_operator:in; 191, 192; 191, 193; 192, identifier:j; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:Coloring; 196, identifier:keys; 197, argument_list; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 204; 201, subscript; 201, 202; 201, 203; 202, identifier:Coloring; 203, identifier:j; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:utils; 207, identifier:uniqify; 208, argument_list; 208, 209; 209, binary_operator:+; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:Coloring; 212, identifier:j; 213, subscript; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:Colorings; 216, identifier:k; 217, identifier:j; 218, else_clause; 218, 219; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:Coloring; 224, identifier:j; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:utils; 228, identifier:uniqify; 229, argument_list; 229, 230; 230, subscript; 230, 231; 230, 234; 231, subscript; 231, 232; 231, 233; 232, identifier:Colorings; 233, identifier:k; 234, identifier:j; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:Result; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:Result; 241, identifier:view; 242, argument_list; 242, 243; 243, identifier:tabarray; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:Result; 248, identifier:coloring; 249, identifier:Coloring; 250, if_statement; 250, 251; 250, 252; 250, 257; 251, identifier:returnrenaming; 252, block; 252, 253; 253, return_statement; 253, 254; 254, list:[Result,Renaming]; 254, 255; 254, 256; 255, identifier:Result; 256, identifier:Renaming; 257, else_clause; 257, 258; 258, block; 258, 259; 259, return_statement; 259, 260; 260, identifier:Result | def tab_join(ToMerge, keycols=None, nullvals=None, renamer=None,
returnrenaming=False, Names=None):
'''
Database-join for tabular arrays.
Wrapper for :func:`tabular.spreadsheet.join` that deals with the coloring
and returns the result as a tabarray.
Method calls::
data = tabular.spreadsheet.join
'''
[Result,Renaming] = spreadsheet.join(ToMerge, keycols=keycols,
nullvals=nullvals, renamer=renamer, returnrenaming=True, Names=Names)
if isinstance(ToMerge,dict):
Names = ToMerge.keys()
else:
Names = range(len(ToMerge))
Colorings = dict([(k,ToMerge[k].coloring) if 'coloring' in dir(ToMerge[k])
else {} for k in Names])
for k in Names:
if k in Renaming.keys():
l = ToMerge[k]
Colorings[k] = \
dict([(g, [n if not n in Renaming[k].keys() else Renaming[k][n]
for n in l.coloring[g]]) for g in Colorings[k].keys()])
Coloring = {}
for k in Colorings.keys():
for j in Colorings[k].keys():
if j in Coloring.keys():
Coloring[j] = utils.uniqify(Coloring[j] + Colorings[k][j])
else:
Coloring[j] = utils.uniqify(Colorings[k][j])
Result = Result.view(tabarray)
Result.coloring = Coloring
if returnrenaming:
return [Result,Renaming]
else:
return Result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:aggregate; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:On; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:AggFuncDict; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:AggFunc; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:AggList; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:returnsort; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:KeepOthers; 22, True; 23, default_parameter; 23, 24; 23, 25; 24, identifier:keyfuncdict; 25, None; 26, block; 26, 27; 26, 95; 26, 104; 26, 112; 27, if_statement; 27, 28; 27, 29; 27, 61; 28, identifier:returnsort; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, list_pattern; 32, 33; 32, 34; 33, identifier:data; 34, identifier:s; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:spreadsheet; 38, identifier:aggregate; 39, argument_list; 39, 40; 39, 43; 39, 46; 39, 49; 39, 52; 39, 55; 39, 58; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:X; 42, identifier:self; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:On; 45, identifier:On; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:AggFuncDict; 48, identifier:AggFuncDict; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:AggFunc; 51, identifier:AggFunc; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:AggList; 54, identifier:AggList; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:returnsort; 57, identifier:returnsort; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:keyfuncdict; 60, identifier:keyfuncdict; 61, else_clause; 61, 62; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:data; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:spreadsheet; 69, identifier:aggregate; 70, argument_list; 70, 71; 70, 74; 70, 77; 70, 80; 70, 83; 70, 86; 70, 89; 70, 92; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:X; 73, identifier:self; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:On; 76, identifier:On; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:AggFuncDict; 79, identifier:AggFuncDict; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:AggFunc; 82, identifier:AggFunc; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:AggList; 85, identifier:AggList; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:returnsort; 88, identifier:returnsort; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:KeepOthers; 91, identifier:KeepOthers; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:keyfuncdict; 94, identifier:keyfuncdict; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:data; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:data; 101, identifier:view; 102, argument_list; 102, 103; 103, identifier:tabarray; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:data; 108, identifier:coloring; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:coloring; 112, if_statement; 112, 113; 112, 114; 112, 119; 113, identifier:returnsort; 114, block; 114, 115; 115, return_statement; 115, 116; 116, list:[data, s]; 116, 117; 116, 118; 117, identifier:data; 118, identifier:s; 119, else_clause; 119, 120; 120, block; 120, 121; 121, return_statement; 121, 122; 122, identifier:data | def aggregate(self, On=None, AggFuncDict=None, AggFunc=None, AggList =
None, returnsort=False,KeepOthers=True, keyfuncdict=None):
if returnsort:
[data, s] = spreadsheet.aggregate(X=self,
On=On,
AggFuncDict=AggFuncDict,
AggFunc=AggFunc,
AggList=AggList,
returnsort=returnsort,
keyfuncdict=keyfuncdict)
else:
data = spreadsheet.aggregate(X=self, On=On, AggFuncDict=AggFuncDict,
AggFunc=AggFunc, AggList = AggList, returnsort=returnsort,
KeepOthers=KeepOthers,
keyfuncdict=keyfuncdict)
data = data.view(tabarray)
data.coloring = self.coloring
if returnsort:
return [data, s]
else:
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:argsort; 3, parameters; 3, 4; 3, 5; 3, 9; 3, 12; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:axis; 7, unary_operator:-; 7, 8; 8, integer:1; 9, default_parameter; 9, 10; 9, 11; 10, identifier:kind; 11, string:'quicksort'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:order; 14, None; 15, block; 15, 16; 15, 33; 15, 44; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:index_array; 19, call; 19, 20; 19, 27; 20, attribute; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:core; 25, identifier:fromnumeric; 26, identifier:_wrapit; 27, argument_list; 27, 28; 27, 29; 27, 30; 27, 31; 27, 32; 28, identifier:self; 29, string:'argsort'; 30, identifier:axis; 31, identifier:kind; 32, identifier:order; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:index_array; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:index_array; 39, identifier:view; 40, argument_list; 40, 41; 41, attribute; 41, 42; 41, 43; 42, identifier:np; 43, identifier:ndarray; 44, return_statement; 44, 45; 45, identifier:index_array | def argsort(self, axis=-1, kind='quicksort', order=None):
index_array = np.core.fromnumeric._wrapit(self, 'argsort', axis,
kind, order)
index_array = index_array.view(np.ndarray)
return index_array |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_finalize_namespaces; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ns_dict; 7, None; 8, block; 8, 9; 8, 33; 8, 55; 8, 61; 8, 84; 8, 95; 9, if_statement; 9, 10; 9, 11; 10, identifier:ns_dict; 11, block; 11, 12; 12, for_statement; 12, 13; 12, 16; 12, 22; 13, pattern_list; 13, 14; 13, 15; 14, identifier:ns; 15, identifier:alias; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:six; 19, identifier:iteritems; 20, argument_list; 20, 21; 21, identifier:ns_dict; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_collected_namespaces; 29, identifier:add_namespace_uri; 30, argument_list; 30, 31; 30, 32; 31, identifier:ns; 32, identifier:alias; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 40; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:_collected_namespaces; 39, identifier:add_namespace_uri; 40, argument_list; 40, 41; 40, 48; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:ns_uri; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:idgen; 46, identifier:get_id_namespace; 47, argument_list; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:prefix; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:idgen; 53, identifier:get_id_namespace_alias; 54, argument_list; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_fix_example_namespace; 60, argument_list; 61, for_statement; 61, 62; 61, 65; 61, 73; 62, pattern_list; 62, 63; 62, 64; 63, identifier:prefix; 64, identifier:uri; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:six; 68, identifier:iteritems; 69, argument_list; 69, 70; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:_input_namespaces; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:_collected_namespaces; 80, identifier:add_namespace_uri; 81, argument_list; 81, 82; 81, 83; 82, identifier:uri; 83, identifier:prefix; 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:_collected_namespaces; 90, identifier:import_from; 91, argument_list; 91, 92; 92, attribute; 92, 93; 92, 94; 93, identifier:namespaces; 94, identifier:XML_NAMESPACES; 95, for_statement; 95, 96; 95, 97; 95, 102; 96, identifier:ns_uri; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:_collected_namespaces; 101, identifier:namespace_uris; 102, block; 102, 103; 102, 114; 102, 118; 102, 129; 102, 153; 102, 165; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:preferred_prefix; 106, call; 106, 107; 106, 112; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:_collected_namespaces; 111, identifier:preferred_prefix_for_namespace; 112, argument_list; 112, 113; 113, identifier:ns_uri; 114, if_statement; 114, 115; 114, 116; 115, identifier:preferred_prefix; 116, block; 116, 117; 117, continue_statement; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:prefixes; 121, call; 121, 122; 121, 127; 122, attribute; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:_collected_namespaces; 126, identifier:get_prefixes; 127, argument_list; 127, 128; 128, identifier:ns_uri; 129, if_statement; 129, 130; 129, 131; 129, 142; 130, identifier:prefixes; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:prefix; 135, call; 135, 136; 135, 137; 136, identifier:next; 137, argument_list; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:iter; 140, argument_list; 140, 141; 141, identifier:prefixes; 142, else_clause; 142, 143; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:prefix; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:namespaces; 150, identifier:lookup_name; 151, argument_list; 151, 152; 152, identifier:ns_uri; 153, if_statement; 153, 154; 153, 157; 154, comparison_operator:is; 154, 155; 154, 156; 155, identifier:prefix; 156, None; 157, block; 157, 158; 158, raise_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:namespaces; 162, identifier:NoPrefixesError; 163, argument_list; 163, 164; 164, identifier:ns_uri; 165, expression_statement; 165, 166; 166, call; 166, 167; 166, 172; 167, attribute; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:_collected_namespaces; 171, identifier:set_preferred_prefix_for_namespace; 172, argument_list; 172, 173; 172, 176; 172, 179; 173, keyword_argument; 173, 174; 173, 175; 174, identifier:ns_uri; 175, identifier:ns_uri; 176, keyword_argument; 176, 177; 176, 178; 177, identifier:prefix; 178, identifier:prefix; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:add_if_not_exist; 181, True | def _finalize_namespaces(self, ns_dict=None):
if ns_dict:
for ns, alias in six.iteritems(ns_dict):
self._collected_namespaces.add_namespace_uri(ns, alias)
self._collected_namespaces.add_namespace_uri(
ns_uri=idgen.get_id_namespace(),
prefix=idgen.get_id_namespace_alias()
)
self._fix_example_namespace()
for prefix, uri in six.iteritems(self._input_namespaces):
self._collected_namespaces.add_namespace_uri(uri, prefix)
self._collected_namespaces.import_from(namespaces.XML_NAMESPACES)
for ns_uri in self._collected_namespaces.namespace_uris:
preferred_prefix = self._collected_namespaces.preferred_prefix_for_namespace(ns_uri)
if preferred_prefix:
continue
prefixes = self._collected_namespaces.get_prefixes(ns_uri)
if prefixes:
prefix = next(iter(prefixes))
else:
prefix = namespaces.lookup_name(ns_uri)
if prefix is None:
raise namespaces.NoPrefixesError(ns_uri)
self._collected_namespaces.set_preferred_prefix_for_namespace(
ns_uri=ns_uri,
prefix=prefix,
add_if_not_exist=True
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:update_empty_fields; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 26; 7, 44; 7, 62; 7, 93; 7, 111; 7, 127; 7, 144; 7, 162; 8, if_statement; 8, 9; 8, 14; 9, comparison_operator:is; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_is_deprecated; 13, None; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_is_deprecated; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:kwargs; 23, identifier:get; 24, argument_list; 24, 25; 25, string:'is_deprecated'; 26, if_statement; 26, 27; 26, 32; 27, comparison_operator:is; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:_is_dubious; 31, None; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_is_dubious; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:kwargs; 41, identifier:get; 42, argument_list; 42, 43; 43, string:'is_dubious'; 44, if_statement; 44, 45; 44, 50; 45, comparison_operator:is; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:_is_synonym; 49, None; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:_is_synonym; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:kwargs; 59, identifier:get; 60, argument_list; 60, 61; 61, string:'is_synonym'; 62, if_statement; 62, 63; 62, 68; 63, comparison_operator:is; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_synonyms; 67, identifier:_EMPTY_TUPLE; 68, block; 68, 69; 68, 80; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:_synonyms; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:kwargs; 77, identifier:get; 78, argument_list; 78, 79; 79, string:'synonyms'; 80, if_statement; 80, 81; 80, 86; 81, comparison_operator:is; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:_synonyms; 85, None; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:_synonyms; 92, identifier:_EMPTY_TUPLE; 93, if_statement; 93, 94; 93, 99; 94, comparison_operator:is; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:rank; 98, None; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:_rank; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:kwargs; 108, identifier:get; 109, argument_list; 109, 110; 110, string:'rank'; 111, if_statement; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:_nomenclature_code; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:_nomenclature_code; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:kwargs; 124, identifier:get; 125, argument_list; 125, 126; 126, string:'nomenclature_code'; 127, if_statement; 127, 128; 127, 132; 128, not_operator; 128, 129; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:_unique_name; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:_unique_name; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:kwargs; 141, identifier:get; 142, argument_list; 142, 143; 143, string:'unique_name'; 144, if_statement; 144, 145; 144, 150; 145, comparison_operator:is; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:_taxonomic_lineage; 149, None; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:_taxonomic_lineage; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:kwargs; 159, identifier:get; 160, argument_list; 160, 161; 161, string:'taxonomic_lineage'; 162, if_statement; 162, 163; 162, 168; 163, comparison_operator:is; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:_parent; 167, None; 168, block; 168, 169; 168, 180; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:_parent; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:kwargs; 177, identifier:get; 178, argument_list; 178, 179; 179, string:'parent'; 180, if_statement; 180, 181; 180, 196; 181, boolean_operator:and; 181, 182; 181, 193; 182, boolean_operator:and; 182, 183; 182, 188; 183, comparison_operator:is; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:_parent; 187, None; 188, comparison_operator:is; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:_taxomachine_wrapper; 192, None; 193, attribute; 193, 194; 193, 195; 194, identifier:self; 195, identifier:_taxonomic_lineage; 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:_fill_parent_attr; 202, argument_list | def update_empty_fields(self, **kwargs):
if self._is_deprecated is None:
self._is_deprecated = kwargs.get('is_deprecated')
if self._is_dubious is None:
self._is_dubious = kwargs.get('is_dubious')
if self._is_synonym is None:
self._is_synonym = kwargs.get('is_synonym')
if self._synonyms is _EMPTY_TUPLE:
self._synonyms = kwargs.get('synonyms')
if self._synonyms is None:
self._synonyms = _EMPTY_TUPLE
if self.rank is None:
self._rank = kwargs.get('rank')
if self._nomenclature_code:
self._nomenclature_code = kwargs.get('nomenclature_code')
if not self._unique_name:
self._unique_name = kwargs.get('unique_name')
if self._taxonomic_lineage is None:
self._taxonomic_lineage = kwargs.get('taxonomic_lineage')
if self._parent is None:
self._parent = kwargs.get('parent')
if self._parent is None and self._taxomachine_wrapper is not None and self._taxonomic_lineage:
self._fill_parent_attr() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 1, 25; 2, function_name:get_creds; 3, parameters; 3, 4; 3, 5; 3, 9; 3, 14; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:proof_req_json; 7, type; 7, 8; 8, identifier:str; 9, typed_default_parameter; 9, 10; 9, 11; 9, 13; 10, identifier:filt; 11, type; 11, 12; 12, identifier:dict; 13, None; 14, typed_default_parameter; 14, 15; 14, 16; 14, 18; 15, identifier:filt_dflt_incl; 16, type; 16, 17; 17, identifier:bool; 18, False; 19, type; 19, 20; 20, tuple; 20, 21; 20, 24; 21, subscript; 21, 22; 21, 23; 22, identifier:Set; 23, identifier:str; 24, identifier:str; 25, block; 25, 26; 25, 35; 25, 44; 25, 48; 25, 63; 25, 72; 25, 78; 25, 118; 25, 305; 25, 321; 25, 332; 25, 340; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:LOGGER; 30, identifier:debug; 31, argument_list; 31, 32; 31, 33; 31, 34; 32, string:'HolderProver.get_creds >>> proof_req_json: %s, filt: %s'; 33, identifier:proof_req_json; 34, identifier:filt; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:is; 36, 37; 36, 38; 37, identifier:filt; 38, None; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:filt; 43, dictionary; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:rv; 47, None; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:creds_json; 51, await; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:anoncreds; 55, identifier:prover_get_credentials_for_proof_req; 56, argument_list; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:wallet; 61, identifier:handle; 62, identifier:proof_req_json; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:creds; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:json; 69, identifier:loads; 70, argument_list; 70, 71; 71, identifier:creds_json; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:cred_ids; 75, call; 75, 76; 75, 77; 76, identifier:set; 77, argument_list; 78, if_statement; 78, 79; 78, 80; 79, identifier:filt; 80, block; 80, 81; 81, for_statement; 81, 82; 81, 83; 81, 84; 82, identifier:cd_id; 83, identifier:filt; 84, block; 84, 85; 85, try_statement; 85, 86; 85, 100; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:json; 91, identifier:loads; 92, argument_list; 92, 93; 93, await; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:get_cred_def; 98, argument_list; 98, 99; 99, identifier:cd_id; 100, except_clause; 100, 101; 100, 102; 101, identifier:AbsentCredDef; 102, block; 102, 103; 102, 111; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:LOGGER; 107, identifier:warning; 108, argument_list; 108, 109; 108, 110; 109, string:'HolderProver.get_creds: ignoring filter criterion, no cred def on %s'; 110, identifier:cd_id; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:filt; 115, identifier:pop; 116, argument_list; 116, 117; 117, identifier:cd_id; 118, for_statement; 118, 119; 118, 120; 118, 133; 119, identifier:inner_creds; 120, call; 120, 121; 120, 132; 121, attribute; 121, 122; 121, 131; 122, dictionary; 122, 123; 122, 127; 123, dictionary_splat; 123, 124; 124, subscript; 124, 125; 124, 126; 125, identifier:creds; 126, string:'attrs'; 127, dictionary_splat; 127, 128; 128, subscript; 128, 129; 128, 130; 129, identifier:creds; 130, string:'predicates'; 131, identifier:values; 132, argument_list; 133, block; 133, 134; 134, for_statement; 134, 135; 134, 136; 134, 137; 135, identifier:cred; 136, identifier:inner_creds; 137, block; 137, 138; 137, 144; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:cred_info; 141, subscript; 141, 142; 141, 143; 142, identifier:cred; 143, string:'cred_info'; 144, if_statement; 144, 145; 144, 146; 144, 294; 145, identifier:filt; 146, block; 146, 147; 146, 153; 146, 171; 146, 225; 146, 285; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:cred_cd_id; 150, subscript; 150, 151; 150, 152; 151, identifier:cred_info; 152, string:'cred_def_id'; 153, if_statement; 153, 154; 153, 157; 154, comparison_operator:not; 154, 155; 154, 156; 155, identifier:cred_cd_id; 156, identifier:filt; 157, block; 157, 158; 157, 170; 158, if_statement; 158, 159; 158, 160; 159, identifier:filt_dflt_incl; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:cred_ids; 165, identifier:add; 166, argument_list; 166, 167; 167, subscript; 167, 168; 167, 169; 168, identifier:cred_info; 169, string:'referent'; 170, continue_statement; 171, if_statement; 171, 172; 171, 180; 172, comparison_operator:in; 172, 173; 172, 174; 173, string:'attr-match'; 174, parenthesized_expression; 174, 175; 175, boolean_operator:or; 175, 176; 175, 179; 176, subscript; 176, 177; 176, 178; 177, identifier:filt; 178, identifier:cred_cd_id; 179, dictionary; 180, block; 180, 181; 181, if_statement; 181, 182; 181, 223; 182, not_operator; 182, 183; 183, comparison_operator:<=; 183, 184; 183, 216; 184, call; 184, 185; 184, 215; 185, attribute; 185, 186; 185, 214; 186, dictionary_comprehension; 186, 187; 186, 203; 187, pair; 187, 188; 187, 189; 188, identifier:k; 189, call; 189, 190; 189, 191; 190, identifier:str; 191, argument_list; 191, 192; 192, subscript; 192, 193; 192, 202; 193, call; 193, 194; 193, 199; 194, attribute; 194, 195; 194, 198; 195, subscript; 195, 196; 195, 197; 196, identifier:filt; 197, identifier:cred_cd_id; 198, identifier:get; 199, argument_list; 199, 200; 199, 201; 200, string:'attr-match'; 201, dictionary; 202, identifier:k; 203, for_in_clause; 203, 204; 203, 205; 204, identifier:k; 205, call; 205, 206; 205, 211; 206, attribute; 206, 207; 206, 210; 207, subscript; 207, 208; 207, 209; 208, identifier:filt; 209, identifier:cred_cd_id; 210, identifier:get; 211, argument_list; 211, 212; 211, 213; 212, string:'attr-match'; 213, dictionary; 214, identifier:items; 215, argument_list; 216, call; 216, 217; 216, 222; 217, attribute; 217, 218; 217, 221; 218, subscript; 218, 219; 218, 220; 219, identifier:cred_info; 220, string:'attrs'; 221, identifier:items; 222, argument_list; 223, block; 223, 224; 224, continue_statement; 225, if_statement; 225, 226; 225, 234; 226, comparison_operator:in; 226, 227; 226, 228; 227, string:'minima'; 228, parenthesized_expression; 228, 229; 229, boolean_operator:or; 229, 230; 229, 233; 230, subscript; 230, 231; 230, 232; 231, identifier:filt; 232, identifier:cred_cd_id; 233, dictionary; 234, block; 234, 235; 234, 247; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:minima; 238, call; 238, 239; 238, 244; 239, attribute; 239, 240; 239, 243; 240, subscript; 240, 241; 240, 242; 241, identifier:filt; 242, identifier:cred_cd_id; 243, identifier:get; 244, argument_list; 244, 245; 244, 246; 245, string:'minima'; 246, dictionary; 247, try_statement; 247, 248; 247, 281; 248, block; 248, 249; 249, if_statement; 249, 250; 249, 279; 250, call; 250, 251; 250, 252; 251, identifier:any; 252, generator_expression; 252, 253; 252, 276; 253, boolean_operator:or; 253, 254; 253, 260; 254, parenthesized_expression; 254, 255; 255, comparison_operator:not; 255, 256; 255, 257; 256, identifier:attr; 257, subscript; 257, 258; 257, 259; 258, identifier:cred_info; 259, string:'attrs'; 260, parenthesized_expression; 260, 261; 261, comparison_operator:<; 261, 262; 261, 270; 262, call; 262, 263; 262, 264; 263, identifier:int; 264, argument_list; 264, 265; 265, subscript; 265, 266; 265, 269; 266, subscript; 266, 267; 266, 268; 267, identifier:cred_info; 268, string:'attrs'; 269, identifier:attr; 270, call; 270, 271; 270, 272; 271, identifier:int; 272, argument_list; 272, 273; 273, subscript; 273, 274; 273, 275; 274, identifier:minima; 275, identifier:attr; 276, for_in_clause; 276, 277; 276, 278; 277, identifier:attr; 278, identifier:minima; 279, block; 279, 280; 280, continue_statement; 281, except_clause; 281, 282; 281, 283; 282, identifier:ValueError; 283, block; 283, 284; 284, continue_statement; 285, expression_statement; 285, 286; 286, call; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:cred_ids; 289, identifier:add; 290, argument_list; 290, 291; 291, subscript; 291, 292; 291, 293; 292, identifier:cred_info; 293, string:'referent'; 294, else_clause; 294, 295; 295, block; 295, 296; 296, expression_statement; 296, 297; 297, call; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:cred_ids; 300, identifier:add; 301, argument_list; 301, 302; 302, subscript; 302, 303; 302, 304; 303, identifier:cred_info; 304, string:'referent'; 305, if_statement; 305, 306; 305, 307; 306, identifier:filt; 307, block; 307, 308; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 311; 310, identifier:creds; 311, call; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:json; 314, identifier:loads; 315, argument_list; 315, 316; 316, call; 316, 317; 316, 318; 317, identifier:prune_creds_json; 318, argument_list; 318, 319; 318, 320; 319, identifier:creds; 320, identifier:cred_ids; 321, expression_statement; 321, 322; 322, assignment; 322, 323; 322, 324; 323, identifier:rv; 324, tuple; 324, 325; 324, 326; 325, identifier:cred_ids; 326, call; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, identifier:json; 329, identifier:dumps; 330, argument_list; 330, 331; 331, identifier:creds; 332, expression_statement; 332, 333; 333, call; 333, 334; 333, 337; 334, attribute; 334, 335; 334, 336; 335, identifier:LOGGER; 336, identifier:debug; 337, argument_list; 337, 338; 337, 339; 338, string:'HolderProver.get_creds <<< %s'; 339, identifier:rv; 340, return_statement; 340, 341; 341, identifier:rv | async def get_creds(self, proof_req_json: str, filt: dict = None, filt_dflt_incl: bool = False) -> (Set[str], str):
LOGGER.debug('HolderProver.get_creds >>> proof_req_json: %s, filt: %s', proof_req_json, filt)
if filt is None:
filt = {}
rv = None
creds_json = await anoncreds.prover_get_credentials_for_proof_req(self.wallet.handle, proof_req_json)
creds = json.loads(creds_json)
cred_ids = set()
if filt:
for cd_id in filt:
try:
json.loads(await self.get_cred_def(cd_id))
except AbsentCredDef:
LOGGER.warning('HolderProver.get_creds: ignoring filter criterion, no cred def on %s', cd_id)
filt.pop(cd_id)
for inner_creds in {**creds['attrs'], **creds['predicates']}.values():
for cred in inner_creds:
cred_info = cred['cred_info']
if filt:
cred_cd_id = cred_info['cred_def_id']
if cred_cd_id not in filt:
if filt_dflt_incl:
cred_ids.add(cred_info['referent'])
continue
if 'attr-match' in (filt[cred_cd_id] or {}):
if not {k: str(filt[cred_cd_id].get('attr-match', {})[k])
for k in filt[cred_cd_id].get('attr-match', {})}.items() <= cred_info['attrs'].items():
continue
if 'minima' in (filt[cred_cd_id] or {}):
minima = filt[cred_cd_id].get('minima', {})
try:
if any((attr not in cred_info['attrs'])
or (int(cred_info['attrs'][attr]) < int(minima[attr]))
for attr in minima):
continue
except ValueError:
continue
cred_ids.add(cred_info['referent'])
else:
cred_ids.add(cred_info['referent'])
if filt:
creds = json.loads(prune_creds_json(creds, cred_ids))
rv = (cred_ids, json.dumps(creds))
LOGGER.debug('HolderProver.get_creds <<< %s', rv)
return rv |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:summary; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:processors; 5, identifier:metrics; 6, identifier:context; 7, block; 7, 8; 7, 42; 7, 76; 7, 114; 7, 118; 7, 199; 7, 206; 7, 243; 7, 248; 7, 255; 7, 264; 7, 296; 7, 305; 8, function_definition; 8, 9; 8, 10; 8, 18; 9, function_name:display_header; 10, parameters; 10, 11; 10, 12; 10, 15; 11, identifier:processors; 12, default_parameter; 12, 13; 12, 14; 13, identifier:before; 14, string:''; 15, default_parameter; 15, 16; 15, 17; 16, identifier:after; 17, string:''; 18, block; 18, 19; 18, 27; 18, 37; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:print; 22, argument_list; 22, 23; 22, 24; 23, identifier:before; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:end; 26, string:' '; 27, for_statement; 27, 28; 27, 29; 27, 30; 28, identifier:processor; 29, identifier:processors; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:processor; 35, identifier:display_header; 36, argument_list; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:print; 40, argument_list; 40, 41; 41, identifier:after; 42, function_definition; 42, 43; 42, 44; 42, 52; 43, function_name:display_separator; 44, parameters; 44, 45; 44, 46; 44, 49; 45, identifier:processors; 46, default_parameter; 46, 47; 46, 48; 47, identifier:before; 48, string:''; 49, default_parameter; 49, 50; 49, 51; 50, identifier:after; 51, string:''; 52, block; 52, 53; 52, 61; 52, 71; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:print; 56, argument_list; 56, 57; 56, 58; 57, identifier:before; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:end; 60, string:' '; 61, for_statement; 61, 62; 61, 63; 61, 64; 62, identifier:processor; 63, identifier:processors; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:processor; 69, identifier:display_separator; 70, argument_list; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:print; 74, argument_list; 74, 75; 75, identifier:after; 76, function_definition; 76, 77; 76, 78; 76, 89; 77, function_name:display_metrics; 78, parameters; 78, 79; 78, 80; 78, 83; 78, 86; 79, identifier:processors; 80, default_parameter; 80, 81; 80, 82; 81, identifier:before; 82, string:''; 83, default_parameter; 83, 84; 83, 85; 84, identifier:after; 85, string:''; 86, default_parameter; 86, 87; 86, 88; 87, identifier:metrics; 88, list:[]; 89, block; 89, 90; 89, 98; 89, 109; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:print; 93, argument_list; 93, 94; 93, 95; 94, identifier:before; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:end; 97, string:' '; 98, for_statement; 98, 99; 98, 100; 98, 101; 99, identifier:processor; 100, identifier:processors; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:processor; 106, identifier:display_metrics; 107, argument_list; 107, 108; 108, identifier:metrics; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:print; 112, argument_list; 112, 113; 113, identifier:after; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:summary; 117, dictionary; 118, for_statement; 118, 119; 118, 120; 118, 121; 119, identifier:m; 120, identifier:metrics; 121, block; 121, 122; 121, 130; 121, 136; 121, 152; 121, 160; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:lang; 125, subscript; 125, 126; 125, 129; 126, subscript; 126, 127; 126, 128; 127, identifier:metrics; 128, identifier:m; 129, string:'language'; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:has_key; 133, comparison_operator:in; 133, 134; 133, 135; 134, identifier:lang; 135, identifier:summary; 136, if_statement; 136, 137; 136, 139; 137, not_operator; 137, 138; 138, identifier:has_key; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:summary; 144, identifier:lang; 145, dictionary; 145, 146; 145, 149; 146, pair; 146, 147; 146, 148; 147, string:'file_count'; 148, integer:0; 149, pair; 149, 150; 149, 151; 150, string:'language'; 151, identifier:lang; 152, expression_statement; 152, 153; 153, augmented_assignment:+=; 153, 154; 153, 159; 154, subscript; 154, 155; 154, 158; 155, subscript; 155, 156; 155, 157; 156, identifier:summary; 157, identifier:lang; 158, string:'file_count'; 159, integer:1; 160, for_statement; 160, 161; 160, 162; 160, 165; 161, identifier:i; 162, subscript; 162, 163; 162, 164; 163, identifier:metrics; 164, identifier:m; 165, block; 165, 166; 165, 175; 165, 187; 166, if_statement; 166, 167; 166, 173; 167, comparison_operator:not; 167, 168; 167, 169; 168, identifier:i; 169, list:['sloc', 'comments', 'mccabe']; 169, 170; 169, 171; 169, 172; 170, string:'sloc'; 171, string:'comments'; 172, string:'mccabe'; 173, block; 173, 174; 174, continue_statement; 175, if_statement; 175, 176; 175, 178; 176, not_operator; 176, 177; 177, identifier:has_key; 178, block; 178, 179; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 186; 181, subscript; 181, 182; 181, 185; 182, subscript; 182, 183; 182, 184; 183, identifier:summary; 184, identifier:lang; 185, identifier:i; 186, integer:0; 187, expression_statement; 187, 188; 188, augmented_assignment:+=; 188, 189; 188, 194; 189, subscript; 189, 190; 189, 193; 190, subscript; 190, 191; 190, 192; 191, identifier:summary; 192, identifier:lang; 193, identifier:i; 194, subscript; 194, 195; 194, 198; 195, subscript; 195, 196; 195, 197; 196, identifier:metrics; 197, identifier:m; 198, identifier:i; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:total; 202, dictionary; 202, 203; 203, pair; 203, 204; 203, 205; 204, string:'language'; 205, string:'Total'; 206, for_statement; 206, 207; 206, 208; 206, 209; 207, identifier:m; 208, identifier:summary; 209, block; 209, 210; 210, for_statement; 210, 211; 210, 212; 210, 215; 211, identifier:i; 212, subscript; 212, 213; 212, 214; 213, identifier:summary; 214, identifier:m; 215, block; 215, 216; 215, 222; 215, 233; 216, if_statement; 216, 217; 216, 220; 217, comparison_operator:==; 217, 218; 217, 219; 218, identifier:i; 219, string:'language'; 220, block; 220, 221; 221, continue_statement; 222, if_statement; 222, 223; 222, 226; 223, comparison_operator:not; 223, 224; 223, 225; 224, identifier:i; 225, identifier:total; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 232; 229, subscript; 229, 230; 229, 231; 230, identifier:total; 231, identifier:i; 232, integer:0; 233, expression_statement; 233, 234; 234, augmented_assignment:+=; 234, 235; 234, 238; 235, subscript; 235, 236; 235, 237; 236, identifier:total; 237, identifier:i; 238, subscript; 238, 239; 238, 242; 239, subscript; 239, 240; 239, 241; 240, identifier:summary; 241, identifier:m; 242, identifier:i; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 246; 245, identifier:print; 246, argument_list; 246, 247; 247, string:'Metrics Summary:'; 248, expression_statement; 248, 249; 249, call; 249, 250; 249, 251; 250, identifier:display_header; 251, argument_list; 251, 252; 251, 253; 251, 254; 252, identifier:processors; 253, string:'Files'; 254, string:''; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 258; 257, identifier:display_separator; 258, argument_list; 258, 259; 258, 260; 258, 263; 259, identifier:processors; 260, binary_operator:*; 260, 261; 260, 262; 261, string:'-'; 262, integer:5; 263, string:''; 264, for_statement; 264, 265; 264, 266; 264, 279; 265, identifier:k; 266, call; 266, 267; 266, 268; 267, identifier:sorted; 268, argument_list; 268, 269; 268, 274; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:summary; 272, identifier:keys; 273, argument_list; 274, keyword_argument; 274, 275; 274, 276; 275, identifier:key; 276, attribute; 276, 277; 276, 278; 277, identifier:str; 278, identifier:lower; 279, block; 279, 280; 280, expression_statement; 280, 281; 281, call; 281, 282; 281, 283; 282, identifier:display_metrics; 283, argument_list; 283, 284; 283, 285; 283, 292; 283, 293; 284, identifier:processors; 285, binary_operator:%; 285, 286; 285, 287; 286, string:'%5d'; 287, subscript; 287, 288; 287, 291; 288, subscript; 288, 289; 288, 290; 289, identifier:summary; 290, identifier:k; 291, string:'file_count'; 292, string:''; 293, subscript; 293, 294; 293, 295; 294, identifier:summary; 295, identifier:k; 296, expression_statement; 296, 297; 297, call; 297, 298; 297, 299; 298, identifier:display_separator; 299, argument_list; 299, 300; 299, 301; 299, 304; 300, identifier:processors; 301, binary_operator:*; 301, 302; 301, 303; 302, string:'-'; 303, integer:5; 304, string:''; 305, expression_statement; 305, 306; 306, call; 306, 307; 306, 308; 307, identifier:display_metrics; 308, argument_list; 308, 309; 308, 310; 308, 315; 308, 316; 309, identifier:processors; 310, binary_operator:%; 310, 311; 310, 312; 311, string:'%5d'; 312, subscript; 312, 313; 312, 314; 313, identifier:total; 314, string:'file_count'; 315, string:''; 316, identifier:total | def summary(processors, metrics, context):
def display_header(processors, before='', after=''):
print(before, end=' ')
for processor in processors:
processor.display_header()
print(after)
def display_separator(processors, before='', after=''):
print(before, end=' ')
for processor in processors:
processor.display_separator()
print(after)
def display_metrics(processors, before='', after='', metrics=[]):
print(before, end=' ')
for processor in processors:
processor.display_metrics(metrics)
print(after)
summary = {}
for m in metrics:
lang = metrics[m]['language']
has_key = lang in summary
if not has_key:
summary[lang] = {'file_count': 0, 'language': lang}
summary[lang]['file_count'] += 1
for i in metrics[m]:
if i not in ['sloc', 'comments', 'mccabe']:
continue
if not has_key:
summary[lang][i] = 0
summary[lang][i] += metrics[m][i]
total = {'language': 'Total'}
for m in summary:
for i in summary[m]:
if i == 'language':
continue
if i not in total:
total[i] = 0
total[i] += summary[m][i]
print('Metrics Summary:')
display_header(processors, 'Files', '')
display_separator(processors, '-'*5, '')
for k in sorted(summary.keys(), key=str.lower):
display_metrics(processors, '%5d' %
summary[k]['file_count'], '', summary[k])
display_separator(processors, '-'*5, '')
display_metrics(processors, '%5d' % total['file_count'],
'', total) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:run_experiment; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 4, identifier:experiment; 5, identifier:roleouts; 6, identifier:episodes; 7, default_parameter; 7, 8; 7, 9; 8, identifier:in_cloud; 9, False; 10, default_parameter; 10, 11; 10, 12; 11, identifier:dynProfile; 12, None; 13, block; 13, 14; 13, 396; 13, 441; 14, function_definition; 14, 15; 14, 16; 14, 17; 15, function_name:run; 16, parameters; 17, block; 17, 18; 17, 42; 17, 51; 17, 59; 17, 68; 17, 77; 17, 86; 17, 93; 17, 391; 18, if_statement; 18, 19; 18, 22; 18, 32; 19, comparison_operator:is; 19, 20; 19, 21; 20, identifier:dynProfile; 21, None; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:maxsteps; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, attribute; 29, 30; 29, 31; 30, identifier:experiment; 31, identifier:profile; 32, else_clause; 32, 33; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:maxsteps; 37, subscript; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:dynProfile; 40, identifier:shape; 41, integer:1; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:na; 45, call; 45, 46; 45, 47; 46, identifier:len; 47, argument_list; 47, 48; 48, attribute; 48, 49; 48, 50; 49, identifier:experiment; 50, identifier:agents; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:ni; 54, binary_operator:*; 54, 55; 54, 58; 55, binary_operator:*; 55, 56; 55, 57; 56, identifier:roleouts; 57, identifier:episodes; 58, identifier:maxsteps; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:all_action; 62, call; 62, 63; 62, 64; 63, identifier:zeros; 64, argument_list; 64, 65; 65, tuple; 65, 66; 65, 67; 66, identifier:na; 67, integer:0; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:all_reward; 71, call; 71, 72; 71, 73; 72, identifier:zeros; 73, argument_list; 73, 74; 74, tuple; 74, 75; 74, 76; 75, identifier:na; 76, integer:0; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:epsilon; 80, call; 80, 81; 80, 82; 81, identifier:zeros; 82, argument_list; 82, 83; 83, tuple; 83, 84; 83, 85; 84, identifier:na; 85, identifier:ni; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:vmarkup; 89, call; 89, 90; 89, 91; 90, identifier:vectorize; 91, argument_list; 91, 92; 92, identifier:get_markup; 93, for_statement; 93, 94; 93, 95; 93, 99; 94, identifier:roleout; 95, call; 95, 96; 95, 97; 96, identifier:range; 97, argument_list; 97, 98; 98, identifier:roleouts; 99, block; 99, 100; 99, 126; 99, 133; 99, 139; 99, 148; 99, 157; 99, 377; 99, 384; 100, if_statement; 100, 101; 100, 104; 101, comparison_operator:is; 101, 102; 101, 103; 102, identifier:dynProfile; 103, None; 104, block; 104, 105; 104, 111; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:i; 108, binary_operator:*; 108, 109; 108, 110; 109, identifier:roleout; 110, identifier:episodes; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:experiment; 115, identifier:profile; 116, subscript; 116, 117; 116, 118; 116, 124; 117, identifier:dynProfile; 118, slice; 118, 119; 118, 120; 118, 121; 119, identifier:i; 120, colon; 121, binary_operator:+; 121, 122; 121, 123; 122, identifier:i; 123, identifier:episodes; 124, slice; 124, 125; 125, colon; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:experiment; 130, identifier:doEpisodes; 131, argument_list; 131, 132; 132, identifier:episodes; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:nei; 136, binary_operator:*; 136, 137; 136, 138; 137, identifier:episodes; 138, identifier:maxsteps; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:epi_action; 142, call; 142, 143; 142, 144; 143, identifier:zeros; 144, argument_list; 144, 145; 145, tuple; 145, 146; 145, 147; 146, integer:0; 147, identifier:nei; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:epi_reward; 151, call; 151, 152; 151, 153; 152, identifier:zeros; 153, argument_list; 153, 154; 154, tuple; 154, 155; 154, 156; 155, integer:0; 156, identifier:nei; 157, for_statement; 157, 158; 157, 163; 157, 164; 157, 176; 158, pattern_list; 158, 159; 158, 160; 159, identifier:i; 160, tuple_pattern; 160, 161; 160, 162; 161, identifier:task; 162, identifier:agent; 163, line_continuation:\; 164, call; 164, 165; 164, 166; 165, identifier:enumerate; 166, argument_list; 166, 167; 167, call; 167, 168; 167, 169; 168, identifier:zip; 169, argument_list; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:experiment; 172, identifier:tasks; 173, attribute; 173, 174; 173, 175; 174, identifier:experiment; 175, identifier:agents; 176, block; 176, 177; 176, 188; 176, 199; 176, 317; 176, 336; 176, 351; 176, 365; 176, 371; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:action; 180, call; 180, 181; 180, 182; 181, identifier:copy; 182, argument_list; 182, 183; 183, subscript; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:agent; 186, identifier:history; 187, string:"action"; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:reward; 191, call; 191, 192; 191, 193; 192, identifier:copy; 193, argument_list; 193, 194; 194, subscript; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:agent; 197, identifier:history; 198, string:"reward"; 199, for_statement; 199, 200; 199, 201; 199, 205; 200, identifier:j; 201, call; 201, 202; 201, 203; 202, identifier:range; 203, argument_list; 203, 204; 204, identifier:nei; 205, block; 205, 206; 206, if_statement; 206, 207; 206, 214; 206, 258; 206, 307; 207, call; 207, 208; 207, 209; 208, identifier:isinstance; 209, argument_list; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:agent; 212, identifier:learner; 213, identifier:DirectSearchLearner; 214, block; 214, 215; 214, 232; 214, 238; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 222; 217, subscript; 217, 218; 217, 219; 217, 220; 218, identifier:action; 219, identifier:j; 220, slice; 220, 221; 221, colon; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:task; 225, identifier:denormalize; 226, argument_list; 226, 227; 227, subscript; 227, 228; 227, 229; 227, 230; 228, identifier:action; 229, identifier:j; 230, slice; 230, 231; 231, colon; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:k; 235, binary_operator:*; 235, 236; 235, 237; 236, identifier:nei; 237, identifier:roleout; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 249; 240, subscript; 240, 241; 240, 242; 240, 243; 241, identifier:epsilon; 242, identifier:i; 243, slice; 243, 244; 243, 245; 243, 246; 244, identifier:k; 245, colon; 246, binary_operator:+; 246, 247; 246, 248; 247, identifier:k; 248, identifier:nei; 249, subscript; 249, 250; 249, 257; 250, attribute; 250, 251; 250, 256; 251, attribute; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:agent; 254, identifier:learner; 255, identifier:explorer; 256, identifier:sigma; 257, integer:0; 258, elif_clause; 258, 259; 258, 266; 259, call; 259, 260; 259, 261; 260, identifier:isinstance; 261, argument_list; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:agent; 264, identifier:learner; 265, identifier:ValueBasedLearner; 266, block; 266, 267; 266, 283; 266, 289; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 274; 269, subscript; 269, 270; 269, 271; 269, 272; 270, identifier:action; 271, identifier:j; 272, slice; 272, 273; 273, colon; 274, call; 274, 275; 274, 276; 275, identifier:vmarkup; 276, argument_list; 276, 277; 276, 282; 277, subscript; 277, 278; 277, 279; 277, 280; 278, identifier:action; 279, identifier:j; 280, slice; 280, 281; 281, colon; 282, identifier:task; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:k; 286, binary_operator:*; 286, 287; 286, 288; 287, identifier:nei; 288, identifier:roleout; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 300; 291, subscript; 291, 292; 291, 293; 291, 294; 292, identifier:epsilon; 293, identifier:i; 294, slice; 294, 295; 294, 296; 294, 297; 295, identifier:k; 296, colon; 297, binary_operator:+; 297, 298; 297, 299; 298, identifier:k; 299, identifier:nei; 300, attribute; 300, 301; 300, 306; 301, attribute; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:agent; 304, identifier:learner; 305, identifier:explorer; 306, identifier:epsilon; 307, else_clause; 307, 308; 308, block; 308, 309; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 312; 311, identifier:action; 312, call; 312, 313; 312, 314; 313, identifier:vmarkup; 314, argument_list; 314, 315; 314, 316; 315, identifier:action; 316, identifier:task; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 320; 319, identifier:epi_action; 320, attribute; 320, 321; 320, 335; 321, subscript; 321, 322; 321, 323; 321, 326; 322, identifier:c_; 323, attribute; 323, 324; 323, 325; 324, identifier:epi_action; 325, identifier:T; 326, call; 326, 327; 326, 334; 327, attribute; 327, 328; 327, 333; 328, subscript; 328, 329; 328, 330; 328, 332; 329, identifier:action; 330, slice; 330, 331; 331, colon; 332, integer:0; 333, identifier:flatten; 334, argument_list; 335, identifier:T; 336, expression_statement; 336, 337; 337, assignment; 337, 338; 337, 339; 338, identifier:epi_reward; 339, attribute; 339, 340; 339, 350; 340, subscript; 340, 341; 340, 342; 340, 345; 341, identifier:c_; 342, attribute; 342, 343; 342, 344; 343, identifier:epi_reward; 344, identifier:T; 345, call; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:reward; 348, identifier:flatten; 349, argument_list; 350, identifier:T; 351, if_statement; 351, 352; 351, 357; 352, call; 352, 353; 352, 354; 353, identifier:hasattr; 354, argument_list; 354, 355; 354, 356; 355, identifier:agent; 356, string:"module"; 357, block; 357, 358; 358, print_statement; 358, 359; 358, 360; 359, string:"PARAMS:"; 360, attribute; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, identifier:agent; 363, identifier:module; 364, identifier:params; 365, expression_statement; 365, 366; 366, call; 366, 367; 366, 370; 367, attribute; 367, 368; 367, 369; 368, identifier:agent; 369, identifier:learn; 370, argument_list; 371, expression_statement; 371, 372; 372, call; 372, 373; 372, 376; 373, attribute; 373, 374; 373, 375; 374, identifier:agent; 375, identifier:reset; 376, argument_list; 377, expression_statement; 377, 378; 378, assignment; 378, 379; 378, 380; 379, identifier:all_action; 380, subscript; 380, 381; 380, 382; 380, 383; 381, identifier:c_; 382, identifier:all_action; 383, identifier:epi_action; 384, expression_statement; 384, 385; 385, assignment; 385, 386; 385, 387; 386, identifier:all_reward; 387, subscript; 387, 388; 387, 389; 387, 390; 388, identifier:c_; 389, identifier:all_reward; 390, identifier:epi_reward; 391, return_statement; 391, 392; 392, expression_list; 392, 393; 392, 394; 392, 395; 393, identifier:all_action; 394, identifier:all_reward; 395, identifier:epsilon; 396, if_statement; 396, 397; 396, 398; 396, 430; 397, identifier:in_cloud; 398, block; 398, 399; 398, 402; 398, 414; 398, 423; 399, import_statement; 399, 400; 400, dotted_name; 400, 401; 401, identifier:cloud; 402, expression_statement; 402, 403; 403, assignment; 403, 404; 403, 405; 404, identifier:job_id; 405, call; 405, 406; 405, 409; 406, attribute; 406, 407; 406, 408; 407, identifier:cloud; 408, identifier:call; 409, argument_list; 409, 410; 409, 411; 410, identifier:run; 411, keyword_argument; 411, 412; 411, 413; 412, identifier:_high_cpu; 413, False; 414, expression_statement; 414, 415; 415, assignment; 415, 416; 415, 417; 416, identifier:result; 417, call; 417, 418; 417, 421; 418, attribute; 418, 419; 418, 420; 419, identifier:cloud; 420, identifier:result; 421, argument_list; 421, 422; 422, identifier:job_id; 423, expression_statement; 423, 424; 424, assignment; 424, 425; 424, 429; 425, pattern_list; 425, 426; 425, 427; 425, 428; 426, identifier:all_action; 427, identifier:all_reward; 428, identifier:epsilon; 429, identifier:result; 430, else_clause; 430, 431; 431, block; 431, 432; 432, expression_statement; 432, 433; 433, assignment; 433, 434; 433, 438; 434, pattern_list; 434, 435; 434, 436; 434, 437; 435, identifier:all_action; 436, identifier:all_reward; 437, identifier:epsilon; 438, call; 438, 439; 438, 440; 439, identifier:run; 440, argument_list; 441, return_statement; 441, 442; 442, expression_list; 442, 443; 442, 444; 442, 445; 443, identifier:all_action; 444, identifier:all_reward; 445, identifier:epsilon | def run_experiment(experiment, roleouts, episodes, in_cloud=False,
dynProfile=None):
def run():
if dynProfile is None:
maxsteps = len(experiment.profile)
else:
maxsteps = dynProfile.shape[1]
na = len(experiment.agents)
ni = roleouts * episodes * maxsteps
all_action = zeros((na, 0))
all_reward = zeros((na, 0))
epsilon = zeros((na, ni))
vmarkup = vectorize(get_markup)
for roleout in range(roleouts):
if dynProfile is not None:
i = roleout * episodes
experiment.profile = dynProfile[i:i + episodes, :]
experiment.doEpisodes(episodes)
nei = episodes * maxsteps
epi_action = zeros((0, nei))
epi_reward = zeros((0, nei))
for i, (task, agent) in \
enumerate(zip(experiment.tasks, experiment.agents)):
action = copy(agent.history["action"])
reward = copy(agent.history["reward"])
for j in range(nei):
if isinstance(agent.learner, DirectSearchLearner):
action[j, :] = task.denormalize(action[j, :])
k = nei * roleout
epsilon[i, k:k + nei] = agent.learner.explorer.sigma[0]
elif isinstance(agent.learner, ValueBasedLearner):
action[j, :] = vmarkup(action[j, :], task)
k = nei * roleout
epsilon[i, k:k + nei] = agent.learner.explorer.epsilon
else:
action = vmarkup(action, task)
epi_action = c_[epi_action.T, action[:, 0].flatten()].T
epi_reward = c_[epi_reward.T, reward.flatten()].T
if hasattr(agent, "module"):
print "PARAMS:", agent.module.params
agent.learn()
agent.reset()
all_action = c_[all_action, epi_action]
all_reward = c_[all_reward, epi_reward]
return all_action, all_reward, epsilon
if in_cloud:
import cloud
job_id = cloud.call(run, _high_cpu=False)
result = cloud.result(job_id)
all_action, all_reward, epsilon = result
else:
all_action, all_reward, epsilon = run()
return all_action, all_reward, epsilon |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:total_cost; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:p; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:p_cost; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:pcost_model; 13, None; 14, block; 14, 15; 14, 26; 14, 37; 14, 48; 14, 58; 14, 175; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:p; 18, conditional_expression:if; 18, 19; 18, 22; 18, 25; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:p; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:p; 24, None; 25, identifier:p; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:p_cost; 29, conditional_expression:if; 29, 30; 29, 33; 29, 36; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:p_cost; 33, comparison_operator:is; 33, 34; 33, 35; 34, identifier:p_cost; 35, None; 36, identifier:p_cost; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:pcost_model; 40, conditional_expression:if; 40, 41; 40, 44; 40, 47; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:pcost_model; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:pcost_model; 46, None; 47, identifier:pcost_model; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:p; 51, conditional_expression:if; 51, 52; 51, 53; 51, 57; 52, float:0.0; 53, not_operator; 53, 54; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:online; 57, identifier:p; 58, if_statement; 58, 59; 58, 62; 58, 158; 58, 171; 59, comparison_operator:==; 59, 60; 59, 61; 60, identifier:pcost_model; 61, identifier:PW_LINEAR; 62, block; 62, 63; 62, 72; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:n_segments; 66, binary_operator:-; 66, 67; 66, 71; 67, call; 67, 68; 67, 69; 68, identifier:len; 69, argument_list; 69, 70; 70, identifier:p_cost; 71, integer:1; 72, for_statement; 72, 73; 72, 74; 72, 78; 72, 132; 73, identifier:i; 74, call; 74, 75; 74, 76; 75, identifier:range; 76, argument_list; 76, 77; 77, identifier:n_segments; 78, block; 78, 79; 78, 87; 78, 97; 78, 109; 78, 117; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, pattern_list; 81, 82; 81, 83; 82, identifier:x1; 83, identifier:y1; 84, subscript; 84, 85; 84, 86; 85, identifier:p_cost; 86, identifier:i; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, pattern_list; 89, 90; 89, 91; 90, identifier:x2; 91, identifier:y2; 92, subscript; 92, 93; 92, 94; 93, identifier:p_cost; 94, binary_operator:+; 94, 95; 94, 96; 95, identifier:i; 96, integer:1; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:m; 100, binary_operator:/; 100, 101; 100, 105; 101, parenthesized_expression; 101, 102; 102, binary_operator:-; 102, 103; 102, 104; 103, identifier:y2; 104, identifier:y1; 105, parenthesized_expression; 105, 106; 106, binary_operator:-; 106, 107; 106, 108; 107, identifier:x2; 108, identifier:x1; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:c; 112, binary_operator:-; 112, 113; 112, 114; 113, identifier:y1; 114, binary_operator:*; 114, 115; 114, 116; 115, identifier:m; 116, identifier:x1; 117, if_statement; 117, 118; 117, 122; 118, comparison_operator:<=; 118, 119; 118, 120; 118, 121; 119, identifier:x1; 120, identifier:p; 121, identifier:x2; 122, block; 122, 123; 122, 131; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:result; 126, binary_operator:+; 126, 127; 126, 130; 127, binary_operator:*; 127, 128; 127, 129; 128, identifier:m; 129, identifier:p; 130, identifier:c; 131, break_statement; 132, else_clause; 132, 133; 133, block; 133, 134; 133, 150; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:logger; 138, identifier:error; 139, argument_list; 139, 140; 140, binary_operator:%; 140, 141; 140, 142; 141, string:"Value [%f] outside pwl cost curve [%s]."; 142, tuple; 142, 143; 142, 144; 143, identifier:p; 144, subscript; 144, 145; 144, 149; 145, subscript; 145, 146; 145, 147; 146, identifier:p_cost; 147, unary_operator:-; 147, 148; 148, integer:1; 149, integer:0; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:result; 153, binary_operator:+; 153, 154; 153, 157; 154, binary_operator:*; 154, 155; 154, 156; 155, identifier:m; 156, identifier:p; 157, identifier:c; 158, elif_clause; 158, 159; 158, 162; 159, comparison_operator:==; 159, 160; 159, 161; 160, identifier:pcost_model; 161, identifier:POLYNOMIAL; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:result; 166, call; 166, 167; 166, 168; 167, identifier:polyval; 168, argument_list; 168, 169; 168, 170; 169, identifier:p_cost; 170, identifier:p; 171, else_clause; 171, 172; 172, block; 172, 173; 173, raise_statement; 173, 174; 174, identifier:ValueError; 175, if_statement; 175, 176; 175, 179; 175, 183; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:is_load; 179, block; 179, 180; 180, return_statement; 180, 181; 181, unary_operator:-; 181, 182; 182, identifier:result; 183, else_clause; 183, 184; 184, block; 184, 185; 185, return_statement; 185, 186; 186, identifier:result | def total_cost(self, p=None, p_cost=None, pcost_model=None):
p = self.p if p is None else p
p_cost = self.p_cost if p_cost is None else p_cost
pcost_model = self.pcost_model if pcost_model is None else pcost_model
p = 0.0 if not self.online else p
if pcost_model == PW_LINEAR:
n_segments = len(p_cost) - 1
for i in range(n_segments):
x1, y1 = p_cost[i]
x2, y2 = p_cost[i + 1]
m = (y2 - y1) / (x2 - x1)
c = y1 - m * x1
if x1 <= p <= x2:
result = m*p + c
break
else:
logger.error("Value [%f] outside pwl cost curve [%s]." %
(p, p_cost[-1][0]))
result = m*p + c
elif pcost_model == POLYNOMIAL:
result = polyval(p_cost, p)
else:
raise ValueError
if self.is_load:
return -result
else:
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:offers_to_pwl; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:offers; 6, block; 6, 7; 6, 12; 6, 26; 6, 44; 6, 57; 6, 70; 6, 82; 6, 159; 6, 193; 6, 223; 7, assert_statement; 7, 8; 8, not_operator; 8, 9; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:is_load; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:g_offers; 15, list_comprehension; 15, 16; 15, 17; 15, 20; 16, identifier:offer; 17, for_in_clause; 17, 18; 17, 19; 18, identifier:offer; 19, identifier:offers; 20, if_clause; 20, 21; 21, comparison_operator:==; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:offer; 24, identifier:generator; 25, identifier:self; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:gt_zero; 29, list_comprehension; 29, 30; 29, 31; 29, 34; 30, identifier:offr; 31, for_in_clause; 31, 32; 31, 33; 32, identifier:offr; 33, identifier:g_offers; 34, if_clause; 34, 35; 35, comparison_operator:>; 35, 36; 35, 43; 36, call; 36, 37; 36, 38; 37, identifier:round; 38, argument_list; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:offr; 41, identifier:quantity; 42, integer:4; 43, float:0.0; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:valid; 47, list_comprehension; 47, 48; 47, 49; 47, 52; 48, identifier:offer; 49, for_in_clause; 49, 50; 49, 51; 50, identifier:offer; 51, identifier:gt_zero; 52, if_clause; 52, 53; 53, not_operator; 53, 54; 54, attribute; 54, 55; 54, 56; 55, identifier:offer; 56, identifier:withheld; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:p_offers; 60, list_comprehension; 60, 61; 60, 62; 60, 65; 61, identifier:v; 62, for_in_clause; 62, 63; 62, 64; 63, identifier:v; 64, identifier:valid; 65, if_clause; 65, 66; 66, not_operator; 66, 67; 67, attribute; 67, 68; 67, 69; 68, identifier:v; 69, identifier:reactive; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:q_offers; 73, list_comprehension; 73, 74; 73, 75; 73, 78; 74, identifier:v; 75, for_in_clause; 75, 76; 75, 77; 76, identifier:v; 77, identifier:valid; 78, if_clause; 78, 79; 79, attribute; 79, 80; 79, 81; 80, identifier:v; 81, identifier:reactive; 82, if_statement; 82, 83; 82, 84; 82, 108; 83, identifier:p_offers; 84, block; 84, 85; 84, 96; 84, 102; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:p_cost; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:_offbids_to_points; 94, argument_list; 94, 95; 95, identifier:p_offers; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:pcost_model; 101, identifier:PW_LINEAR; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:online; 107, True; 108, else_clause; 108, 109; 109, block; 109, 110; 109, 124; 109, 130; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:p_cost; 115, list:[(0.0, 0.0), (self.p_max, 0.0)]; 115, 116; 115, 119; 116, tuple; 116, 117; 116, 118; 117, float:0.0; 118, float:0.0; 119, tuple; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:p_max; 123, float:0.0; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:pcost_model; 129, identifier:PW_LINEAR; 130, if_statement; 130, 131; 130, 132; 130, 151; 131, identifier:q_offers; 132, block; 132, 133; 132, 139; 132, 145; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:p_min; 138, float:0.0; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:p_max; 144, float:0.0; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:online; 150, True; 151, else_clause; 151, 152; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:online; 158, False; 159, if_statement; 159, 160; 159, 161; 159, 179; 160, identifier:q_offers; 161, block; 161, 162; 161, 173; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:q_cost; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:_offbids_to_points; 171, argument_list; 171, 172; 172, identifier:q_offers; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:qcost_model; 178, identifier:PW_LINEAR; 179, else_clause; 179, 180; 180, block; 180, 181; 180, 187; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:q_cost; 186, None; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:qcost_model; 192, identifier:PW_LINEAR; 193, if_statement; 193, 194; 193, 205; 194, boolean_operator:and; 194, 195; 194, 200; 195, not_operator; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:len; 198, argument_list; 198, 199; 199, identifier:p_offers; 200, not_operator; 200, 201; 201, call; 201, 202; 201, 203; 202, identifier:len; 203, argument_list; 203, 204; 204, identifier:q_offers; 205, block; 205, 206; 205, 217; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:logger; 210, identifier:info; 211, argument_list; 211, 212; 212, binary_operator:%; 212, 213; 212, 214; 213, string:"No valid offers for generator [%s], shutting down."; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:name; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:self; 221, identifier:online; 222, False; 223, expression_statement; 223, 224; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:_adjust_limits; 228, argument_list | def offers_to_pwl(self, offers):
assert not self.is_load
g_offers = [offer for offer in offers if offer.generator == self]
gt_zero = [offr for offr in g_offers if round(offr.quantity, 4) > 0.0]
valid = [offer for offer in gt_zero if not offer.withheld]
p_offers = [v for v in valid if not v.reactive]
q_offers = [v for v in valid if v.reactive]
if p_offers:
self.p_cost = self._offbids_to_points(p_offers)
self.pcost_model = PW_LINEAR
self.online = True
else:
self.p_cost = [(0.0, 0.0), (self.p_max, 0.0)]
self.pcost_model = PW_LINEAR
if q_offers:
self.p_min = 0.0
self.p_max = 0.0
self.online = True
else:
self.online = False
if q_offers:
self.q_cost = self._offbids_to_points(q_offers)
self.qcost_model = PW_LINEAR
else:
self.q_cost = None
self.qcost_model = PW_LINEAR
if not len(p_offers) and not len(q_offers):
logger.info("No valid offers for generator [%s], shutting down." %
self.name)
self.online = False
self._adjust_limits() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:bids_to_pwl; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:bids; 6, block; 6, 7; 6, 11; 6, 25; 6, 43; 6, 56; 6, 69; 6, 81; 6, 149; 6, 203; 7, assert_statement; 7, 8; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:is_load; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:vl_bids; 14, list_comprehension; 14, 15; 14, 16; 14, 19; 15, identifier:bid; 16, for_in_clause; 16, 17; 16, 18; 17, identifier:bid; 18, identifier:bids; 19, if_clause; 19, 20; 20, comparison_operator:==; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:bid; 23, identifier:vLoad; 24, identifier:self; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:gt_zero; 28, list_comprehension; 28, 29; 28, 30; 28, 33; 29, identifier:bid; 30, for_in_clause; 30, 31; 30, 32; 31, identifier:bid; 32, identifier:vl_bids; 33, if_clause; 33, 34; 34, comparison_operator:>; 34, 35; 34, 42; 35, call; 35, 36; 35, 37; 36, identifier:round; 37, argument_list; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:bid; 40, identifier:quantity; 41, integer:4; 42, float:0.0; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:valid_bids; 46, list_comprehension; 46, 47; 46, 48; 46, 51; 47, identifier:bid; 48, for_in_clause; 48, 49; 48, 50; 49, identifier:bid; 50, identifier:gt_zero; 51, if_clause; 51, 52; 52, not_operator; 52, 53; 53, attribute; 53, 54; 53, 55; 54, identifier:bid; 55, identifier:withheld; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:p_bids; 59, list_comprehension; 59, 60; 59, 61; 59, 64; 60, identifier:v; 61, for_in_clause; 61, 62; 61, 63; 62, identifier:v; 63, identifier:valid_bids; 64, if_clause; 64, 65; 65, not_operator; 65, 66; 66, attribute; 66, 67; 66, 68; 67, identifier:v; 68, identifier:reactive; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:q_bids; 72, list_comprehension; 72, 73; 72, 74; 72, 77; 73, identifier:v; 74, for_in_clause; 74, 75; 74, 76; 75, identifier:v; 76, identifier:valid_bids; 77, if_clause; 77, 78; 78, attribute; 78, 79; 78, 80; 79, identifier:v; 80, identifier:reactive; 81, if_statement; 81, 82; 81, 83; 81, 108; 82, identifier:p_bids; 83, block; 83, 84; 83, 96; 83, 102; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:p_cost; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:_offbids_to_points; 93, argument_list; 93, 94; 93, 95; 94, identifier:p_bids; 95, True; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:pcost_model; 101, identifier:PW_LINEAR; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:online; 107, True; 108, else_clause; 108, 109; 109, block; 109, 110; 109, 124; 109, 130; 109, 143; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:p_cost; 115, list:[(0.0, 0.0), (self.p_max, 0.0)]; 115, 116; 115, 119; 116, tuple; 116, 117; 116, 118; 117, float:0.0; 118, float:0.0; 119, tuple; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:p_max; 123, float:0.0; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:pcost_model; 129, identifier:PW_LINEAR; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:logger; 134, identifier:info; 135, argument_list; 135, 136; 136, binary_operator:%; 136, 137; 136, 140; 137, concatenated_string; 137, 138; 137, 139; 138, string:"No valid active power bids for dispatchable load "; 139, string:"[%s], shutting down."; 140, attribute; 140, 141; 140, 142; 141, identifier:self; 142, identifier:name; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:online; 148, False; 149, if_statement; 149, 150; 149, 151; 149, 176; 150, identifier:q_bids; 151, block; 151, 152; 151, 164; 151, 170; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:q_cost; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:_offbids_to_points; 161, argument_list; 161, 162; 161, 163; 162, identifier:q_bids; 163, True; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:qcost_model; 169, identifier:PW_LINEAR; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:online; 175, True; 176, else_clause; 176, 177; 177, block; 177, 178; 177, 197; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:q_cost; 183, list:[(self.q_min, 0.0), (0.0, 0.0), (self.q_max, 0.0)]; 183, 184; 183, 189; 183, 192; 184, tuple; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:q_min; 188, float:0.0; 189, tuple; 189, 190; 189, 191; 190, float:0.0; 191, float:0.0; 192, tuple; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:self; 195, identifier:q_max; 196, float:0.0; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:self; 201, identifier:qcost_model; 202, identifier:PW_LINEAR; 203, expression_statement; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:self; 207, identifier:_adjust_limits; 208, argument_list | def bids_to_pwl(self, bids):
assert self.is_load
vl_bids = [bid for bid in bids if bid.vLoad == self]
gt_zero = [bid for bid in vl_bids if round(bid.quantity, 4) > 0.0]
valid_bids = [bid for bid in gt_zero if not bid.withheld]
p_bids = [v for v in valid_bids if not v.reactive]
q_bids = [v for v in valid_bids if v.reactive]
if p_bids:
self.p_cost = self._offbids_to_points(p_bids, True)
self.pcost_model = PW_LINEAR
self.online = True
else:
self.p_cost = [(0.0, 0.0), (self.p_max, 0.0)]
self.pcost_model = PW_LINEAR
logger.info("No valid active power bids for dispatchable load "
"[%s], shutting down." % self.name)
self.online = False
if q_bids:
self.q_cost = self._offbids_to_points(q_bids, True)
self.qcost_model = PW_LINEAR
self.online = True
else:
self.q_cost = [(self.q_min, 0.0), (0.0, 0.0), (self.q_max, 0.0)]
self.qcost_model = PW_LINEAR
self._adjust_limits() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:DoxyfileParse; 3, parameters; 3, 4; 4, identifier:file_contents; 5, block; 5, 6; 5, 10; 5, 13; 5, 27; 5, 33; 5, 47; 5, 53; 5, 59; 5, 67; 5, 71; 5, 75; 5, 79; 5, 83; 5, 87; 5, 127; 5, 274; 5, 325; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:data; 9, dictionary; 10, import_statement; 10, 11; 11, dotted_name; 11, 12; 12, identifier:shlex; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:lex; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:shlex; 19, identifier:shlex; 20, argument_list; 20, 21; 20, 24; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:instream; 23, identifier:file_contents; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:posix; 26, True; 27, expression_statement; 27, 28; 28, augmented_assignment:+=; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:lex; 31, identifier:wordchars; 32, string:"*+./-:"; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:lex; 37, identifier:whitespace; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:lex; 42, identifier:whitespace; 43, identifier:replace; 44, argument_list; 44, 45; 44, 46; 45, string:"\n"; 46, string:""; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:lex; 51, identifier:escape; 52, string:""; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:lineno; 56, attribute; 56, 57; 56, 58; 57, identifier:lex; 58, identifier:lineno; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:token; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:lex; 65, identifier:get_token; 66, argument_list; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:key; 70, identifier:token; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:last_token; 74, string:""; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:key_token; 78, False; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:next_key; 82, False; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:new_data; 86, True; 87, function_definition; 87, 88; 87, 89; 87, 94; 88, function_name:append_data; 89, parameters; 89, 90; 89, 91; 89, 92; 89, 93; 90, identifier:data; 91, identifier:key; 92, identifier:new_data; 93, identifier:token; 94, block; 94, 95; 95, if_statement; 95, 96; 95, 106; 95, 116; 96, boolean_operator:or; 96, 97; 96, 98; 97, identifier:new_data; 98, comparison_operator:==; 98, 99; 98, 105; 99, call; 99, 100; 99, 101; 100, identifier:len; 101, argument_list; 101, 102; 102, subscript; 102, 103; 102, 104; 103, identifier:data; 104, identifier:key; 105, integer:0; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 114; 109, attribute; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:data; 112, identifier:key; 113, identifier:append; 114, argument_list; 114, 115; 115, identifier:token; 116, else_clause; 116, 117; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, augmented_assignment:+=; 119, 120; 119, 126; 120, subscript; 120, 121; 120, 124; 121, subscript; 121, 122; 121, 123; 122, identifier:data; 123, identifier:key; 124, unary_operator:-; 124, 125; 125, integer:1; 126, identifier:token; 127, while_statement; 127, 128; 127, 129; 128, identifier:token; 129, block; 129, 130; 129, 241; 129, 245; 129, 253; 130, if_statement; 130, 131; 130, 135; 130, 146; 130, 153; 130, 164; 131, comparison_operator:in; 131, 132; 131, 133; 132, identifier:token; 133, list:['\n']; 133, 134; 134, string:'\n'; 135, block; 135, 136; 136, if_statement; 136, 137; 136, 141; 137, comparison_operator:not; 137, 138; 137, 139; 138, identifier:last_token; 139, list:['\\']; 139, 140; 140, string:'\\'; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:key_token; 145, True; 146, elif_clause; 146, 147; 146, 151; 147, comparison_operator:in; 147, 148; 147, 149; 148, identifier:token; 149, list:['\\']; 149, 150; 150, string:'\\'; 151, block; 151, 152; 152, pass_statement; 153, elif_clause; 153, 154; 153, 155; 154, identifier:key_token; 155, block; 155, 156; 155, 160; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:key; 159, identifier:token; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:key_token; 163, False; 164, else_clause; 164, 165; 165, block; 165, 166; 166, if_statement; 166, 167; 166, 170; 166, 188; 166, 227; 167, comparison_operator:==; 167, 168; 167, 169; 168, identifier:token; 169, string:"+="; 170, block; 170, 171; 171, if_statement; 171, 172; 171, 179; 172, not_operator; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:data; 176, identifier:has_key; 177, argument_list; 177, 178; 178, identifier:key; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 185; 182, subscript; 182, 183; 182, 184; 183, identifier:data; 184, identifier:key; 185, call; 185, 186; 185, 187; 186, identifier:list; 187, argument_list; 188, elif_clause; 188, 189; 188, 192; 189, comparison_operator:==; 189, 190; 189, 191; 190, identifier:token; 191, string:"="; 192, block; 192, 193; 193, if_statement; 193, 194; 193, 204; 193, 217; 194, boolean_operator:and; 194, 195; 194, 198; 195, comparison_operator:==; 195, 196; 195, 197; 196, identifier:key; 197, string:"TAGFILES"; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:data; 201, identifier:has_key; 202, argument_list; 202, 203; 203, identifier:key; 204, block; 204, 205; 204, 213; 205, expression_statement; 205, 206; 206, call; 206, 207; 206, 208; 207, identifier:append_data; 208, argument_list; 208, 209; 208, 210; 208, 211; 208, 212; 209, identifier:data; 210, identifier:key; 211, False; 212, string:"="; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:new_data; 216, False; 217, else_clause; 217, 218; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 224; 221, subscript; 221, 222; 221, 223; 222, identifier:data; 223, identifier:key; 224, call; 224, 225; 224, 226; 225, identifier:list; 226, argument_list; 227, else_clause; 227, 228; 228, block; 228, 229; 228, 237; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 232; 231, identifier:append_data; 232, argument_list; 232, 233; 232, 234; 232, 235; 232, 236; 233, identifier:data; 234, identifier:key; 235, identifier:new_data; 236, identifier:token; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:new_data; 240, True; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:last_token; 244, identifier:token; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:token; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:lex; 251, identifier:get_token; 252, argument_list; 253, if_statement; 253, 254; 253, 261; 254, boolean_operator:and; 254, 255; 254, 258; 255, comparison_operator:==; 255, 256; 255, 257; 256, identifier:last_token; 257, string:'\\'; 258, comparison_operator:!=; 258, 259; 258, 260; 259, identifier:token; 260, string:'\n'; 261, block; 261, 262; 261, 266; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:new_data; 265, False; 266, expression_statement; 266, 267; 267, call; 267, 268; 267, 269; 268, identifier:append_data; 269, argument_list; 269, 270; 269, 271; 269, 272; 269, 273; 270, identifier:data; 271, identifier:key; 272, identifier:new_data; 273, string:'\\'; 274, for_statement; 274, 275; 274, 278; 274, 283; 275, tuple_pattern; 275, 276; 275, 277; 276, identifier:k; 277, identifier:v; 278, call; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:data; 281, identifier:items; 282, argument_list; 283, block; 283, 284; 283, 299; 283, 309; 284, if_statement; 284, 285; 284, 291; 285, comparison_operator:==; 285, 286; 285, 290; 286, call; 286, 287; 286, 288; 287, identifier:len; 288, argument_list; 288, 289; 289, identifier:v; 290, integer:0; 291, block; 291, 292; 292, expression_statement; 292, 293; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:data; 296, identifier:pop; 297, argument_list; 297, 298; 298, identifier:k; 299, if_statement; 299, 300; 299, 307; 300, comparison_operator:in; 300, 301; 300, 302; 301, identifier:k; 302, list:["INPUT", "FILE_PATTERNS", "EXCLUDE_PATTERNS", "TAGFILES"]; 302, 303; 302, 304; 302, 305; 302, 306; 303, string:"INPUT"; 304, string:"FILE_PATTERNS"; 305, string:"EXCLUDE_PATTERNS"; 306, string:"TAGFILES"; 307, block; 307, 308; 308, continue_statement; 309, if_statement; 309, 310; 309, 316; 310, comparison_operator:==; 310, 311; 310, 315; 311, call; 311, 312; 311, 313; 312, identifier:len; 313, argument_list; 313, 314; 314, identifier:v; 315, integer:1; 316, block; 316, 317; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 322; 319, subscript; 319, 320; 319, 321; 320, identifier:data; 321, identifier:k; 322, subscript; 322, 323; 322, 324; 323, identifier:v; 324, integer:0; 325, return_statement; 325, 326; 326, identifier:data | def DoxyfileParse(file_contents):
data = {}
import shlex
lex = shlex.shlex(instream = file_contents, posix = True)
lex.wordchars += "*+./-:"
lex.whitespace = lex.whitespace.replace("\n", "")
lex.escape = ""
lineno = lex.lineno
token = lex.get_token()
key = token
last_token = ""
key_token = False
next_key = False
new_data = True
def append_data(data, key, new_data, token):
if new_data or len(data[key]) == 0:
data[key].append(token)
else:
data[key][-1] += token
while token:
if token in ['\n']:
if last_token not in ['\\']:
key_token = True
elif token in ['\\']:
pass
elif key_token:
key = token
key_token = False
else:
if token == "+=":
if not data.has_key(key):
data[key] = list()
elif token == "=":
if key == "TAGFILES" and data.has_key(key):
append_data( data, key, False, "=" )
new_data=False
else:
data[key] = list()
else:
append_data( data, key, new_data, token )
new_data = True
last_token = token
token = lex.get_token()
if last_token == '\\' and token != '\n':
new_data = False
append_data( data, key, new_data, '\\' )
for (k, v) in data.items():
if len(v) == 0:
data.pop(k)
if k in ["INPUT", "FILE_PATTERNS", "EXCLUDE_PATTERNS", "TAGFILES"]:
continue
if len(v) == 1:
data[k] = v[0]
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:DoxySourceScan; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:node; 5, identifier:env; 6, identifier:path; 7, block; 7, 8; 7, 37; 7, 42; 7, 46; 7, 57; 7, 78; 7, 88; 7, 98; 7, 112; 7, 282; 7, 333; 7, 393; 7, 398; 7, 403; 7, 408; 7, 424; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:default_file_patterns; 11, list:[
'*.c', '*.cc', '*.cxx', '*.cpp', '*.c++', '*.java', '*.ii', '*.ixx',
'*.ipp', '*.i++', '*.inl', '*.h', '*.hh ', '*.hxx', '*.hpp', '*.h++',
'*.idl', '*.odl', '*.cs', '*.php', '*.php3', '*.inc', '*.m', '*.mm',
'*.py',
]; 11, 12; 11, 13; 11, 14; 11, 15; 11, 16; 11, 17; 11, 18; 11, 19; 11, 20; 11, 21; 11, 22; 11, 23; 11, 24; 11, 25; 11, 26; 11, 27; 11, 28; 11, 29; 11, 30; 11, 31; 11, 32; 11, 33; 11, 34; 11, 35; 11, 36; 12, string:'*.c'; 13, string:'*.cc'; 14, string:'*.cxx'; 15, string:'*.cpp'; 16, string:'*.c++'; 17, string:'*.java'; 18, string:'*.ii'; 19, string:'*.ixx'; 20, string:'*.ipp'; 21, string:'*.i++'; 22, string:'*.inl'; 23, string:'*.h'; 24, string:'*.hh '; 25, string:'*.hxx'; 26, string:'*.hpp'; 27, string:'*.h++'; 28, string:'*.idl'; 29, string:'*.odl'; 30, string:'*.cs'; 31, string:'*.php'; 32, string:'*.php3'; 33, string:'*.inc'; 34, string:'*.m'; 35, string:'*.mm'; 36, string:'*.py'; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:default_exclude_patterns; 40, list:[
'*~',
]; 40, 41; 41, string:'*~'; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:sources; 45, list:[]; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:data; 49, call; 49, 50; 49, 51; 50, identifier:DoxyfileParse; 51, argument_list; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:node; 55, identifier:get_contents; 56, argument_list; 57, if_statement; 57, 58; 57, 67; 57, 72; 58, comparison_operator:==; 58, 59; 58, 66; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:data; 62, identifier:get; 63, argument_list; 63, 64; 63, 65; 64, string:"RECURSIVE"; 65, string:"NO"; 66, string:"YES"; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:recursive; 71, True; 72, else_clause; 72, 73; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:recursive; 77, False; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:file_patterns; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:data; 84, identifier:get; 85, argument_list; 85, 86; 85, 87; 86, string:"FILE_PATTERNS"; 87, identifier:default_file_patterns; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:exclude_patterns; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:data; 94, identifier:get; 95, argument_list; 95, 96; 95, 97; 96, string:"EXCLUDE_PATTERNS"; 97, identifier:default_exclude_patterns; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:conf_dir; 101, call; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:os; 105, identifier:path; 106, identifier:dirname; 107, argument_list; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:str; 110, argument_list; 110, 111; 111, identifier:node; 112, for_statement; 112, 113; 112, 114; 112, 121; 113, identifier:node; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:data; 117, identifier:get; 118, argument_list; 118, 119; 118, 120; 119, string:"INPUT"; 120, list:[]; 121, block; 121, 122; 121, 145; 122, if_statement; 122, 123; 122, 132; 123, not_operator; 123, 124; 124, call; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:os; 128, identifier:path; 129, identifier:isabs; 130, argument_list; 130, 131; 131, identifier:node; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:node; 136, call; 136, 137; 136, 142; 137, attribute; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:os; 140, identifier:path; 141, identifier:join; 142, argument_list; 142, 143; 142, 144; 143, identifier:conf_dir; 144, identifier:node; 145, if_statement; 145, 146; 145, 154; 145, 162; 146, call; 146, 147; 146, 152; 147, attribute; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:os; 150, identifier:path; 151, identifier:isfile; 152, argument_list; 152, 153; 153, identifier:node; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:sources; 159, identifier:append; 160, argument_list; 160, 161; 161, identifier:node; 162, elif_clause; 162, 163; 162, 171; 163, call; 163, 164; 163, 169; 164, attribute; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:os; 167, identifier:path; 168, identifier:isdir; 169, argument_list; 169, 170; 170, identifier:node; 171, block; 171, 172; 172, if_statement; 172, 173; 172, 174; 172, 257; 173, identifier:recursive; 174, block; 174, 175; 175, for_statement; 175, 176; 175, 180; 175, 186; 176, pattern_list; 176, 177; 176, 178; 176, 179; 177, identifier:root; 178, identifier:dirs; 179, identifier:files; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:os; 183, identifier:walk; 184, argument_list; 184, 185; 185, identifier:node; 186, block; 186, 187; 187, for_statement; 187, 188; 187, 189; 187, 190; 188, identifier:f; 189, identifier:files; 190, block; 190, 191; 190, 203; 190, 225; 190, 244; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:filename; 194, call; 194, 195; 194, 200; 195, attribute; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:os; 198, identifier:path; 199, identifier:join; 200, argument_list; 200, 201; 200, 202; 201, identifier:root; 202, identifier:f; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:pattern_check; 206, call; 206, 207; 206, 208; 207, identifier:reduce; 208, argument_list; 208, 209; 208, 223; 208, 224; 209, lambda; 209, 210; 209, 213; 210, lambda_parameters; 210, 211; 210, 212; 211, identifier:x; 212, identifier:y; 213, boolean_operator:or; 213, 214; 213, 215; 214, identifier:x; 215, call; 215, 216; 215, 217; 216, identifier:bool; 217, argument_list; 217, 218; 218, call; 218, 219; 218, 220; 219, identifier:fnmatch; 220, argument_list; 220, 221; 220, 222; 221, identifier:filename; 222, identifier:y; 223, identifier:file_patterns; 224, False; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:exclude_check; 228, call; 228, 229; 228, 230; 229, identifier:reduce; 230, argument_list; 230, 231; 230, 242; 230, 243; 231, lambda; 231, 232; 231, 235; 232, lambda_parameters; 232, 233; 232, 234; 233, identifier:x; 234, identifier:y; 235, boolean_operator:and; 235, 236; 235, 237; 236, identifier:x; 237, call; 237, 238; 237, 239; 238, identifier:fnmatch; 239, argument_list; 239, 240; 239, 241; 240, identifier:filename; 241, identifier:y; 242, identifier:exclude_patterns; 243, True; 244, if_statement; 244, 245; 244, 249; 245, boolean_operator:and; 245, 246; 245, 247; 246, identifier:pattern_check; 247, not_operator; 247, 248; 248, identifier:exclude_check; 249, block; 249, 250; 250, expression_statement; 250, 251; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:sources; 254, identifier:append; 255, argument_list; 255, 256; 256, identifier:filename; 257, else_clause; 257, 258; 258, block; 258, 259; 259, for_statement; 259, 260; 259, 261; 259, 262; 260, identifier:pattern; 261, identifier:file_patterns; 262, block; 262, 263; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:sources; 267, identifier:extend; 268, argument_list; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:glob; 272, identifier:glob; 273, argument_list; 273, 274; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, string:"/"; 277, identifier:join; 278, argument_list; 278, 279; 279, list:[node, pattern]; 279, 280; 279, 281; 280, identifier:node; 281, identifier:pattern; 282, for_statement; 282, 283; 282, 284; 282, 291; 283, identifier:node; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:data; 287, identifier:get; 288, argument_list; 288, 289; 288, 290; 289, string:"TAGFILES"; 290, list:[]; 291, block; 291, 292; 291, 303; 291, 326; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:file; 295, subscript; 295, 296; 295, 302; 296, call; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:node; 299, identifier:split; 300, argument_list; 300, 301; 301, string:"="; 302, integer:0; 303, if_statement; 303, 304; 303, 313; 304, not_operator; 304, 305; 305, call; 305, 306; 305, 311; 306, attribute; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:os; 309, identifier:path; 310, identifier:isabs; 311, argument_list; 311, 312; 312, identifier:file; 313, block; 313, 314; 314, expression_statement; 314, 315; 315, assignment; 315, 316; 315, 317; 316, identifier:file; 317, call; 317, 318; 317, 323; 318, attribute; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:os; 321, identifier:path; 322, identifier:join; 323, argument_list; 323, 324; 323, 325; 324, identifier:conf_dir; 325, identifier:file; 326, expression_statement; 326, 327; 327, call; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:sources; 330, identifier:append; 331, argument_list; 331, 332; 332, identifier:file; 333, function_definition; 333, 334; 333, 335; 333, 337; 334, function_name:append_additional_source; 335, parameters; 335, 336; 336, identifier:option; 337, block; 337, 338; 337, 348; 338, expression_statement; 338, 339; 339, assignment; 339, 340; 339, 341; 340, identifier:file; 341, call; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, identifier:data; 344, identifier:get; 345, argument_list; 345, 346; 345, 347; 346, identifier:option; 347, string:""; 348, if_statement; 348, 349; 348, 352; 349, comparison_operator:!=; 349, 350; 349, 351; 350, identifier:file; 351, string:""; 352, block; 352, 353; 352, 376; 353, if_statement; 353, 354; 353, 363; 354, not_operator; 354, 355; 355, call; 355, 356; 355, 361; 356, attribute; 356, 357; 356, 360; 357, attribute; 357, 358; 357, 359; 358, identifier:os; 359, identifier:path; 360, identifier:isabs; 361, argument_list; 361, 362; 362, identifier:file; 363, block; 363, 364; 364, expression_statement; 364, 365; 365, assignment; 365, 366; 365, 367; 366, identifier:file; 367, call; 367, 368; 367, 373; 368, attribute; 368, 369; 368, 372; 369, attribute; 369, 370; 369, 371; 370, identifier:os; 371, identifier:path; 372, identifier:join; 373, argument_list; 373, 374; 373, 375; 374, identifier:conf_dir; 375, identifier:file; 376, if_statement; 376, 377; 376, 385; 377, call; 377, 378; 377, 383; 378, attribute; 378, 379; 378, 382; 379, attribute; 379, 380; 379, 381; 380, identifier:os; 381, identifier:path; 382, identifier:isfile; 383, argument_list; 383, 384; 384, identifier:file; 385, block; 385, 386; 386, expression_statement; 386, 387; 387, call; 387, 388; 387, 391; 388, attribute; 388, 389; 388, 390; 389, identifier:sources; 390, identifier:append; 391, argument_list; 391, 392; 392, identifier:file; 393, expression_statement; 393, 394; 394, call; 394, 395; 394, 396; 395, identifier:append_additional_source; 396, argument_list; 396, 397; 397, string:"HTML_STYLESHEET"; 398, expression_statement; 398, 399; 399, call; 399, 400; 399, 401; 400, identifier:append_additional_source; 401, argument_list; 401, 402; 402, string:"HTML_HEADER"; 403, expression_statement; 403, 404; 404, call; 404, 405; 404, 406; 405, identifier:append_additional_source; 406, argument_list; 406, 407; 407, string:"HTML_FOOTER"; 408, expression_statement; 408, 409; 409, assignment; 409, 410; 409, 411; 410, identifier:sources; 411, call; 411, 412; 411, 413; 412, identifier:map; 413, argument_list; 413, 414; 413, 423; 414, lambda; 414, 415; 414, 417; 415, lambda_parameters; 415, 416; 416, identifier:path; 417, call; 417, 418; 417, 421; 418, attribute; 418, 419; 418, 420; 419, identifier:env; 420, identifier:File; 421, argument_list; 421, 422; 422, identifier:path; 423, identifier:sources; 424, return_statement; 424, 425; 425, identifier:sources | def DoxySourceScan(node, env, path):
default_file_patterns = [
'*.c', '*.cc', '*.cxx', '*.cpp', '*.c++', '*.java', '*.ii', '*.ixx',
'*.ipp', '*.i++', '*.inl', '*.h', '*.hh ', '*.hxx', '*.hpp', '*.h++',
'*.idl', '*.odl', '*.cs', '*.php', '*.php3', '*.inc', '*.m', '*.mm',
'*.py',
]
default_exclude_patterns = [
'*~',
]
sources = []
data = DoxyfileParse(node.get_contents())
if data.get("RECURSIVE", "NO") == "YES":
recursive = True
else:
recursive = False
file_patterns = data.get("FILE_PATTERNS", default_file_patterns)
exclude_patterns = data.get("EXCLUDE_PATTERNS", default_exclude_patterns)
conf_dir = os.path.dirname(str(node))
for node in data.get("INPUT", []):
if not os.path.isabs(node):
node = os.path.join(conf_dir, node)
if os.path.isfile(node):
sources.append(node)
elif os.path.isdir(node):
if recursive:
for root, dirs, files in os.walk(node):
for f in files:
filename = os.path.join(root, f)
pattern_check = reduce(lambda x, y: x or bool(fnmatch(filename, y)), file_patterns, False)
exclude_check = reduce(lambda x, y: x and fnmatch(filename, y), exclude_patterns, True)
if pattern_check and not exclude_check:
sources.append(filename)
else:
for pattern in file_patterns:
sources.extend(glob.glob("/".join([node, pattern])))
for node in data.get("TAGFILES", []):
file = node.split("=")[0]
if not os.path.isabs(file):
file = os.path.join(conf_dir, file)
sources.append(file)
def append_additional_source(option):
file = data.get(option, "")
if file != "":
if not os.path.isabs(file):
file = os.path.join(conf_dir, file)
if os.path.isfile(file):
sources.append(file)
append_additional_source("HTML_STYLESHEET")
append_additional_source("HTML_HEADER")
append_additional_source("HTML_FOOTER")
sources = map( lambda path: env.File(path), sources )
return sources |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_quadratic_costs; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:generators; 6, identifier:ipol; 7, identifier:nxyz; 8, identifier:base_mva; 9, block; 9, 10; 9, 17; 9, 24; 9, 38; 9, 61; 9, 89; 9, 117; 9, 126; 9, 316; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:npol; 13, call; 13, 14; 13, 15; 14, identifier:len; 15, argument_list; 15, 16; 16, identifier:ipol; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:rnpol; 20, call; 20, 21; 20, 22; 21, identifier:range; 22, argument_list; 22, 23; 23, identifier:npol; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:gpol; 27, list_comprehension; 27, 28; 27, 29; 27, 32; 28, identifier:g; 29, for_in_clause; 29, 30; 29, 31; 30, identifier:g; 31, identifier:generators; 32, if_clause; 32, 33; 33, comparison_operator:==; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:g; 36, identifier:pcost_model; 37, identifier:POLYNOMIAL; 38, if_statement; 38, 39; 38, 53; 39, list_comprehension; 39, 40; 39, 41; 39, 44; 40, identifier:g; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:g; 43, identifier:gpol; 44, if_clause; 44, 45; 45, comparison_operator:>; 45, 46; 45, 52; 46, call; 46, 47; 46, 48; 47, identifier:len; 48, argument_list; 48, 49; 49, attribute; 49, 50; 49, 51; 50, identifier:g; 51, identifier:p_cost; 52, integer:3; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:logger; 58, identifier:error; 59, argument_list; 59, 60; 60, string:"Order of polynomial cost greater than quadratic."; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:iqdr; 64, list_comprehension; 64, 65; 64, 66; 64, 74; 65, identifier:i; 66, for_in_clause; 66, 67; 66, 70; 67, pattern_list; 67, 68; 67, 69; 68, identifier:i; 69, identifier:g; 70, call; 70, 71; 70, 72; 71, identifier:enumerate; 72, argument_list; 72, 73; 73, identifier:generators; 74, if_clause; 74, 75; 75, boolean_operator:and; 75, 76; 75, 81; 76, comparison_operator:==; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:g; 79, identifier:pcost_model; 80, identifier:POLYNOMIAL; 81, comparison_operator:==; 81, 82; 81, 88; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, attribute; 85, 86; 85, 87; 86, identifier:g; 87, identifier:p_cost; 88, integer:3; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:ilin; 92, list_comprehension; 92, 93; 92, 94; 92, 102; 93, identifier:i; 94, for_in_clause; 94, 95; 94, 98; 95, pattern_list; 95, 96; 95, 97; 96, identifier:i; 97, identifier:g; 98, call; 98, 99; 98, 100; 99, identifier:enumerate; 100, argument_list; 100, 101; 101, identifier:generators; 102, if_clause; 102, 103; 103, boolean_operator:and; 103, 104; 103, 109; 104, comparison_operator:==; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:g; 107, identifier:pcost_model; 108, identifier:POLYNOMIAL; 109, comparison_operator:==; 109, 110; 109, 116; 110, call; 110, 111; 110, 112; 111, identifier:len; 112, argument_list; 112, 113; 113, attribute; 113, 114; 113, 115; 114, identifier:g; 115, identifier:p_cost; 116, integer:2; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:polycf; 120, call; 120, 121; 120, 122; 121, identifier:zeros; 122, argument_list; 122, 123; 123, tuple; 123, 124; 123, 125; 124, identifier:npol; 125, integer:3; 126, if_statement; 126, 127; 126, 130; 126, 292; 127, comparison_operator:>; 127, 128; 127, 129; 128, identifier:npol; 129, integer:0; 130, block; 130, 131; 130, 159; 130, 192; 130, 206; 130, 217; 130, 241; 130, 261; 130, 269; 131, if_statement; 131, 132; 131, 138; 132, comparison_operator:>; 132, 133; 132, 137; 133, call; 133, 134; 133, 135; 134, identifier:len; 135, argument_list; 135, 136; 136, identifier:iqdr; 137, integer:0; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 146; 141, subscript; 141, 142; 141, 143; 141, 144; 142, identifier:polycf; 143, identifier:iqdr; 144, slice; 144, 145; 145, colon; 146, call; 146, 147; 146, 148; 147, identifier:array; 148, argument_list; 148, 149; 149, list_comprehension; 149, 150; 149, 156; 150, call; 150, 151; 150, 152; 151, identifier:list; 152, argument_list; 152, 153; 153, attribute; 153, 154; 153, 155; 154, identifier:g; 155, identifier:p_cost; 156, for_in_clause; 156, 157; 156, 158; 157, identifier:g; 158, identifier:generators; 159, if_statement; 159, 160; 159, 166; 160, comparison_operator:>; 160, 161; 160, 165; 161, call; 161, 162; 161, 163; 162, identifier:len; 163, argument_list; 163, 164; 164, identifier:ilin; 165, integer:0; 166, block; 166, 167; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 175; 169, subscript; 169, 170; 169, 171; 169, 172; 170, identifier:polycf; 171, identifier:ilin; 172, slice; 172, 173; 172, 174; 173, integer:1; 174, colon; 175, call; 175, 176; 175, 177; 176, identifier:array; 177, argument_list; 177, 178; 178, list_comprehension; 178, 179; 178, 189; 179, call; 179, 180; 179, 181; 180, identifier:list; 181, argument_list; 181, 182; 182, subscript; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:g; 185, identifier:p_cost; 186, slice; 186, 187; 186, 188; 187, colon; 188, integer:2; 189, for_in_clause; 189, 190; 189, 191; 190, identifier:g; 191, identifier:generators; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:polycf; 195, binary_operator:*; 195, 196; 195, 197; 196, identifier:polycf; 197, call; 197, 198; 197, 199; 198, identifier:array; 199, argument_list; 199, 200; 200, list:[base_mva**2, base_mva, 1]; 200, 201; 200, 204; 200, 205; 201, binary_operator:**; 201, 202; 201, 203; 202, identifier:base_mva; 203, integer:2; 204, identifier:base_mva; 205, integer:1; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:Pg; 209, call; 209, 210; 209, 215; 210, attribute; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:self; 213, identifier:om; 214, identifier:get_var; 215, argument_list; 215, 216; 216, string:"Pg"; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:Npol; 220, call; 220, 221; 220, 222; 221, identifier:csr_matrix; 222, argument_list; 222, 223; 222, 238; 223, tuple; 223, 224; 223, 228; 224, call; 224, 225; 224, 226; 225, identifier:ones; 226, argument_list; 226, 227; 227, identifier:npol; 228, tuple; 228, 229; 228, 230; 229, identifier:rnpol; 230, binary_operator:+; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:Pg; 233, identifier:i1; 234, call; 234, 235; 234, 236; 235, identifier:array; 236, argument_list; 236, 237; 237, identifier:ipol; 238, tuple; 238, 239; 238, 240; 239, identifier:npol; 240, identifier:nxyz; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:Hpol; 244, call; 244, 245; 244, 246; 245, identifier:csr_matrix; 246, argument_list; 246, 247; 246, 258; 247, tuple; 247, 248; 247, 255; 248, binary_operator:*; 248, 249; 248, 250; 249, integer:2; 250, subscript; 250, 251; 250, 252; 250, 254; 251, identifier:polycf; 252, slice; 252, 253; 253, colon; 254, integer:0; 255, tuple; 255, 256; 255, 257; 256, identifier:rnpol; 257, identifier:rnpol; 258, tuple; 258, 259; 258, 260; 259, identifier:npol; 260, identifier:npol; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:Cpol; 264, subscript; 264, 265; 264, 266; 264, 268; 265, identifier:polycf; 266, slice; 266, 267; 267, colon; 268, integer:1; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:fparm_pol; 272, attribute; 272, 273; 272, 291; 273, parenthesized_expression; 273, 274; 274, binary_operator:*; 274, 275; 274, 279; 275, call; 275, 276; 275, 277; 276, identifier:ones; 277, argument_list; 277, 278; 278, identifier:npol; 279, call; 279, 280; 279, 281; 280, identifier:array; 281, argument_list; 281, 282; 282, list:[[1], [0], [0], [1]]; 282, 283; 282, 285; 282, 287; 282, 289; 283, list:[1]; 283, 284; 284, integer:1; 285, list:[0]; 285, 286; 286, integer:0; 287, list:[0]; 287, 288; 288, integer:0; 289, list:[1]; 289, 290; 290, integer:1; 291, identifier:T; 292, else_clause; 292, 293; 293, block; 293, 294; 293, 300; 293, 307; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:Npol; 297, assignment; 297, 298; 297, 299; 298, identifier:Hpol; 299, None; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:Cpol; 303, call; 303, 304; 303, 305; 304, identifier:array; 305, argument_list; 305, 306; 306, list:[]; 307, expression_statement; 307, 308; 308, assignment; 308, 309; 308, 310; 309, identifier:fparm_pol; 310, call; 310, 311; 310, 312; 311, identifier:zeros; 312, argument_list; 312, 313; 313, tuple; 313, 314; 313, 315; 314, integer:0; 315, integer:4; 316, return_statement; 316, 317; 317, expression_list; 317, 318; 317, 319; 317, 320; 317, 321; 317, 322; 317, 323; 318, identifier:Npol; 319, identifier:Hpol; 320, identifier:Cpol; 321, identifier:fparm_pol; 322, identifier:polycf; 323, identifier:npol | def _quadratic_costs(self, generators, ipol, nxyz, base_mva):
npol = len(ipol)
rnpol = range(npol)
gpol = [g for g in generators if g.pcost_model == POLYNOMIAL]
if [g for g in gpol if len(g.p_cost) > 3]:
logger.error("Order of polynomial cost greater than quadratic.")
iqdr = [i for i, g in enumerate(generators)
if g.pcost_model == POLYNOMIAL and len(g.p_cost) == 3]
ilin = [i for i, g in enumerate(generators)
if g.pcost_model == POLYNOMIAL and len(g.p_cost) == 2]
polycf = zeros((npol, 3))
if npol > 0:
if len(iqdr) > 0:
polycf[iqdr, :] = array([list(g.p_cost)
for g in generators])
if len(ilin) > 0:
polycf[ilin, 1:] = array([list(g.p_cost[:2])
for g in generators])
polycf = polycf * array([base_mva**2, base_mva, 1])
Pg = self.om.get_var("Pg")
Npol = csr_matrix((ones(npol), (rnpol, Pg.i1 + array(ipol))),
(npol, nxyz))
Hpol = csr_matrix((2 * polycf[:, 0], (rnpol, rnpol)), (npol, npol))
Cpol = polycf[:, 1]
fparm_pol = (ones(npol) * array([[1], [0], [0], [1]])).T
else:
Npol = Hpol = None
Cpol = array([])
fparm_pol = zeros((0, 4))
return Npol, Hpol, Cpol, fparm_pol, polycf, npol |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_gh; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:x; 6, block; 6, 7; 6, 26; 6, 45; 6, 80; 6, 95; 6, 114; 6, 133; 6, 144; 6, 159; 6, 170; 6, 192; 6, 212; 6, 384; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:Pgen; 10, subscript; 10, 11; 10, 12; 11, identifier:x; 12, slice; 12, 13; 12, 18; 12, 19; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_Pg; 17, identifier:i1; 18, colon; 19, binary_operator:+; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_Pg; 24, identifier:iN; 25, integer:1; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:Qgen; 29, subscript; 29, 30; 29, 31; 30, identifier:x; 31, slice; 31, 32; 31, 37; 31, 38; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:_Qg; 36, identifier:i1; 37, colon; 38, binary_operator:+; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:_Qg; 43, identifier:iN; 44, integer:1; 45, for_statement; 45, 46; 45, 49; 45, 55; 46, pattern_list; 46, 47; 46, 48; 47, identifier:i; 48, identifier:gen; 49, call; 49, 50; 49, 51; 50, identifier:enumerate; 51, argument_list; 51, 52; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:_gn; 55, block; 55, 56; 55, 68; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:gen; 60, identifier:p; 61, binary_operator:*; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:Pgen; 64, identifier:i; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:_base_mva; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:gen; 72, identifier:q; 73, binary_operator:*; 73, 74; 73, 77; 74, subscript; 74, 75; 74, 76; 75, identifier:Qgen; 76, identifier:i; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:_base_mva; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:Sbus; 83, call; 83, 84; 83, 91; 84, attribute; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:om; 89, identifier:case; 90, identifier:getSbus; 91, argument_list; 91, 92; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:_bs; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:Vang; 98, subscript; 98, 99; 98, 100; 99, identifier:x; 100, slice; 100, 101; 100, 106; 100, 107; 101, attribute; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:_Va; 105, identifier:i1; 106, colon; 107, binary_operator:+; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:_Va; 112, identifier:iN; 113, integer:1; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:Vmag; 117, subscript; 117, 118; 117, 119; 118, identifier:x; 119, slice; 119, 120; 119, 125; 119, 126; 120, attribute; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:_Vm; 124, identifier:i1; 125, colon; 126, binary_operator:+; 126, 127; 126, 132; 127, attribute; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:_Vm; 131, identifier:iN; 132, integer:1; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:V; 136, binary_operator:*; 136, 137; 136, 138; 137, identifier:Vmag; 138, call; 138, 139; 138, 140; 139, identifier:exp; 140, argument_list; 140, 141; 141, binary_operator:*; 141, 142; 141, 143; 142, integer:1j; 143, identifier:Vang; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:mis; 147, binary_operator:-; 147, 148; 147, 158; 148, binary_operator:*; 148, 149; 148, 150; 149, identifier:V; 150, call; 150, 151; 150, 152; 151, identifier:conj; 152, argument_list; 152, 153; 153, binary_operator:*; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:_Ybus; 157, identifier:V; 158, identifier:Sbus; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:g; 162, subscript; 162, 163; 162, 164; 162, 167; 163, identifier:r_; 164, attribute; 164, 165; 164, 166; 165, identifier:mis; 166, identifier:real; 167, attribute; 167, 168; 167, 169; 168, identifier:mis; 169, identifier:imag; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:flow_max; 173, call; 173, 174; 173, 175; 174, identifier:array; 175, argument_list; 175, 176; 176, list_comprehension; 176, 177; 176, 187; 177, binary_operator:**; 177, 178; 177, 186; 178, parenthesized_expression; 178, 179; 179, binary_operator:/; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:l; 182, identifier:rate_a; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:_base_mva; 186, integer:2; 187, for_in_clause; 187, 188; 187, 189; 188, identifier:l; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:_ln; 192, for_statement; 192, 193; 192, 196; 192, 200; 193, pattern_list; 193, 194; 193, 195; 194, identifier:i; 195, identifier:v; 196, call; 196, 197; 196, 198; 197, identifier:enumerate; 198, argument_list; 198, 199; 199, identifier:flow_max; 200, block; 200, 201; 201, if_statement; 201, 202; 201, 205; 202, comparison_operator:==; 202, 203; 202, 204; 203, identifier:v; 204, float:0.0; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 211; 208, subscript; 208, 209; 208, 210; 209, identifier:flow_max; 210, identifier:i; 211, identifier:Inf; 212, if_statement; 212, 213; 212, 218; 212, 258; 213, comparison_operator:==; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:flow_lim; 217, identifier:IFLOW; 218, block; 218, 219; 218, 227; 218, 235; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:If; 222, binary_operator:*; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:_Yf; 226, identifier:V; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:It; 230, binary_operator:*; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:self; 233, identifier:_Yt; 234, identifier:V; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:h; 238, subscript; 238, 239; 238, 240; 238, 249; 239, identifier:r_; 240, binary_operator:-; 240, 241; 240, 248; 241, parenthesized_expression; 241, 242; 242, binary_operator:*; 242, 243; 242, 244; 243, identifier:If; 244, call; 244, 245; 244, 246; 245, identifier:conj; 246, argument_list; 246, 247; 247, identifier:If; 248, identifier:flow_max; 249, binary_operator:-; 249, 250; 249, 257; 250, parenthesized_expression; 250, 251; 251, binary_operator:*; 251, 252; 251, 253; 252, identifier:It; 253, call; 253, 254; 253, 255; 254, identifier:conj; 255, argument_list; 255, 256; 256, identifier:It; 257, identifier:flow_max; 258, else_clause; 258, 259; 259, block; 259, 260; 259, 274; 259, 288; 259, 303; 259, 318; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:i_fbus; 263, list_comprehension; 263, 264; 263, 269; 264, attribute; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:e; 267, identifier:from_bus; 268, identifier:_i; 269, for_in_clause; 269, 270; 269, 271; 270, identifier:e; 271, attribute; 271, 272; 271, 273; 272, identifier:self; 273, identifier:_ln; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:i_tbus; 277, list_comprehension; 277, 278; 277, 283; 278, attribute; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:e; 281, identifier:to_bus; 282, identifier:_i; 283, for_in_clause; 283, 284; 283, 285; 284, identifier:e; 285, attribute; 285, 286; 285, 287; 286, identifier:self; 287, identifier:_ln; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:Sf; 291, binary_operator:*; 291, 292; 291, 295; 292, subscript; 292, 293; 292, 294; 293, identifier:V; 294, identifier:i_fbus; 295, call; 295, 296; 295, 297; 296, identifier:conj; 297, argument_list; 297, 298; 298, binary_operator:*; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:self; 301, identifier:_Yf; 302, identifier:V; 303, expression_statement; 303, 304; 304, assignment; 304, 305; 304, 306; 305, identifier:St; 306, binary_operator:*; 306, 307; 306, 310; 307, subscript; 307, 308; 307, 309; 308, identifier:V; 309, identifier:i_tbus; 310, call; 310, 311; 310, 312; 311, identifier:conj; 312, argument_list; 312, 313; 313, binary_operator:*; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:self; 316, identifier:_Yt; 317, identifier:V; 318, if_statement; 318, 319; 318, 324; 318, 348; 318, 380; 319, comparison_operator:==; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:self; 322, identifier:flow_lim; 323, identifier:PFLOW; 324, block; 324, 325; 325, expression_statement; 325, 326; 326, assignment; 326, 327; 326, 328; 327, identifier:h; 328, subscript; 328, 329; 328, 330; 328, 339; 329, identifier:r_; 330, binary_operator:-; 330, 331; 330, 338; 331, binary_operator:**; 331, 332; 331, 337; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:Sf; 335, identifier:real; 336, argument_list; 337, integer:2; 338, identifier:flow_max; 339, binary_operator:-; 339, 340; 339, 347; 340, binary_operator:**; 340, 341; 340, 346; 341, call; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, identifier:St; 344, identifier:real; 345, argument_list; 346, integer:2; 347, identifier:flow_max; 348, elif_clause; 348, 349; 348, 354; 349, comparison_operator:==; 349, 350; 349, 353; 350, attribute; 350, 351; 350, 352; 351, identifier:self; 352, identifier:flow_lim; 353, identifier:SFLOW; 354, block; 354, 355; 355, expression_statement; 355, 356; 356, assignment; 356, 357; 356, 358; 357, identifier:h; 358, attribute; 358, 359; 358, 379; 359, subscript; 359, 360; 359, 361; 359, 370; 360, identifier:r_; 361, binary_operator:-; 361, 362; 361, 369; 362, parenthesized_expression; 362, 363; 363, binary_operator:*; 363, 364; 363, 365; 364, identifier:Sf; 365, call; 365, 366; 365, 367; 366, identifier:conj; 367, argument_list; 367, 368; 368, identifier:Sf; 369, identifier:flow_max; 370, binary_operator:-; 370, 371; 370, 378; 371, parenthesized_expression; 371, 372; 372, binary_operator:*; 372, 373; 372, 374; 373, identifier:St; 374, call; 374, 375; 374, 376; 375, identifier:conj; 376, argument_list; 376, 377; 377, identifier:St; 378, identifier:flow_max; 379, identifier:real; 380, else_clause; 380, 381; 381, block; 381, 382; 382, raise_statement; 382, 383; 383, identifier:ValueError; 384, return_statement; 384, 385; 385, expression_list; 385, 386; 385, 387; 386, identifier:h; 387, identifier:g | def _gh(self, x):
Pgen = x[self._Pg.i1:self._Pg.iN + 1]
Qgen = x[self._Qg.i1:self._Qg.iN + 1]
for i, gen in enumerate(self._gn):
gen.p = Pgen[i] * self._base_mva
gen.q = Qgen[i] * self._base_mva
Sbus = self.om.case.getSbus(self._bs)
Vang = x[self._Va.i1:self._Va.iN + 1]
Vmag = x[self._Vm.i1:self._Vm.iN + 1]
V = Vmag * exp(1j * Vang)
mis = V * conj(self._Ybus * V) - Sbus
g = r_[mis.real,
mis.imag]
flow_max = array([(l.rate_a / self._base_mva)**2 for l in self._ln])
for i, v in enumerate(flow_max):
if v == 0.0:
flow_max[i] = Inf
if self.flow_lim == IFLOW:
If = self._Yf * V
It = self._Yt * V
h = r_[(If * conj(If)) - flow_max,
(It * conj(It)) - flow_max]
else:
i_fbus = [e.from_bus._i for e in self._ln]
i_tbus = [e.to_bus._i for e in self._ln]
Sf = V[i_fbus] * conj(self._Yf * V)
St = V[i_tbus] * conj(self._Yt * V)
if self.flow_lim == PFLOW:
h = r_[Sf.real()**2 - flow_max,
St.real()**2 - flow_max]
elif self.flow_lim == SFLOW:
h = r_[(Sf * conj(Sf)) - flow_max,
(St * conj(St)) - flow_max].real
else:
raise ValueError
return h, g |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:performAction; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:action; 6, block; 6, 7; 6, 27; 6, 37; 6, 49; 6, 66; 6, 80; 6, 102; 6, 163; 6, 169; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:gs; 10, list_comprehension; 10, 11; 10, 12; 10, 19; 11, identifier:g; 12, for_in_clause; 12, 13; 12, 14; 13, identifier:g; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:case; 18, identifier:online_generators; 19, if_clause; 19, 20; 20, comparison_operator:!=; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:g; 24, identifier:bus; 25, identifier:type; 26, identifier:REFERENCE; 27, assert_statement; 27, 28; 28, comparison_operator:==; 28, 29; 28, 33; 29, call; 29, 30; 29, 31; 30, identifier:len; 31, argument_list; 31, 32; 32, identifier:action; 33, call; 33, 34; 33, 35; 34, identifier:len; 35, argument_list; 35, 36; 36, identifier:gs; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:logger; 41, identifier:info; 42, argument_list; 42, 43; 43, binary_operator:%; 43, 44; 43, 45; 44, string:"Action: %s"; 45, call; 45, 46; 45, 47; 46, identifier:list; 47, argument_list; 47, 48; 48, identifier:action; 49, for_statement; 49, 50; 49, 53; 49, 57; 50, pattern_list; 50, 51; 50, 52; 51, identifier:i; 52, identifier:g; 53, call; 53, 54; 53, 55; 54, identifier:enumerate; 55, argument_list; 55, 56; 56, identifier:gs; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:g; 62, identifier:p; 63, subscript; 63, 64; 63, 65; 64, identifier:action; 65, identifier:i; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 79; 68, attribute; 68, 69; 68, 78; 69, call; 69, 70; 69, 71; 70, identifier:NewtonPF; 71, argument_list; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:case; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:verbose; 77, False; 78, identifier:solve; 79, argument_list; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 91; 82, subscript; 82, 83; 82, 86; 82, 88; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:_Pg; 86, slice; 86, 87; 87, colon; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:_step; 91, list_comprehension; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:g; 94, identifier:p; 95, for_in_clause; 95, 96; 95, 97; 96, identifier:g; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:case; 101, identifier:online_generators; 102, if_statement; 102, 103; 102, 115; 103, comparison_operator:!=; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:_step; 107, binary_operator:-; 107, 108; 107, 114; 108, call; 108, 109; 108, 110; 109, identifier:len; 110, argument_list; 110, 111; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:profile; 114, integer:1; 115, block; 115, 116; 115, 134; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:pq_buses; 119, list_comprehension; 119, 120; 119, 121; 119, 128; 120, identifier:b; 121, for_in_clause; 121, 122; 121, 123; 122, identifier:b; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:case; 127, identifier:buses; 128, if_clause; 128, 129; 129, comparison_operator:==; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:b; 132, identifier:type; 133, identifier:PQ; 134, for_statement; 134, 135; 134, 138; 134, 142; 135, pattern_list; 135, 136; 135, 137; 136, identifier:i; 137, identifier:b; 138, call; 138, 139; 138, 140; 139, identifier:enumerate; 140, argument_list; 140, 141; 141, identifier:pq_buses; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:b; 147, identifier:p_demand; 148, binary_operator:*; 148, 149; 148, 154; 149, subscript; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:_Pd0; 153, identifier:i; 154, subscript; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:profile; 158, binary_operator:+; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:_step; 162, integer:1; 163, expression_statement; 163, 164; 164, augmented_assignment:+=; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:_step; 168, integer:1; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:logger; 173, identifier:info; 174, argument_list; 174, 175; 175, binary_operator:%; 175, 176; 175, 177; 176, string:"Entering step %d."; 177, attribute; 177, 178; 177, 179; 178, identifier:self; 179, identifier:_step | def performAction(self, action):
gs = [g for g in self.case.online_generators if g.bus.type !=REFERENCE]
assert len(action) == len(gs)
logger.info("Action: %s" % list(action))
for i, g in enumerate(gs):
g.p = action[i]
NewtonPF(self.case, verbose=False).solve()
self._Pg[:, self._step] = [g.p for g in self.case.online_generators]
if self._step != len(self.profile) - 1:
pq_buses = [b for b in self.case.buses if b.type == PQ]
for i, b in enumerate(pq_buses):
b.p_demand = self._Pd0[i] * self.profile[self._step + 1]
self._step += 1
logger.info("Entering step %d." % self._step) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 1, 28; 2, function_name:blt; 3, parameters; 3, 4; 3, 12; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:f; 6, type; 6, 7; 7, generic_type; 7, 8; 7, 9; 8, identifier:List; 9, type_parameter; 9, 10; 10, type; 10, 11; 11, identifier:SYM; 12, typed_parameter; 12, 13; 12, 14; 13, identifier:x; 14, type; 14, 15; 15, generic_type; 15, 16; 15, 17; 16, identifier:List; 17, type_parameter; 17, 18; 18, type; 18, 19; 19, identifier:SYM; 20, type; 20, 21; 21, generic_type; 21, 22; 21, 23; 22, identifier:Dict; 23, type_parameter; 23, 24; 23, 26; 24, type; 24, 25; 25, identifier:str; 26, type; 26, 27; 27, identifier:Any; 28, block; 28, 29; 28, 39; 28, 58; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:J; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:ca; 35, identifier:jacobian; 36, argument_list; 36, 37; 36, 38; 37, identifier:f; 38, identifier:x; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 49; 41, pattern_list; 41, 42; 41, 43; 41, 44; 41, 45; 41, 46; 41, 47; 41, 48; 42, identifier:nblock; 43, identifier:rowperm; 44, identifier:colperm; 45, identifier:rowblock; 46, identifier:colblock; 47, identifier:coarserow; 48, identifier:coarsecol; 49, call; 49, 50; 49, 57; 50, attribute; 50, 51; 50, 56; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:J; 54, identifier:sparsity; 55, argument_list; 56, identifier:btf; 57, argument_list; 58, return_statement; 58, 59; 59, dictionary; 59, 60; 59, 63; 59, 66; 59, 69; 59, 72; 59, 75; 59, 78; 59, 81; 60, pair; 60, 61; 60, 62; 61, string:'J'; 62, identifier:J; 63, pair; 63, 64; 63, 65; 64, string:'nblock'; 65, identifier:nblock; 66, pair; 66, 67; 66, 68; 67, string:'rowperm'; 68, identifier:rowperm; 69, pair; 69, 70; 69, 71; 70, string:'colperm'; 71, identifier:colperm; 72, pair; 72, 73; 72, 74; 73, string:'rowblock'; 74, identifier:rowblock; 75, pair; 75, 76; 75, 77; 76, string:'colblock'; 77, identifier:colblock; 78, pair; 78, 79; 78, 80; 79, string:'coarserow'; 80, identifier:coarserow; 81, pair; 81, 82; 81, 83; 82, string:'coarsecol'; 83, identifier:coarsecol | def blt(f: List[SYM], x: List[SYM]) -> Dict[str, Any]:
J = ca.jacobian(f, x)
nblock, rowperm, colperm, rowblock, colblock, coarserow, coarsecol = J.sparsity().btf()
return {
'J': J,
'nblock': nblock,
'rowperm': rowperm,
'colperm': colperm,
'rowblock': rowblock,
'colblock': colblock,
'coarserow': coarserow,
'coarsecol': coarsecol
} |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_generators; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 13; 8, attribute; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:generators; 12, identifier:sort; 13, argument_list; 13, 14; 14, keyword_argument; 14, 15; 14, 16; 15, identifier:key; 16, lambda; 16, 17; 16, 19; 17, lambda_parameters; 17, 18; 18, identifier:gn; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:gn; 22, identifier:bus; 23, identifier:_i | def sort_generators(self):
self.generators.sort(key=lambda gn: gn.bus._i) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:create; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:dotdata; 6, default_parameter; 6, 7; 6, 8; 7, identifier:prog; 8, string:"dot"; 9, default_parameter; 9, 10; 9, 11; 10, identifier:format; 11, string:"xdot"; 12, block; 12, 13; 12, 18; 12, 24; 12, 30; 12, 44; 12, 71; 12, 81; 12, 88; 12, 96; 12, 103; 12, 109; 12, 120; 12, 149; 12, 155; 12, 161; 12, 167; 12, 190; 12, 196; 12, 208; 12, 261; 12, 269; 12, 299; 12, 306; 13, import_statement; 13, 14; 13, 16; 14, dotted_name; 14, 15; 15, identifier:os; 16, dotted_name; 16, 17; 17, identifier:tempfile; 18, import_from_statement; 18, 19; 18, 22; 19, dotted_name; 19, 20; 19, 21; 20, identifier:dot2tex; 21, identifier:dotparsing; 22, dotted_name; 22, 23; 23, identifier:find_graphviz; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:progs; 27, call; 27, 28; 27, 29; 28, identifier:find_graphviz; 29, argument_list; 30, if_statement; 30, 31; 30, 34; 31, comparison_operator:is; 31, 32; 31, 33; 32, identifier:progs; 33, None; 34, block; 34, 35; 34, 42; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:logger; 39, identifier:warning; 40, argument_list; 40, 41; 41, string:"GraphViz executables not found."; 42, return_statement; 42, 43; 43, None; 44, if_statement; 44, 45; 44, 52; 45, not_operator; 45, 46; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:progs; 49, identifier:has_key; 50, argument_list; 50, 51; 51, identifier:prog; 52, block; 52, 53; 52, 69; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:logger; 57, identifier:warning; 58, argument_list; 58, 59; 59, binary_operator:%; 59, 60; 59, 61; 59, 62; 60, string:'Invalid program [%s]. Available programs are: %s'; 61, line_continuation:\; 62, tuple; 62, 63; 62, 64; 63, identifier:prog; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:progs; 67, identifier:keys; 68, argument_list; 69, return_statement; 69, 70; 70, None; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 76; 73, pattern_list; 73, 74; 73, 75; 74, identifier:tmp_fd; 75, identifier:tmp_name; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:tempfile; 79, identifier:mkstemp; 80, argument_list; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:os; 85, identifier:close; 86, argument_list; 86, 87; 87, identifier:tmp_fd; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:dot_fd; 91, call; 91, 92; 91, 93; 92, identifier:file; 93, argument_list; 93, 94; 93, 95; 94, identifier:tmp_name; 95, string:"w+b"; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:dot_fd; 100, identifier:write; 101, argument_list; 101, 102; 102, identifier:dotdata; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:dot_fd; 107, identifier:close; 108, argument_list; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:tmp_dir; 112, call; 112, 113; 112, 118; 113, attribute; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:os; 116, identifier:path; 117, identifier:dirname; 118, argument_list; 118, 119; 119, identifier:tmp_name; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:p; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:subprocess; 126, identifier:Popen; 127, argument_list; 127, 128; 127, 136; 127, 139; 127, 144; 128, tuple; 128, 129; 128, 132; 128, 135; 129, subscript; 129, 130; 129, 131; 130, identifier:progs; 131, identifier:prog; 132, binary_operator:+; 132, 133; 132, 134; 133, string:'-T'; 134, identifier:format; 135, identifier:tmp_name; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:cwd; 138, identifier:tmp_dir; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:stderr; 141, attribute; 141, 142; 141, 143; 142, identifier:subprocess; 143, identifier:PIPE; 144, keyword_argument; 144, 145; 144, 146; 145, identifier:stdout; 146, attribute; 146, 147; 146, 148; 147, identifier:subprocess; 148, identifier:PIPE; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:stderr; 152, attribute; 152, 153; 152, 154; 153, identifier:p; 154, identifier:stderr; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:stdout; 158, attribute; 158, 159; 158, 160; 159, identifier:p; 160, identifier:stdout; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:stdout_output; 164, call; 164, 165; 164, 166; 165, identifier:list; 166, argument_list; 167, while_statement; 167, 168; 167, 169; 168, True; 169, block; 169, 170; 169, 178; 169, 183; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:data; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:stdout; 176, identifier:read; 177, argument_list; 178, if_statement; 178, 179; 178, 181; 179, not_operator; 179, 180; 180, identifier:data; 181, block; 181, 182; 182, break_statement; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:stdout_output; 187, identifier:append; 188, argument_list; 188, 189; 189, identifier:data; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:stdout; 194, identifier:close; 195, argument_list; 196, if_statement; 196, 197; 196, 198; 197, identifier:stdout_output; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:stdout_output; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, string:''; 205, identifier:join; 206, argument_list; 206, 207; 207, identifier:stdout_output; 208, if_statement; 208, 209; 208, 213; 209, not_operator; 209, 210; 210, attribute; 210, 211; 210, 212; 211, identifier:stderr; 212, identifier:closed; 213, block; 213, 214; 213, 220; 213, 243; 213, 249; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:stderr_output; 217, call; 217, 218; 217, 219; 218, identifier:list; 219, argument_list; 220, while_statement; 220, 221; 220, 222; 221, True; 222, block; 222, 223; 222, 231; 222, 236; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:data; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:stderr; 229, identifier:read; 230, argument_list; 231, if_statement; 231, 232; 231, 234; 232, not_operator; 232, 233; 233, identifier:data; 234, block; 234, 235; 235, break_statement; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:stderr_output; 240, identifier:append; 241, argument_list; 241, 242; 242, identifier:data; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:stderr; 247, identifier:close; 248, argument_list; 249, if_statement; 249, 250; 249, 251; 250, identifier:stderr_output; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:stderr_output; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, string:''; 258, identifier:join; 259, argument_list; 259, 260; 260, identifier:stderr_output; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:status; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:p; 267, identifier:wait; 268, argument_list; 269, if_statement; 269, 270; 269, 273; 269, 288; 270, comparison_operator:!=; 270, 271; 270, 272; 271, identifier:status; 272, integer:0; 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, binary_operator:%; 280, 281; 280, 284; 281, concatenated_string; 281, 282; 281, 283; 282, string:"Program [%s] terminated with status: %d. stderr "; 283, string:"follows: %s"; 284, tuple; 284, 285; 284, 286; 284, 287; 285, identifier:prog; 286, identifier:status; 287, identifier:stderr_output; 288, elif_clause; 288, 289; 288, 290; 289, identifier:stderr_output; 290, block; 290, 291; 291, expression_statement; 291, 292; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:logger; 295, identifier:error; 296, argument_list; 296, 297; 296, 298; 297, string:"%s"; 298, identifier:stderr_output; 299, expression_statement; 299, 300; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:os; 303, identifier:unlink; 304, argument_list; 304, 305; 305, identifier:tmp_name; 306, return_statement; 306, 307; 307, identifier:stdout_output | def create(self, dotdata, prog="dot", format="xdot"):
import os, tempfile
from dot2tex.dotparsing import find_graphviz
progs = find_graphviz()
if progs is None:
logger.warning("GraphViz executables not found.")
return None
if not progs.has_key(prog):
logger.warning('Invalid program [%s]. Available programs are: %s' % \
(prog, progs.keys()))
return None
tmp_fd, tmp_name = tempfile.mkstemp()
os.close(tmp_fd)
dot_fd = file(tmp_name, "w+b")
dot_fd.write(dotdata)
dot_fd.close()
tmp_dir = os.path.dirname(tmp_name)
p = subprocess.Popen((progs[prog], '-T'+format, tmp_name),
cwd=tmp_dir, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
stderr = p.stderr
stdout = p.stdout
stdout_output = list()
while True:
data = stdout.read()
if not data:
break
stdout_output.append(data)
stdout.close()
if stdout_output:
stdout_output = ''.join(stdout_output)
if not stderr.closed:
stderr_output = list()
while True:
data = stderr.read()
if not data:
break
stderr_output.append(data)
stderr.close()
if stderr_output:
stderr_output = ''.join(stderr_output)
status = p.wait()
if status != 0 :
logger.error("Program [%s] terminated with status: %d. stderr " \
"follows: %s" % ( prog, status, stderr_output ) )
elif stderr_output:
logger.error( "%s", stderr_output )
os.unlink(tmp_name)
return stdout_output |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:format; 3, parameters; 3, 4; 3, 5; 4, identifier:file_metrics; 5, identifier:build_metrics; 6, block; 6, 7; 6, 132; 6, 141; 6, 150; 6, 157; 6, 226; 6, 245; 6, 250; 6, 276; 7, function_definition; 7, 8; 7, 9; 7, 14; 8, function_name:indent; 9, parameters; 9, 10; 9, 11; 10, identifier:elem; 11, default_parameter; 11, 12; 11, 13; 12, identifier:level; 13, integer:0; 14, block; 14, 15; 14, 23; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:i; 18, binary_operator:+; 18, 19; 18, 20; 19, string:"\n"; 20, binary_operator:*; 20, 21; 20, 22; 21, identifier:level; 22, string:" "; 23, if_statement; 23, 24; 23, 28; 23, 106; 24, call; 24, 25; 24, 26; 25, identifier:len; 26, argument_list; 26, 27; 27, identifier:elem; 28, block; 28, 29; 28, 52; 28, 73; 28, 85; 29, if_statement; 29, 30; 29, 43; 30, boolean_operator:or; 30, 31; 30, 35; 31, not_operator; 31, 32; 32, attribute; 32, 33; 32, 34; 33, identifier:elem; 34, identifier:text; 35, not_operator; 35, 36; 36, call; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:elem; 40, identifier:text; 41, identifier:strip; 42, argument_list; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:elem; 48, identifier:text; 49, binary_operator:+; 49, 50; 49, 51; 50, identifier:i; 51, string:" "; 52, if_statement; 52, 53; 52, 66; 53, boolean_operator:or; 53, 54; 53, 58; 54, not_operator; 54, 55; 55, attribute; 55, 56; 55, 57; 56, identifier:elem; 57, identifier:tail; 58, not_operator; 58, 59; 59, call; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:elem; 63, identifier:tail; 64, identifier:strip; 65, argument_list; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:elem; 71, identifier:tail; 72, identifier:i; 73, for_statement; 73, 74; 73, 75; 73, 76; 74, identifier:elem; 75, identifier:elem; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:indent; 80, argument_list; 80, 81; 80, 82; 81, identifier:elem; 82, binary_operator:+; 82, 83; 82, 84; 83, identifier:level; 84, integer:1; 85, if_statement; 85, 86; 85, 99; 86, boolean_operator:or; 86, 87; 86, 91; 87, not_operator; 87, 88; 88, attribute; 88, 89; 88, 90; 89, identifier:elem; 90, identifier:tail; 91, not_operator; 91, 92; 92, call; 92, 93; 92, 98; 93, attribute; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:elem; 96, identifier:tail; 97, identifier:strip; 98, argument_list; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:elem; 104, identifier:tail; 105, identifier:i; 106, else_clause; 106, 107; 107, block; 107, 108; 108, if_statement; 108, 109; 108, 125; 109, boolean_operator:and; 109, 110; 109, 111; 110, identifier:level; 111, parenthesized_expression; 111, 112; 112, boolean_operator:or; 112, 113; 112, 117; 113, not_operator; 113, 114; 114, attribute; 114, 115; 114, 116; 115, identifier:elem; 116, identifier:tail; 117, not_operator; 117, 118; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:elem; 122, identifier:tail; 123, identifier:strip; 124, argument_list; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:elem; 130, identifier:tail; 131, identifier:i; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:root; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:ET; 138, identifier:Element; 139, argument_list; 139, 140; 140, string:'metrics'; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:files; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:ET; 147, identifier:Element; 148, argument_list; 148, 149; 149, string:'files'; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:root; 154, identifier:append; 155, argument_list; 155, 156; 156, identifier:files; 157, for_statement; 157, 158; 157, 159; 157, 164; 158, identifier:key; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:file_metrics; 162, identifier:keys; 163, argument_list; 164, block; 164, 165; 164, 186; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:tmp_file; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:ET; 171, identifier:SubElement; 172, argument_list; 172, 173; 172, 174; 172, 175; 173, identifier:files; 174, string:"file"; 175, dictionary; 175, 176; 175, 179; 176, pair; 176, 177; 176, 178; 177, string:'name'; 178, identifier:key; 179, pair; 179, 180; 179, 181; 180, string:'language'; 181, subscript; 181, 182; 181, 185; 182, subscript; 182, 183; 182, 184; 183, identifier:file_metrics; 184, identifier:key; 185, string:'language'; 186, for_statement; 186, 187; 186, 188; 186, 195; 187, identifier:name; 188, call; 188, 189; 188, 194; 189, attribute; 189, 190; 189, 193; 190, subscript; 190, 191; 190, 192; 191, identifier:file_metrics; 192, identifier:key; 193, identifier:keys; 194, argument_list; 195, block; 195, 196; 195, 202; 196, if_statement; 196, 197; 196, 200; 197, comparison_operator:==; 197, 198; 197, 199; 198, identifier:name; 199, string:'language'; 200, block; 200, 201; 201, continue_statement; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:tmp_metric; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:ET; 208, identifier:SubElement; 209, argument_list; 209, 210; 209, 211; 209, 212; 210, identifier:tmp_file; 211, string:"metric"; 212, dictionary; 212, 213; 212, 216; 213, pair; 213, 214; 213, 215; 214, string:'name'; 215, identifier:name; 216, pair; 216, 217; 216, 218; 217, string:'value'; 218, call; 218, 219; 218, 220; 219, identifier:str; 220, argument_list; 220, 221; 221, subscript; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:file_metrics; 224, identifier:key; 225, identifier:name; 226, if_statement; 226, 227; 226, 228; 227, identifier:build_metrics; 228, block; 228, 229; 228, 238; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:build; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:ET; 235, identifier:Element; 236, argument_list; 236, 237; 237, string:'build'; 238, expression_statement; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:root; 242, identifier:append; 243, argument_list; 243, 244; 244, identifier:build; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 248; 247, identifier:indent; 248, argument_list; 248, 249; 249, identifier:root; 250, if_statement; 250, 251; 250, 252; 250, 265; 251, identifier:PY3; 252, block; 252, 253; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:body; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:ET; 259, identifier:tostring; 260, argument_list; 260, 261; 260, 262; 261, identifier:root; 262, keyword_argument; 262, 263; 262, 264; 263, identifier:encoding; 264, string:'unicode'; 265, else_clause; 265, 266; 266, block; 266, 267; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:body; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:ET; 273, identifier:tostring; 274, argument_list; 274, 275; 275, identifier:root; 276, return_statement; 276, 277; 277, identifier:body | def format(file_metrics, build_metrics):
def indent(elem, level=0):
i = "\n" + level*" "
if len(elem):
if not elem.text or not elem.text.strip():
elem.text = i + " "
if not elem.tail or not elem.tail.strip():
elem.tail = i
for elem in elem:
indent(elem, level+1)
if not elem.tail or not elem.tail.strip():
elem.tail = i
else:
if level and (not elem.tail or not elem.tail.strip()):
elem.tail = i
root = ET.Element('metrics')
files = ET.Element('files')
root.append(files)
for key in file_metrics.keys():
tmp_file = ET.SubElement(files, "file",
{'name': key, 'language': file_metrics[key]['language']})
for name in file_metrics[key].keys():
if name == 'language':
continue
tmp_metric = ET.SubElement(tmp_file, "metric",
{'name': name, 'value': str(file_metrics[key][name])})
if build_metrics:
build = ET.Element('build')
root.append(build)
indent(root)
if PY3:
body = ET.tostring(root, encoding='unicode')
else:
body = ET.tostring(root)
return body |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:governor; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:Xgov; 6, identifier:Pgov; 7, identifier:Vgov; 8, block; 8, 9; 8, 15; 8, 25; 8, 34; 8, 52; 8, 70; 8, 77; 8, 84; 8, 91; 8, 98; 8, 105; 8, 112; 8, 119; 8, 126; 8, 133; 8, 140; 8, 147; 8, 154; 8, 161; 8, 168; 8, 175; 8, 199; 8, 216; 8, 229; 8, 233; 8, 269; 8, 305; 8, 309; 8, 313; 8, 349; 8, 385; 8, 398; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:governors; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:governors; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:omegas; 18, binary_operator:*; 18, 19; 18, 22; 19, binary_operator:*; 19, 20; 19, 21; 20, integer:2; 21, identifier:pi; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:freq; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:F; 28, call; 28, 29; 28, 30; 29, identifier:zeros; 30, argument_list; 30, 31; 31, attribute; 31, 32; 31, 33; 32, identifier:Xgov; 33, identifier:shape; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:typ1; 37, list_comprehension; 37, 38; 37, 43; 37, 46; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:g; 41, identifier:generator; 42, identifier:_i; 43, for_in_clause; 43, 44; 43, 45; 44, identifier:g; 45, identifier:governors; 46, if_clause; 46, 47; 47, comparison_operator:==; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:g; 50, identifier:model; 51, identifier:CONST_POWER; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:typ2; 55, list_comprehension; 55, 56; 55, 61; 55, 64; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:g; 59, identifier:generator; 60, identifier:_i; 61, for_in_clause; 61, 62; 61, 63; 62, identifier:g; 63, identifier:governors; 64, if_clause; 64, 65; 65, comparison_operator:==; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:g; 68, identifier:model; 69, identifier:GENERAL_IEEE; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 76; 72, subscript; 72, 73; 72, 74; 72, 75; 73, identifier:F; 74, identifier:typ1; 75, integer:0; 76, integer:0; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:Pm; 80, subscript; 80, 81; 80, 82; 80, 83; 81, identifier:Xgov; 82, identifier:typ2; 83, integer:0; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:P; 87, subscript; 87, 88; 87, 89; 87, 90; 88, identifier:Xgov; 89, identifier:typ2; 90, integer:1; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:x; 94, subscript; 94, 95; 94, 96; 94, 97; 95, identifier:Xgov; 96, identifier:typ2; 97, integer:2; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:z; 101, subscript; 101, 102; 101, 103; 101, 104; 102, identifier:Xgov; 103, identifier:typ2; 104, integer:3; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:K; 108, subscript; 108, 109; 108, 110; 108, 111; 109, identifier:Pgov; 110, identifier:typ2; 111, integer:0; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:T1; 115, subscript; 115, 116; 115, 117; 115, 118; 116, identifier:Pgov; 117, identifier:typ2; 118, integer:1; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:T2; 122, subscript; 122, 123; 122, 124; 122, 125; 123, identifier:Pgov; 124, identifier:typ2; 125, integer:2; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:T3; 129, subscript; 129, 130; 129, 131; 129, 132; 130, identifier:Pgov; 131, identifier:typ2; 132, integer:3; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:Pup; 136, subscript; 136, 137; 136, 138; 136, 139; 137, identifier:Pgov; 138, identifier:typ2; 139, integer:4; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:Pdown; 143, subscript; 143, 144; 143, 145; 143, 146; 144, identifier:Pgov; 145, identifier:typ2; 146, integer:5; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:Pmax; 150, subscript; 150, 151; 150, 152; 150, 153; 151, identifier:Pgov; 152, identifier:typ2; 153, integer:6; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:Pmin; 157, subscript; 157, 158; 157, 159; 157, 160; 158, identifier:Pgov; 159, identifier:typ2; 160, integer:7; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:P0; 164, subscript; 164, 165; 164, 166; 164, 167; 165, identifier:Pgov; 166, identifier:typ2; 167, integer:8; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:omega; 171, subscript; 171, 172; 171, 173; 171, 174; 172, identifier:Vgov; 173, identifier:typ2; 174, integer:0; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:dx; 178, binary_operator:*; 178, 179; 178, 180; 179, identifier:K; 180, parenthesized_expression; 180, 181; 181, binary_operator:+; 181, 182; 181, 188; 182, binary_operator:*; 182, 183; 182, 187; 183, binary_operator:/; 183, 184; 183, 186; 184, unary_operator:-; 184, 185; 185, integer:1; 186, identifier:T1; 187, identifier:x; 188, binary_operator:*; 188, 189; 188, 195; 189, parenthesized_expression; 189, 190; 190, binary_operator:-; 190, 191; 190, 192; 191, integer:1; 192, binary_operator:/; 192, 193; 192, 194; 193, identifier:T2; 194, identifier:T1; 195, parenthesized_expression; 195, 196; 196, binary_operator:-; 196, 197; 196, 198; 197, identifier:omega; 198, identifier:omegas; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:dP; 202, binary_operator:+; 202, 203; 202, 208; 203, binary_operator:*; 203, 204; 203, 207; 204, binary_operator:/; 204, 205; 204, 206; 205, integer:1; 206, identifier:T1; 207, identifier:x; 208, binary_operator:*; 208, 209; 208, 212; 209, binary_operator:/; 209, 210; 209, 211; 210, identifier:T2; 211, identifier:T1; 212, parenthesized_expression; 212, 213; 213, binary_operator:-; 213, 214; 213, 215; 214, identifier:omega; 215, identifier:omegas; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:y; 219, binary_operator:*; 219, 220; 219, 223; 220, binary_operator:/; 220, 221; 220, 222; 221, integer:1; 222, identifier:T3; 223, parenthesized_expression; 223, 224; 224, binary_operator:-; 224, 225; 224, 228; 225, binary_operator:-; 225, 226; 225, 227; 226, identifier:P0; 227, identifier:P; 228, identifier:Pm; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:y2; 232, identifier:y; 233, if_statement; 233, 234; 233, 245; 234, comparison_operator:>=; 234, 235; 234, 244; 235, call; 235, 236; 235, 237; 236, identifier:sum; 237, argument_list; 237, 238; 238, call; 238, 239; 238, 240; 239, identifier:flatnonzero; 240, argument_list; 240, 241; 241, comparison_operator:>; 241, 242; 241, 243; 242, identifier:y; 243, identifier:Pup; 244, integer:1; 245, block; 245, 246; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:y2; 249, binary_operator:+; 249, 250; 249, 261; 250, binary_operator:*; 250, 251; 250, 260; 251, parenthesized_expression; 251, 252; 252, binary_operator:-; 252, 253; 252, 254; 253, integer:1; 254, call; 254, 255; 254, 256; 255, identifier:flatnonzero; 256, argument_list; 256, 257; 257, comparison_operator:>; 257, 258; 257, 259; 258, identifier:y; 259, identifier:Pup; 260, identifier:y2; 261, binary_operator:*; 261, 262; 261, 268; 262, call; 262, 263; 262, 264; 263, identifier:flatnonzero; 264, argument_list; 264, 265; 265, comparison_operator:>; 265, 266; 265, 267; 266, identifier:y; 267, identifier:Pup; 268, identifier:Pup; 269, if_statement; 269, 270; 269, 281; 270, comparison_operator:>=; 270, 271; 270, 280; 271, call; 271, 272; 271, 273; 272, identifier:sum; 273, argument_list; 273, 274; 274, call; 274, 275; 274, 276; 275, identifier:flatnonzero; 276, argument_list; 276, 277; 277, comparison_operator:<; 277, 278; 277, 279; 278, identifier:y; 279, identifier:Pdown; 280, integer:1; 281, block; 281, 282; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 285; 284, identifier:y2; 285, binary_operator:+; 285, 286; 285, 297; 286, binary_operator:*; 286, 287; 286, 296; 287, parenthesized_expression; 287, 288; 288, binary_operator:-; 288, 289; 288, 290; 289, integer:1; 290, call; 290, 291; 290, 292; 291, identifier:flatnonzero; 292, argument_list; 292, 293; 293, comparison_operator:<; 293, 294; 293, 295; 294, identifier:y; 295, identifier:Pdown; 296, identifier:y2; 297, binary_operator:*; 297, 298; 297, 304; 298, call; 298, 299; 298, 300; 299, identifier:flatnonzero; 300, argument_list; 300, 301; 301, comparison_operator:<; 301, 302; 301, 303; 302, identifier:y; 303, identifier:Pdown; 304, identifier:Pdown; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:dz; 308, identifier:y2; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 312; 311, identifier:dPm; 312, identifier:y2; 313, if_statement; 313, 314; 313, 325; 314, comparison_operator:>=; 314, 315; 314, 324; 315, call; 315, 316; 315, 317; 316, identifier:sum; 317, argument_list; 317, 318; 318, call; 318, 319; 318, 320; 319, identifier:flatnonzero; 320, argument_list; 320, 321; 321, comparison_operator:>; 321, 322; 321, 323; 322, identifier:z; 323, identifier:Pmax; 324, integer:1; 325, block; 325, 326; 326, expression_statement; 326, 327; 327, assignment; 327, 328; 327, 329; 328, identifier:dPm; 329, binary_operator:+; 329, 330; 329, 341; 330, binary_operator:*; 330, 331; 330, 340; 331, parenthesized_expression; 331, 332; 332, binary_operator:-; 332, 333; 332, 334; 333, integer:1; 334, call; 334, 335; 334, 336; 335, identifier:flatnonzero; 336, argument_list; 336, 337; 337, comparison_operator:>; 337, 338; 337, 339; 338, identifier:z; 339, identifier:Pmax; 340, identifier:dPm; 341, binary_operator:*; 341, 342; 341, 348; 342, call; 342, 343; 342, 344; 343, identifier:flatnonzero; 344, argument_list; 344, 345; 345, comparison_operator:>; 345, 346; 345, 347; 346, identifier:z; 347, identifier:Pmax; 348, integer:0; 349, if_statement; 349, 350; 349, 361; 350, comparison_operator:>=; 350, 351; 350, 360; 351, call; 351, 352; 351, 353; 352, identifier:sum; 353, argument_list; 353, 354; 354, call; 354, 355; 354, 356; 355, identifier:flatnonzero; 356, argument_list; 356, 357; 357, comparison_operator:<; 357, 358; 357, 359; 358, identifier:z; 359, identifier:Pmin; 360, integer:1; 361, block; 361, 362; 362, expression_statement; 362, 363; 363, assignment; 363, 364; 363, 365; 364, identifier:dPm; 365, binary_operator:+; 365, 366; 365, 377; 366, binary_operator:*; 366, 367; 366, 376; 367, parenthesized_expression; 367, 368; 368, binary_operator:-; 368, 369; 368, 370; 369, integer:1; 370, call; 370, 371; 370, 372; 371, identifier:flatnonzero; 372, argument_list; 372, 373; 373, comparison_operator:<; 373, 374; 373, 375; 374, identifier:z; 375, identifier:Pmin; 376, identifier:dPm; 377, binary_operator:*; 377, 378; 377, 384; 378, call; 378, 379; 378, 380; 379, identifier:flatnonzero; 380, argument_list; 380, 381; 381, comparison_operator:<; 381, 382; 381, 383; 382, identifier:z; 383, identifier:Pmin; 384, integer:0; 385, expression_statement; 385, 386; 386, assignment; 386, 387; 386, 392; 387, subscript; 387, 388; 387, 389; 387, 390; 388, identifier:F; 389, identifier:typ2; 390, slice; 390, 391; 391, colon; 392, subscript; 392, 393; 392, 394; 392, 395; 392, 396; 392, 397; 393, identifier:c_; 394, identifier:dPm; 395, identifier:dP; 396, identifier:dx; 397, identifier:dz; 398, return_statement; 398, 399; 399, identifier:F | def governor(self, Xgov, Pgov, Vgov):
governors = self.governors
omegas = 2 * pi * self.freq
F = zeros(Xgov.shape)
typ1 = [g.generator._i for g in governors if g.model == CONST_POWER]
typ2 = [g.generator._i for g in governors if g.model == GENERAL_IEEE]
F[typ1, 0] = 0
Pm = Xgov[typ2, 0]
P = Xgov[typ2, 1]
x = Xgov[typ2, 2]
z = Xgov[typ2, 3]
K = Pgov[typ2, 0]
T1 = Pgov[typ2, 1]
T2 = Pgov[typ2, 2]
T3 = Pgov[typ2, 3]
Pup = Pgov[typ2, 4]
Pdown = Pgov[typ2, 5]
Pmax = Pgov[typ2, 6]
Pmin = Pgov[typ2, 7]
P0 = Pgov[typ2, 8]
omega = Vgov[typ2, 0]
dx = K * (-1 / T1 * x + (1 - T2 / T1) * (omega - omegas))
dP = 1 / T1 * x + T2 / T1 * (omega - omegas)
y = 1 / T3 * (P0 - P - Pm)
y2 = y
if sum(flatnonzero(y > Pup)) >= 1:
y2 = (1 - flatnonzero(y > Pup)) * y2 + flatnonzero(y > Pup) * Pup
if sum(flatnonzero(y < Pdown)) >= 1:
y2 = (1 - flatnonzero(y<Pdown)) * y2 + flatnonzero(y<Pdown) * Pdown
dz = y2
dPm = y2
if sum(flatnonzero(z > Pmax)) >= 1:
dPm = (1 - flatnonzero(z > Pmax)) * dPm + flatnonzero(z > Pmax) * 0
if sum(flatnonzero(z < Pmin)) >= 1:
dPm = (1 - flatnonzero(z < Pmin)) * dPm + flatnonzero(z < Pmin) * 0
F[typ2, :] = c_[dPm, dP, dx, dz]
return F |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:generator; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:Xgen; 6, identifier:Xexc; 7, identifier:Xgov; 8, identifier:Vgen; 9, block; 9, 10; 9, 16; 9, 26; 9, 35; 9, 51; 9, 67; 9, 74; 9, 81; 9, 96; 9, 111; 9, 118; 9, 124; 9, 147; 9, 157; 9, 169; 9, 176; 9, 183; 9, 190; 9, 203; 9, 216; 9, 229; 9, 242; 9, 255; 9, 268; 9, 281; 9, 294; 9, 301; 9, 308; 9, 315; 9, 322; 9, 329; 9, 335; 9, 358; 9, 376; 9, 393; 9, 406; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:generators; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:dyn_generators; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:omegas; 19, binary_operator:*; 19, 20; 19, 23; 20, binary_operator:*; 20, 21; 20, 22; 21, integer:2; 22, identifier:pi; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:freq; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:F; 29, call; 29, 30; 29, 31; 30, identifier:zeros; 31, argument_list; 31, 32; 32, attribute; 32, 33; 32, 34; 33, identifier:Xgen; 34, identifier:shape; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:typ1; 38, list_comprehension; 38, 39; 38, 42; 38, 45; 39, attribute; 39, 40; 39, 41; 40, identifier:g; 41, identifier:_i; 42, for_in_clause; 42, 43; 42, 44; 43, identifier:g; 44, identifier:generators; 45, if_clause; 45, 46; 46, comparison_operator:==; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:g; 49, identifier:model; 50, identifier:CLASSICAL; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:typ2; 54, list_comprehension; 54, 55; 54, 58; 54, 61; 55, attribute; 55, 56; 55, 57; 56, identifier:g; 57, identifier:_i; 58, for_in_clause; 58, 59; 58, 60; 59, identifier:g; 60, identifier:generators; 61, if_clause; 61, 62; 62, comparison_operator:==; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:g; 65, identifier:model; 66, identifier:FOURTH_ORDER; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:omega; 70, subscript; 70, 71; 70, 72; 70, 73; 71, identifier:Xgen; 72, identifier:typ1; 73, integer:1; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:Pm0; 77, subscript; 77, 78; 77, 79; 77, 80; 78, identifier:Xgov; 79, identifier:typ1; 80, integer:0; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:H; 84, subscript; 84, 85; 84, 95; 85, call; 85, 86; 85, 87; 86, identifier:array; 87, argument_list; 87, 88; 88, list_comprehension; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:g; 91, identifier:h; 92, for_in_clause; 92, 93; 92, 94; 93, identifier:g; 94, identifier:generators; 95, identifier:typ1; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:D; 99, subscript; 99, 100; 99, 110; 100, call; 100, 101; 100, 102; 101, identifier:array; 102, argument_list; 102, 103; 103, list_comprehension; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:g; 106, identifier:d; 107, for_in_clause; 107, 108; 107, 109; 108, identifier:g; 109, identifier:generators; 110, identifier:typ1; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:Pe; 114, subscript; 114, 115; 114, 116; 114, 117; 115, identifier:Vgen; 116, identifier:typ1; 117, integer:2; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:ddelta; 121, assignment; 121, 122; 121, 123; 122, identifier:omega; 123, identifier:omegas; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:domega; 127, binary_operator:*; 127, 128; 127, 135; 128, binary_operator:/; 128, 129; 128, 134; 129, binary_operator:*; 129, 130; 129, 131; 130, identifier:pi; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:freq; 134, identifier:H; 135, parenthesized_expression; 135, 136; 136, binary_operator:-; 136, 137; 136, 146; 137, binary_operator:+; 137, 138; 137, 145; 138, binary_operator:*; 138, 139; 138, 141; 139, unary_operator:-; 139, 140; 140, identifier:D; 141, parenthesized_expression; 141, 142; 142, binary_operator:-; 142, 143; 142, 144; 143, identifier:omega; 144, identifier:omegas; 145, identifier:Pm0; 146, identifier:Pe; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:dEq; 150, call; 150, 151; 150, 152; 151, identifier:zeros; 152, argument_list; 152, 153; 153, call; 153, 154; 153, 155; 154, identifier:len; 155, argument_list; 155, 156; 156, identifier:typ1; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 164; 159, subscript; 159, 160; 159, 161; 159, 162; 160, identifier:F; 161, identifier:typ1; 162, slice; 162, 163; 163, colon; 164, subscript; 164, 165; 164, 166; 164, 167; 164, 168; 165, identifier:c_; 166, identifier:ddelta; 167, identifier:domega; 168, identifier:dEq; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:omega; 172, subscript; 172, 173; 172, 174; 172, 175; 173, identifier:Xgen; 174, identifier:typ2; 175, integer:1; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:Eq_tr; 179, subscript; 179, 180; 179, 181; 179, 182; 180, identifier:Xgen; 181, identifier:typ2; 182, integer:2; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:Ed_tr; 186, subscript; 186, 187; 186, 188; 186, 189; 187, identifier:Xgen; 188, identifier:typ2; 189, integer:3; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:H; 193, call; 193, 194; 193, 195; 194, identifier:array; 195, argument_list; 195, 196; 196, list_comprehension; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:g; 199, identifier:h; 200, for_in_clause; 200, 201; 200, 202; 201, identifier:g; 202, identifier:generators; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:D; 206, call; 206, 207; 206, 208; 207, identifier:array; 208, argument_list; 208, 209; 209, list_comprehension; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:g; 212, identifier:d; 213, for_in_clause; 213, 214; 213, 215; 214, identifier:g; 215, identifier:generators; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:xd; 219, call; 219, 220; 219, 221; 220, identifier:array; 221, argument_list; 221, 222; 222, list_comprehension; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:g; 225, identifier:xd; 226, for_in_clause; 226, 227; 226, 228; 227, identifier:g; 228, identifier:generators; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:xq; 232, call; 232, 233; 232, 234; 233, identifier:array; 234, argument_list; 234, 235; 235, list_comprehension; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:g; 238, identifier:xq; 239, for_in_clause; 239, 240; 239, 241; 240, identifier:g; 241, identifier:generators; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:xd_tr; 245, call; 245, 246; 245, 247; 246, identifier:array; 247, argument_list; 247, 248; 248, list_comprehension; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:g; 251, identifier:xd_tr; 252, for_in_clause; 252, 253; 252, 254; 253, identifier:g; 254, identifier:generators; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:xq_tr; 258, call; 258, 259; 258, 260; 259, identifier:array; 260, argument_list; 260, 261; 261, list_comprehension; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:g; 264, identifier:xq_tr; 265, for_in_clause; 265, 266; 265, 267; 266, identifier:g; 267, identifier:generators; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:Td0_tr; 271, call; 271, 272; 271, 273; 272, identifier:array; 273, argument_list; 273, 274; 274, list_comprehension; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:g; 277, identifier:td; 278, for_in_clause; 278, 279; 278, 280; 279, identifier:g; 280, identifier:generators; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:Tq0_tr; 284, call; 284, 285; 284, 286; 285, identifier:array; 286, argument_list; 286, 287; 287, list_comprehension; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:g; 290, identifier:tq; 291, for_in_clause; 291, 292; 291, 293; 292, identifier:g; 293, identifier:generators; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:Id; 297, subscript; 297, 298; 297, 299; 297, 300; 298, identifier:Vgen; 299, identifier:typ2; 300, integer:0; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:Iq; 304, subscript; 304, 305; 304, 306; 304, 307; 305, identifier:Vgen; 306, identifier:typ2; 307, integer:1; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 311; 310, identifier:Pe; 311, subscript; 311, 312; 311, 313; 311, 314; 312, identifier:Vgen; 313, identifier:typ2; 314, integer:2; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 318; 317, identifier:Efd; 318, subscript; 318, 319; 318, 320; 318, 321; 319, identifier:Xexc; 320, identifier:typ2; 321, integer:0; 322, expression_statement; 322, 323; 323, assignment; 323, 324; 323, 325; 324, identifier:Pm; 325, subscript; 325, 326; 325, 327; 325, 328; 326, identifier:Xgov; 327, identifier:typ2; 328, integer:0; 329, expression_statement; 329, 330; 330, assignment; 330, 331; 330, 332; 331, identifier:ddelta; 332, binary_operator:-; 332, 333; 332, 334; 333, identifier:omega; 334, identifier:omegas; 335, expression_statement; 335, 336; 336, assignment; 336, 337; 336, 338; 337, identifier:domega; 338, binary_operator:*; 338, 339; 338, 346; 339, binary_operator:/; 339, 340; 339, 345; 340, binary_operator:*; 340, 341; 340, 342; 341, identifier:pi; 342, attribute; 342, 343; 342, 344; 343, identifier:self; 344, identifier:freq; 345, identifier:H; 346, parenthesized_expression; 346, 347; 347, binary_operator:-; 347, 348; 347, 357; 348, binary_operator:+; 348, 349; 348, 356; 349, binary_operator:*; 349, 350; 349, 352; 350, unary_operator:-; 350, 351; 351, identifier:D; 352, parenthesized_expression; 352, 353; 353, binary_operator:-; 353, 354; 353, 355; 354, identifier:omega; 355, identifier:omegas; 356, identifier:Pm; 357, identifier:Pe; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 361; 360, identifier:dEq; 361, binary_operator:*; 361, 362; 361, 365; 362, binary_operator:/; 362, 363; 362, 364; 363, integer:1; 364, identifier:Td0_tr; 365, parenthesized_expression; 365, 366; 366, binary_operator:+; 366, 367; 366, 370; 367, binary_operator:-; 367, 368; 367, 369; 368, identifier:Efd; 369, identifier:Eq_tr; 370, binary_operator:*; 370, 371; 370, 375; 371, parenthesized_expression; 371, 372; 372, binary_operator:-; 372, 373; 372, 374; 373, identifier:xd; 374, identifier:xd_tr; 375, identifier:Id; 376, expression_statement; 376, 377; 377, assignment; 377, 378; 377, 379; 378, identifier:dEd; 379, binary_operator:*; 379, 380; 379, 383; 380, binary_operator:/; 380, 381; 380, 382; 381, integer:1; 382, identifier:Tq0_tr; 383, parenthesized_expression; 383, 384; 384, binary_operator:-; 384, 385; 384, 387; 385, unary_operator:-; 385, 386; 386, identifier:Ed_tr; 387, binary_operator:*; 387, 388; 387, 392; 388, parenthesized_expression; 388, 389; 389, binary_operator:-; 389, 390; 389, 391; 390, identifier:xq; 391, identifier:xq_tr; 392, identifier:Iq; 393, expression_statement; 393, 394; 394, assignment; 394, 395; 394, 400; 395, subscript; 395, 396; 395, 397; 395, 398; 396, identifier:F; 397, identifier:typ2; 398, slice; 398, 399; 399, colon; 400, subscript; 400, 401; 400, 402; 400, 403; 400, 404; 400, 405; 401, identifier:c_; 402, identifier:ddelta; 403, identifier:domega; 404, identifier:dEq; 405, identifier:dEd; 406, return_statement; 406, 407; 407, identifier:F | def generator(self, Xgen, Xexc, Xgov, Vgen):
generators = self.dyn_generators
omegas = 2 * pi * self.freq
F = zeros(Xgen.shape)
typ1 = [g._i for g in generators if g.model == CLASSICAL]
typ2 = [g._i for g in generators if g.model == FOURTH_ORDER]
omega = Xgen[typ1, 1]
Pm0 = Xgov[typ1, 0]
H = array([g.h for g in generators])[typ1]
D = array([g.d for g in generators])[typ1]
Pe = Vgen[typ1, 2]
ddelta = omega = omegas
domega = pi * self.freq / H * (-D * (omega - omegas) + Pm0 - Pe)
dEq = zeros(len(typ1))
F[typ1, :] = c_[ddelta, domega, dEq]
omega = Xgen[typ2, 1]
Eq_tr = Xgen[typ2, 2]
Ed_tr = Xgen[typ2, 3]
H = array([g.h for g in generators])
D = array([g.d for g in generators])
xd = array([g.xd for g in generators])
xq = array([g.xq for g in generators])
xd_tr = array([g.xd_tr for g in generators])
xq_tr = array([g.xq_tr for g in generators])
Td0_tr = array([g.td for g in generators])
Tq0_tr = array([g.tq for g in generators])
Id = Vgen[typ2, 0]
Iq = Vgen[typ2, 1]
Pe = Vgen[typ2, 2]
Efd = Xexc[typ2, 0]
Pm = Xgov[typ2, 0]
ddelta = omega - omegas
domega = pi * self.freq / H * (-D * (omega - omegas) + Pm - Pe)
dEq = 1 / Td0_tr * (Efd - Eq_tr + (xd - xd_tr) * Id)
dEd = 1 / Tq0_tr * (-Ed_tr - (xq - xq_tr) * Iq)
F[typ2, :] = c_[ddelta, domega, dEq, dEd]
return F |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_const_pf_constraints; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:gn; 6, identifier:base_mva; 7, block; 7, 8; 7, 41; 7, 51; 7, 58; 7, 65; 7, 80; 7, 95; 7, 110; 7, 125; 7, 140; 7, 166; 7, 182; 7, 209; 7, 325; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:ivl; 11, call; 11, 12; 11, 13; 12, identifier:array; 13, argument_list; 13, 14; 14, list_comprehension; 14, 15; 14, 16; 14, 24; 15, identifier:i; 16, for_in_clause; 16, 17; 16, 20; 17, pattern_list; 17, 18; 17, 19; 18, identifier:i; 19, identifier:g; 20, call; 20, 21; 20, 22; 21, identifier:enumerate; 22, argument_list; 22, 23; 23, identifier:gn; 24, if_clause; 24, 25; 25, boolean_operator:and; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:g; 28, identifier:is_load; 29, parenthesized_expression; 29, 30; 30, boolean_operator:or; 30, 31; 30, 36; 31, comparison_operator:!=; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:g; 34, identifier:q_min; 35, float:0.0; 36, comparison_operator:!=; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:g; 39, identifier:q_max; 40, float:0.0; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:vl; 44, list_comprehension; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:gn; 47, identifier:i; 48, for_in_clause; 48, 49; 48, 50; 49, identifier:i; 50, identifier:ivl; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:nvl; 54, call; 54, 55; 54, 56; 55, identifier:len; 56, argument_list; 56, 57; 57, identifier:vl; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:ng; 61, call; 61, 62; 61, 63; 62, identifier:len; 63, argument_list; 63, 64; 64, identifier:gn; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:Pg; 68, binary_operator:/; 68, 69; 68, 79; 69, call; 69, 70; 69, 71; 70, identifier:array; 71, argument_list; 71, 72; 72, list_comprehension; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:g; 75, identifier:p; 76, for_in_clause; 76, 77; 76, 78; 77, identifier:g; 78, identifier:vl; 79, identifier:base_mva; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:Qg; 83, binary_operator:/; 83, 84; 83, 94; 84, call; 84, 85; 84, 86; 85, identifier:array; 86, argument_list; 86, 87; 87, list_comprehension; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:g; 90, identifier:q; 91, for_in_clause; 91, 92; 91, 93; 92, identifier:g; 93, identifier:vl; 94, identifier:base_mva; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:Pmin; 98, binary_operator:/; 98, 99; 98, 109; 99, call; 99, 100; 99, 101; 100, identifier:array; 101, argument_list; 101, 102; 102, list_comprehension; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:g; 105, identifier:p_min; 106, for_in_clause; 106, 107; 106, 108; 107, identifier:g; 108, identifier:vl; 109, identifier:base_mva; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:Qmin; 113, binary_operator:/; 113, 114; 113, 124; 114, call; 114, 115; 114, 116; 115, identifier:array; 116, argument_list; 116, 117; 117, list_comprehension; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:g; 120, identifier:q_min; 121, for_in_clause; 121, 122; 121, 123; 122, identifier:g; 123, identifier:vl; 124, identifier:base_mva; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:Qmax; 128, binary_operator:/; 128, 129; 128, 139; 129, call; 129, 130; 129, 131; 130, identifier:array; 131, argument_list; 131, 132; 132, list_comprehension; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:g; 135, identifier:q_max; 136, for_in_clause; 136, 137; 136, 138; 137, identifier:g; 138, identifier:vl; 139, identifier:base_mva; 140, for_statement; 140, 141; 140, 142; 140, 143; 141, identifier:g; 142, identifier:vl; 143, block; 143, 144; 144, if_statement; 144, 145; 144, 156; 145, boolean_operator:and; 145, 146; 145, 151; 146, comparison_operator:!=; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:g; 149, identifier:qmin; 150, float:0.0; 151, comparison_operator:!=; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:g; 154, identifier:q_max; 155, float:0.0; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:logger; 161, identifier:error; 162, argument_list; 162, 163; 163, concatenated_string; 163, 164; 163, 165; 164, string:"Either Qmin or Qmax must be equal to zero for "; 165, string:"each dispatchable load."; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:Qlim; 169, binary_operator:+; 169, 170; 169, 176; 170, binary_operator:*; 170, 171; 170, 175; 171, parenthesized_expression; 171, 172; 172, comparison_operator:==; 172, 173; 172, 174; 173, identifier:Qmin; 174, float:0.0; 175, identifier:Qmax; 176, binary_operator:*; 176, 177; 176, 181; 177, parenthesized_expression; 177, 178; 178, comparison_operator:==; 178, 179; 178, 180; 179, identifier:Qmax; 180, float:0.0; 181, identifier:Qmin; 182, if_statement; 182, 183; 182, 198; 183, call; 183, 184; 183, 185; 184, identifier:any; 185, argument_list; 185, 186; 186, comparison_operator:>; 186, 187; 186, 197; 187, call; 187, 188; 187, 189; 188, identifier:abs; 189, argument_list; 189, 190; 190, binary_operator:-; 190, 191; 190, 192; 191, identifier:Qg; 192, binary_operator:/; 192, 193; 192, 196; 193, binary_operator:*; 193, 194; 193, 195; 194, identifier:Pg; 195, identifier:Qlim; 196, identifier:Pmin; 197, float:1e-6; 198, block; 198, 199; 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, concatenated_string; 205, 206; 205, 207; 205, 208; 206, string:"For a dispatchable load, PG and QG must be "; 207, string:"consistent with the power factor defined by "; 208, string:"PMIN and the Q limits."; 209, if_statement; 209, 210; 209, 213; 209, 298; 210, comparison_operator:>; 210, 211; 210, 212; 211, identifier:nvl; 212, integer:0; 213, block; 213, 214; 213, 218; 213, 222; 213, 230; 213, 237; 213, 245; 213, 260; 213, 269; 213, 287; 213, 294; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:xx; 217, identifier:Pmin; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:yy; 221, identifier:Qlim; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:pftheta; 225, call; 225, 226; 225, 227; 226, identifier:arctan2; 227, argument_list; 227, 228; 227, 229; 228, identifier:yy; 229, identifier:xx; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:pc; 233, call; 233, 234; 233, 235; 234, identifier:sin; 235, argument_list; 235, 236; 236, identifier:pftheta; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:qc; 240, unary_operator:-; 240, 241; 241, call; 241, 242; 241, 243; 242, identifier:cos; 243, argument_list; 243, 244; 244, identifier:pftheta; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:ii; 248, call; 248, 249; 248, 250; 249, identifier:array; 250, argument_list; 250, 251; 251, list:[range(nvl), range(nvl)]; 251, 252; 251, 256; 252, call; 252, 253; 252, 254; 253, identifier:range; 254, argument_list; 254, 255; 255, identifier:nvl; 256, call; 256, 257; 256, 258; 257, identifier:range; 258, argument_list; 258, 259; 259, identifier:nvl; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:jj; 263, subscript; 263, 264; 263, 265; 263, 266; 264, identifier:r_; 265, identifier:ivl; 266, binary_operator:+; 266, 267; 266, 268; 267, identifier:ivl; 268, identifier:ng; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:Avl; 272, call; 272, 273; 272, 274; 273, identifier:csr_matrix; 274, argument_list; 274, 275; 274, 279; 274, 282; 275, subscript; 275, 276; 275, 277; 275, 278; 276, identifier:r_; 277, identifier:pc; 278, identifier:qc; 279, tuple; 279, 280; 279, 281; 280, identifier:ii; 281, identifier:jj; 282, tuple; 282, 283; 282, 284; 283, identifier:nvl; 284, binary_operator:*; 284, 285; 284, 286; 285, integer:2; 286, identifier:ng; 287, expression_statement; 287, 288; 288, assignment; 288, 289; 288, 290; 289, identifier:lvl; 290, call; 290, 291; 290, 292; 291, identifier:zeros; 292, argument_list; 292, 293; 293, identifier:nvl; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:uvl; 297, identifier:lvl; 298, else_clause; 298, 299; 299, block; 299, 300; 299, 311; 299, 318; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:Avl; 303, call; 303, 304; 303, 305; 304, identifier:zeros; 305, argument_list; 305, 306; 306, tuple; 306, 307; 306, 308; 307, integer:0; 308, binary_operator:*; 308, 309; 308, 310; 309, integer:2; 310, identifier:ng; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:lvl; 314, call; 314, 315; 314, 316; 315, identifier:array; 316, argument_list; 316, 317; 317, list:[]; 318, expression_statement; 318, 319; 319, assignment; 319, 320; 319, 321; 320, identifier:uvl; 321, call; 321, 322; 321, 323; 322, identifier:array; 323, argument_list; 323, 324; 324, list:[]; 325, return_statement; 325, 326; 326, call; 326, 327; 326, 328; 327, identifier:LinearConstraint; 328, argument_list; 328, 329; 328, 330; 328, 331; 328, 332; 328, 333; 329, string:"vl"; 330, identifier:Avl; 331, identifier:lvl; 332, identifier:uvl; 333, list:["Pg", "Qg"]; 333, 334; 333, 335; 334, string:"Pg"; 335, string:"Qg" | def _const_pf_constraints(self, gn, base_mva):
ivl = array([i for i, g in enumerate(gn)
if g.is_load and (g.q_min != 0.0 or g.q_max != 0.0)])
vl = [gn[i] for i in ivl]
nvl = len(vl)
ng = len(gn)
Pg = array([g.p for g in vl]) / base_mva
Qg = array([g.q for g in vl]) / base_mva
Pmin = array([g.p_min for g in vl]) / base_mva
Qmin = array([g.q_min for g in vl]) / base_mva
Qmax = array([g.q_max for g in vl]) / base_mva
for g in vl:
if g.qmin != 0.0 and g.q_max != 0.0:
logger.error("Either Qmin or Qmax must be equal to zero for "
"each dispatchable load.")
Qlim = (Qmin == 0.0) * Qmax + (Qmax == 0.0) * Qmin
if any( abs(Qg - Pg * Qlim / Pmin) > 1e-6 ):
logger.error("For a dispatchable load, PG and QG must be "
"consistent with the power factor defined by "
"PMIN and the Q limits.")
if nvl > 0:
xx = Pmin
yy = Qlim
pftheta = arctan2(yy, xx)
pc = sin(pftheta)
qc = -cos(pftheta)
ii = array([range(nvl), range(nvl)])
jj = r_[ivl, ivl + ng]
Avl = csr_matrix(r_[pc, qc], (ii, jj), (nvl, 2 * ng))
lvl = zeros(nvl)
uvl = lvl
else:
Avl = zeros((0, 2 * ng))
lvl = array([])
uvl = array([])
return LinearConstraint("vl", Avl, lvl, uvl, ["Pg", "Qg"]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_voltage_angle_diff_limit; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:buses; 6, identifier:branches; 7, block; 7, 8; 7, 15; 7, 300; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:nb; 11, call; 11, 12; 11, 13; 12, identifier:len; 13, argument_list; 13, 14; 14, identifier:buses; 15, if_statement; 15, 16; 15, 20; 15, 275; 16, not_operator; 16, 17; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:ignore_ang_lim; 20, block; 20, 21; 20, 59; 20, 83; 20, 107; 20, 114; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:iang; 24, list_comprehension; 24, 25; 24, 26; 24, 34; 25, identifier:i; 26, for_in_clause; 26, 27; 26, 30; 27, pattern_list; 27, 28; 27, 29; 28, identifier:i; 29, identifier:b; 30, call; 30, 31; 30, 32; 31, identifier:enumerate; 32, argument_list; 32, 33; 33, identifier:branches; 34, if_clause; 34, 35; 35, boolean_operator:or; 35, 36; 35, 48; 36, parenthesized_expression; 36, 37; 37, boolean_operator:and; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:b; 40, identifier:ang_min; 41, parenthesized_expression; 41, 42; 42, comparison_operator:>; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:b; 45, identifier:ang_min; 46, unary_operator:-; 46, 47; 47, float:360.0; 48, parenthesized_expression; 48, 49; 49, boolean_operator:and; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:b; 52, identifier:ang_max; 53, parenthesized_expression; 53, 54; 54, comparison_operator:<; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:b; 57, identifier:ang_max; 58, float:360.0; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:iangl; 62, subscript; 62, 63; 62, 82; 63, call; 63, 64; 63, 65; 64, identifier:array; 65, argument_list; 65, 66; 66, list_comprehension; 66, 67; 66, 68; 66, 76; 67, identifier:i; 68, for_in_clause; 68, 69; 68, 72; 69, pattern_list; 69, 70; 69, 71; 70, identifier:i; 71, identifier:b; 72, call; 72, 73; 72, 74; 73, identifier:enumerate; 74, argument_list; 74, 75; 75, identifier:branches; 76, if_clause; 76, 77; 77, comparison_operator:is; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:b; 80, identifier:ang_min; 81, None; 82, identifier:iang; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:iangh; 86, subscript; 86, 87; 86, 106; 87, call; 87, 88; 87, 89; 88, identifier:array; 89, argument_list; 89, 90; 90, list_comprehension; 90, 91; 90, 92; 90, 100; 91, identifier:i; 92, for_in_clause; 92, 93; 92, 96; 93, pattern_list; 93, 94; 93, 95; 94, identifier:i; 95, identifier:b; 96, call; 96, 97; 96, 98; 97, identifier:enumerate; 98, argument_list; 98, 99; 99, identifier:branches; 100, if_clause; 100, 101; 101, comparison_operator:is; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:b; 104, identifier:ang_max; 105, None; 106, identifier:iang; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:nang; 110, call; 110, 111; 110, 112; 111, identifier:len; 112, argument_list; 112, 113; 113, identifier:iang; 114, if_statement; 114, 115; 114, 118; 114, 250; 115, comparison_operator:>; 115, 116; 115, 117; 116, identifier:nang; 117, integer:0; 118, block; 118, 119; 118, 131; 118, 148; 118, 165; 118, 172; 118, 192; 118, 201; 118, 206; 118, 228; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:ii; 122, binary_operator:+; 122, 123; 122, 127; 123, call; 123, 124; 123, 125; 124, identifier:range; 125, argument_list; 125, 126; 126, identifier:nang; 127, call; 127, 128; 127, 129; 128, identifier:range; 129, argument_list; 129, 130; 130, identifier:nang; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:jjf; 134, subscript; 134, 135; 134, 147; 135, call; 135, 136; 135, 137; 136, identifier:array; 137, argument_list; 137, 138; 138, list_comprehension; 138, 139; 138, 144; 139, attribute; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:b; 142, identifier:from_bus; 143, identifier:_i; 144, for_in_clause; 144, 145; 144, 146; 145, identifier:b; 146, identifier:branches; 147, identifier:iang; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:jjt; 151, subscript; 151, 152; 151, 164; 152, call; 152, 153; 152, 154; 153, identifier:array; 154, argument_list; 154, 155; 155, list_comprehension; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:b; 159, identifier:to_bus; 160, identifier:_i; 161, for_in_clause; 161, 162; 161, 163; 162, identifier:b; 163, identifier:branches; 164, identifier:iang; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:jj; 168, subscript; 168, 169; 168, 170; 168, 171; 169, identifier:r_; 170, identifier:jjf; 171, identifier:jjt; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:Aang; 175, call; 175, 176; 175, 177; 176, identifier:csr_matrix; 177, argument_list; 177, 178; 177, 189; 178, subscript; 178, 179; 178, 180; 178, 184; 179, identifier:r_; 180, call; 180, 181; 180, 182; 181, identifier:ones; 182, argument_list; 182, 183; 183, identifier:nang; 184, unary_operator:-; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:ones; 187, argument_list; 187, 188; 188, identifier:nang; 189, tuple; 189, 190; 189, 191; 190, identifier:ii; 191, identifier:jj; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:uang; 195, binary_operator:*; 195, 196; 195, 197; 196, identifier:Inf; 197, call; 197, 198; 197, 199; 198, identifier:ones; 199, argument_list; 199, 200; 200, identifier:nang; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:lang; 204, unary_operator:-; 204, 205; 205, identifier:uang; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 211; 208, subscript; 208, 209; 208, 210; 209, identifier:lang; 210, identifier:iangl; 211, subscript; 211, 212; 211, 227; 212, call; 212, 213; 212, 214; 213, identifier:array; 214, argument_list; 214, 215; 215, list_comprehension; 215, 216; 215, 224; 216, binary_operator:*; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:b; 219, identifier:ang_min; 220, parenthesized_expression; 220, 221; 221, binary_operator:/; 221, 222; 221, 223; 222, identifier:pi; 223, float:180.0; 224, for_in_clause; 224, 225; 224, 226; 225, identifier:b; 226, identifier:branches; 227, identifier:iangl; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 233; 230, subscript; 230, 231; 230, 232; 231, identifier:uang; 232, identifier:iangh; 233, subscript; 233, 234; 233, 249; 234, call; 234, 235; 234, 236; 235, identifier:array; 236, argument_list; 236, 237; 237, list_comprehension; 237, 238; 237, 246; 238, binary_operator:*; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:b; 241, identifier:ang_max; 242, parenthesized_expression; 242, 243; 243, binary_operator:/; 243, 244; 243, 245; 244, identifier:pi; 245, float:180.0; 246, for_in_clause; 246, 247; 246, 248; 247, identifier:b; 248, identifier:branches; 249, identifier:iangh; 250, else_clause; 250, 251; 251, block; 251, 252; 251, 261; 251, 268; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:Aang; 255, call; 255, 256; 255, 257; 256, identifier:zeros; 257, argument_list; 257, 258; 258, tuple; 258, 259; 258, 260; 259, integer:0; 260, identifier:nb; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:lang; 264, call; 264, 265; 264, 266; 265, identifier:array; 266, argument_list; 266, 267; 267, list:[]; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:uang; 271, call; 271, 272; 271, 273; 272, identifier:array; 273, argument_list; 273, 274; 274, list:[]; 275, else_clause; 275, 276; 276, block; 276, 277; 276, 286; 276, 293; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:Aang; 280, call; 280, 281; 280, 282; 281, identifier:zeros; 282, argument_list; 282, 283; 283, tuple; 283, 284; 283, 285; 284, integer:0; 285, identifier:nb; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:lang; 289, call; 289, 290; 289, 291; 290, identifier:array; 291, argument_list; 291, 292; 292, list:[]; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 296; 295, identifier:uang; 296, call; 296, 297; 296, 298; 297, identifier:array; 298, argument_list; 298, 299; 299, list:[]; 300, return_statement; 300, 301; 301, call; 301, 302; 301, 303; 302, identifier:LinearConstraint; 303, argument_list; 303, 304; 303, 305; 303, 306; 303, 307; 303, 308; 304, string:"ang"; 305, identifier:Aang; 306, identifier:lang; 307, identifier:uang; 308, list:["Va"]; 308, 309; 309, string:"Va" | def _voltage_angle_diff_limit(self, buses, branches):
nb = len(buses)
if not self.ignore_ang_lim:
iang = [i for i, b in enumerate(branches)
if (b.ang_min and (b.ang_min > -360.0))
or (b.ang_max and (b.ang_max < 360.0))]
iangl = array([i for i, b in enumerate(branches)
if b.ang_min is not None])[iang]
iangh = array([i for i, b in enumerate(branches)
if b.ang_max is not None])[iang]
nang = len(iang)
if nang > 0:
ii = range(nang) + range(nang)
jjf = array([b.from_bus._i for b in branches])[iang]
jjt = array([b.to_bus._i for b in branches])[iang]
jj = r_[jjf, jjt]
Aang = csr_matrix(r_[ones(nang), -ones(nang)], (ii, jj))
uang = Inf * ones(nang)
lang = -uang
lang[iangl] = array([b.ang_min * (pi / 180.0)
for b in branches])[iangl]
uang[iangh] = array([b.ang_max * (pi / 180.0)
for b in branches])[iangh]
else:
Aang = zeros((0, nb))
lang = array([])
uang = array([])
else:
Aang = zeros((0, nb))
lang = array([])
uang = array([])
return LinearConstraint("ang", Aang, lang, uang, ["Va"]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_clipPrices; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 38; 5, 70; 5, 107; 5, 144; 6, if_statement; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:self; 9, identifier:guaranteeOfferPrice; 10, block; 10, 11; 11, for_statement; 11, 12; 11, 13; 11, 16; 12, identifier:offer; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:offers; 16, block; 16, 17; 17, if_statement; 17, 18; 17, 29; 18, boolean_operator:and; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:offer; 21, identifier:accepted; 22, comparison_operator:<; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:offer; 25, identifier:clearedPrice; 26, attribute; 26, 27; 26, 28; 27, identifier:offer; 28, identifier:price; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:offer; 34, identifier:clearedPrice; 35, attribute; 35, 36; 35, 37; 36, identifier:offer; 37, identifier:price; 38, if_statement; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:guaranteeBidPrice; 42, block; 42, 43; 43, for_statement; 43, 44; 43, 45; 43, 48; 44, identifier:bid; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:bids; 48, block; 48, 49; 49, if_statement; 49, 50; 49, 61; 50, boolean_operator:and; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:bid; 53, identifier:accepted; 54, comparison_operator:>; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:bid; 57, identifier:clearedPrice; 58, attribute; 58, 59; 58, 60; 59, identifier:bid; 60, identifier:price; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:bid; 66, identifier:clearedPrice; 67, attribute; 67, 68; 67, 69; 68, identifier:bid; 69, identifier:price; 70, if_statement; 70, 71; 70, 79; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:limits; 76, identifier:has_key; 77, argument_list; 77, 78; 78, string:"maxClearedOffer"; 79, block; 79, 80; 79, 88; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:maxClearedOffer; 83, subscript; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:limits; 87, string:"maxClearedOffer"; 88, for_statement; 88, 89; 88, 90; 88, 93; 89, identifier:offer; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:offers; 93, block; 93, 94; 94, if_statement; 94, 95; 94, 100; 95, comparison_operator:>; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:offer; 98, identifier:clearedPrice; 99, identifier:maxClearedOffer; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:offer; 105, identifier:clearedPrice; 106, identifier:maxClearedOffer; 107, if_statement; 107, 108; 107, 116; 108, call; 108, 109; 108, 114; 109, attribute; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:limits; 113, identifier:has_key; 114, argument_list; 114, 115; 115, string:"minClearedBid"; 116, block; 116, 117; 116, 125; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:minClearedBid; 120, subscript; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:limits; 124, string:"minClearedBid"; 125, for_statement; 125, 126; 125, 127; 125, 130; 126, identifier:bid; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:bids; 130, block; 130, 131; 131, if_statement; 131, 132; 131, 137; 132, comparison_operator:<; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:bid; 135, identifier:clearedPrice; 136, identifier:minClearedBid; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:bid; 142, identifier:clearedPrice; 143, identifier:minClearedBid; 144, if_statement; 144, 145; 144, 150; 145, comparison_operator:!=; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:auctionType; 149, identifier:DISCRIMINATIVE; 150, block; 150, 151; 151, for_statement; 151, 152; 151, 153; 151, 158; 152, identifier:g; 153, attribute; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:case; 157, identifier:generators; 158, block; 158, 159; 158, 175; 158, 201; 158, 217; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:gOffers; 162, list_comprehension; 162, 163; 162, 164; 162, 169; 163, identifier:of; 164, for_in_clause; 164, 165; 164, 166; 165, identifier:of; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:offers; 169, if_clause; 169, 170; 170, comparison_operator:==; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:of; 173, identifier:generator; 174, identifier:g; 175, if_statement; 175, 176; 175, 177; 176, identifier:gOffers; 177, block; 177, 178; 177, 191; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:uniformPrice; 181, call; 181, 182; 181, 183; 182, identifier:max; 183, argument_list; 183, 184; 184, list_comprehension; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:of; 187, identifier:clearedPrice; 188, for_in_clause; 188, 189; 188, 190; 189, identifier:of; 190, identifier:gOffers; 191, for_statement; 191, 192; 191, 193; 191, 194; 192, identifier:of; 193, identifier:gOffers; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:of; 199, identifier:clearedPrice; 200, identifier:uniformPrice; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:gBids; 204, list_comprehension; 204, 205; 204, 206; 204, 211; 205, identifier:bid; 206, for_in_clause; 206, 207; 206, 208; 207, identifier:bid; 208, attribute; 208, 209; 208, 210; 209, identifier:self; 210, identifier:bids; 211, if_clause; 211, 212; 212, comparison_operator:==; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:bid; 215, identifier:vLoad; 216, identifier:g; 217, if_statement; 217, 218; 217, 219; 218, identifier:gBids; 219, block; 219, 220; 219, 233; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:uniformPrice; 223, call; 223, 224; 223, 225; 224, identifier:min; 225, argument_list; 225, 226; 226, list_comprehension; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:bid; 229, identifier:cleared_price; 230, for_in_clause; 230, 231; 230, 232; 231, identifier:bid; 232, identifier:gBids; 233, for_statement; 233, 234; 233, 235; 233, 236; 234, identifier:bid; 235, identifier:gBids; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:bid; 241, identifier:clearedPrice; 242, identifier:uniformPrice | def _clipPrices(self):
if self.guaranteeOfferPrice:
for offer in self.offers:
if offer.accepted and offer.clearedPrice < offer.price:
offer.clearedPrice = offer.price
if self.guaranteeBidPrice:
for bid in self.bids:
if bid.accepted and bid.clearedPrice > bid.price:
bid.clearedPrice = bid.price
if self.limits.has_key("maxClearedOffer"):
maxClearedOffer = self.limits["maxClearedOffer"]
for offer in self.offers:
if offer.clearedPrice > maxClearedOffer:
offer.clearedPrice = maxClearedOffer
if self.limits.has_key("minClearedBid"):
minClearedBid = self.limits["minClearedBid"]
for bid in self.bids:
if bid.clearedPrice < minClearedBid:
bid.clearedPrice = minClearedBid
if self.auctionType != DISCRIMINATIVE:
for g in self.case.generators:
gOffers = [of for of in self.offers if of.generator == g]
if gOffers:
uniformPrice = max([of.clearedPrice for of in gOffers])
for of in gOffers:
of.clearedPrice = uniformPrice
gBids = [bid for bid in self.bids if bid.vLoad == g]
if gBids:
uniformPrice = min([bid.cleared_price for bid in gBids])
for bid in gBids:
bid.clearedPrice = uniformPrice |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:gpu_iuwt_decomposition; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:in1; 5, identifier:scale_count; 6, identifier:scale_adjust; 7, identifier:store_smoothed; 8, identifier:store_on_gpu; 9, block; 9, 10; 9, 16; 9, 40; 9, 49; 9, 74; 9, 98; 9, 107; 9, 116; 9, 125; 9, 138; 9, 151; 9, 155; 9, 163; 9, 172; 9, 185; 9, 198; 9, 261; 9, 381; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:ker; 13, call; 13, 14; 13, 15; 14, identifier:SourceModule; 15, argument_list; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:wavelet_filter; 19, binary_operator:*; 19, 20; 19, 24; 20, parenthesized_expression; 20, 21; 21, binary_operator:/; 21, 22; 21, 23; 22, float:1.; 23, integer:16; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:np; 27, identifier:array; 28, argument_list; 28, 29; 28, 35; 29, list:[1,4,6,4,1]; 29, 30; 29, 31; 29, 32; 29, 33; 29, 34; 30, integer:1; 31, integer:4; 32, integer:6; 33, integer:4; 34, integer:1; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:dtype; 37, attribute; 37, 38; 37, 39; 38, identifier:np; 39, identifier:float32; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:wavelet_filter; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:gpuarray; 46, identifier:to_gpu_async; 47, argument_list; 47, 48; 48, identifier:wavelet_filter; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:detail_coeffs; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:gpuarray; 55, identifier:empty; 56, argument_list; 56, 57; 56, 71; 57, list:[scale_count-scale_adjust, in1.shape[0], in1.shape[1]]; 57, 58; 57, 61; 57, 66; 58, binary_operator:-; 58, 59; 58, 60; 59, identifier:scale_count; 60, identifier:scale_adjust; 61, subscript; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:in1; 64, identifier:shape; 65, integer:0; 66, subscript; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:in1; 69, identifier:shape; 70, integer:1; 71, attribute; 71, 72; 71, 73; 72, identifier:np; 73, identifier:float32; 74, try_statement; 74, 75; 74, 92; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:gpu_in1; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:gpuarray; 82, identifier:to_gpu_async; 83, argument_list; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:in1; 87, identifier:astype; 88, argument_list; 88, 89; 89, attribute; 89, 90; 89, 91; 90, identifier:np; 91, identifier:float32; 92, except_clause; 92, 93; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:gpu_in1; 97, identifier:in1; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:gpu_tmp; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:gpuarray; 104, identifier:empty_like; 105, argument_list; 105, 106; 106, identifier:gpu_in1; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:gpu_out1; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:gpuarray; 113, identifier:empty_like; 114, argument_list; 114, 115; 115, identifier:gpu_in1; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:gpu_out2; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:gpuarray; 122, identifier:empty_like; 123, argument_list; 123, 124; 124, identifier:gpu_in1; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:gpu_scale; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:gpuarray; 131, identifier:zeros; 132, argument_list; 132, 133; 132, 135; 133, list:[1]; 133, 134; 134, integer:1; 135, attribute; 135, 136; 135, 137; 136, identifier:np; 137, identifier:int32; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:gpu_adjust; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:gpuarray; 144, identifier:zeros; 145, argument_list; 145, 146; 145, 148; 146, list:[1]; 146, 147; 147, integer:1; 148, attribute; 148, 149; 148, 150; 149, identifier:np; 150, identifier:int32; 151, expression_statement; 151, 152; 152, augmented_assignment:+=; 152, 153; 152, 154; 153, identifier:gpu_adjust; 154, identifier:scale_adjust; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 160; 157, pattern_list; 157, 158; 157, 159; 158, identifier:gpu_a_trous_row_kernel; 159, identifier:gpu_a_trous_col_kernel; 160, call; 160, 161; 160, 162; 161, identifier:gpu_a_trous; 162, argument_list; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:gpu_store_detail_coeffs; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:ker; 169, identifier:get_function; 170, argument_list; 170, 171; 171, string:"gpu_store_detail_coeffs"; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:grid_rows; 175, call; 175, 176; 175, 177; 176, identifier:int; 177, argument_list; 177, 178; 178, binary_operator://; 178, 179; 178, 184; 179, subscript; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:in1; 182, identifier:shape; 183, integer:0; 184, integer:32; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:grid_cols; 188, call; 188, 189; 188, 190; 189, identifier:int; 190, argument_list; 190, 191; 191, binary_operator://; 191, 192; 191, 197; 192, subscript; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:in1; 195, identifier:shape; 196, integer:1; 197, integer:32; 198, if_statement; 198, 199; 198, 202; 199, comparison_operator:>; 199, 200; 199, 201; 200, identifier:scale_adjust; 201, integer:0; 202, block; 202, 203; 203, for_statement; 203, 204; 203, 205; 203, 210; 204, identifier:i; 205, call; 205, 206; 205, 207; 206, identifier:range; 207, argument_list; 207, 208; 207, 209; 208, integer:0; 209, identifier:scale_adjust; 210, block; 210, 211; 210, 230; 210, 249; 210, 257; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 214; 213, identifier:gpu_a_trous_row_kernel; 214, argument_list; 214, 215; 214, 216; 214, 217; 214, 218; 214, 219; 214, 225; 215, identifier:gpu_in1; 216, identifier:gpu_tmp; 217, identifier:wavelet_filter; 218, identifier:gpu_scale; 219, keyword_argument; 219, 220; 219, 221; 220, identifier:block; 221, tuple; 221, 222; 221, 223; 221, 224; 222, integer:32; 223, integer:32; 224, integer:1; 225, keyword_argument; 225, 226; 225, 227; 226, identifier:grid; 227, tuple; 227, 228; 227, 229; 228, identifier:grid_cols; 229, identifier:grid_rows; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 233; 232, identifier:gpu_a_trous_col_kernel; 233, argument_list; 233, 234; 233, 235; 233, 236; 233, 237; 233, 238; 233, 244; 234, identifier:gpu_tmp; 235, identifier:gpu_out1; 236, identifier:wavelet_filter; 237, identifier:gpu_scale; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:block; 240, tuple; 240, 241; 240, 242; 240, 243; 241, integer:32; 242, integer:32; 243, integer:1; 244, keyword_argument; 244, 245; 244, 246; 245, identifier:grid; 246, tuple; 246, 247; 246, 248; 247, identifier:grid_cols; 248, identifier:grid_rows; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 254; 251, pattern_list; 251, 252; 251, 253; 252, identifier:gpu_in1; 253, identifier:gpu_out1; 254, expression_list; 254, 255; 254, 256; 255, identifier:gpu_out1; 256, identifier:gpu_in1; 257, expression_statement; 257, 258; 258, augmented_assignment:+=; 258, 259; 258, 260; 259, identifier:gpu_scale; 260, integer:1; 261, for_statement; 261, 262; 261, 263; 261, 268; 262, identifier:i; 263, call; 263, 264; 263, 265; 264, identifier:range; 265, argument_list; 265, 266; 265, 267; 266, identifier:scale_adjust; 267, identifier:scale_count; 268, block; 268, 269; 268, 288; 268, 307; 268, 326; 268, 345; 268, 369; 268, 377; 269, expression_statement; 269, 270; 270, call; 270, 271; 270, 272; 271, identifier:gpu_a_trous_row_kernel; 272, argument_list; 272, 273; 272, 274; 272, 275; 272, 276; 272, 277; 272, 283; 273, identifier:gpu_in1; 274, identifier:gpu_tmp; 275, identifier:wavelet_filter; 276, identifier:gpu_scale; 277, keyword_argument; 277, 278; 277, 279; 278, identifier:block; 279, tuple; 279, 280; 279, 281; 279, 282; 280, integer:32; 281, integer:32; 282, integer:1; 283, keyword_argument; 283, 284; 283, 285; 284, identifier:grid; 285, tuple; 285, 286; 285, 287; 286, identifier:grid_cols; 287, identifier:grid_rows; 288, expression_statement; 288, 289; 289, call; 289, 290; 289, 291; 290, identifier:gpu_a_trous_col_kernel; 291, argument_list; 291, 292; 291, 293; 291, 294; 291, 295; 291, 296; 291, 302; 292, identifier:gpu_tmp; 293, identifier:gpu_out1; 294, identifier:wavelet_filter; 295, identifier:gpu_scale; 296, keyword_argument; 296, 297; 296, 298; 297, identifier:block; 298, tuple; 298, 299; 298, 300; 298, 301; 299, integer:32; 300, integer:32; 301, integer:1; 302, keyword_argument; 302, 303; 302, 304; 303, identifier:grid; 304, tuple; 304, 305; 304, 306; 305, identifier:grid_cols; 306, identifier:grid_rows; 307, expression_statement; 307, 308; 308, call; 308, 309; 308, 310; 309, identifier:gpu_a_trous_row_kernel; 310, argument_list; 310, 311; 310, 312; 310, 313; 310, 314; 310, 315; 310, 321; 311, identifier:gpu_out1; 312, identifier:gpu_tmp; 313, identifier:wavelet_filter; 314, identifier:gpu_scale; 315, keyword_argument; 315, 316; 315, 317; 316, identifier:block; 317, tuple; 317, 318; 317, 319; 317, 320; 318, integer:32; 319, integer:32; 320, integer:1; 321, keyword_argument; 321, 322; 321, 323; 322, identifier:grid; 323, tuple; 323, 324; 323, 325; 324, identifier:grid_cols; 325, identifier:grid_rows; 326, expression_statement; 326, 327; 327, call; 327, 328; 327, 329; 328, identifier:gpu_a_trous_col_kernel; 329, argument_list; 329, 330; 329, 331; 329, 332; 329, 333; 329, 334; 329, 340; 330, identifier:gpu_tmp; 331, identifier:gpu_out2; 332, identifier:wavelet_filter; 333, identifier:gpu_scale; 334, keyword_argument; 334, 335; 334, 336; 335, identifier:block; 336, tuple; 336, 337; 336, 338; 336, 339; 337, integer:32; 338, integer:32; 339, integer:1; 340, keyword_argument; 340, 341; 340, 342; 341, identifier:grid; 342, tuple; 342, 343; 342, 344; 343, identifier:grid_cols; 344, identifier:grid_rows; 345, expression_statement; 345, 346; 346, call; 346, 347; 346, 348; 347, identifier:gpu_store_detail_coeffs; 348, argument_list; 348, 349; 348, 350; 348, 351; 348, 352; 348, 353; 348, 354; 348, 360; 349, identifier:gpu_in1; 350, identifier:gpu_out2; 351, identifier:detail_coeffs; 352, identifier:gpu_scale; 353, identifier:gpu_adjust; 354, keyword_argument; 354, 355; 354, 356; 355, identifier:block; 356, tuple; 356, 357; 356, 358; 356, 359; 357, integer:32; 358, integer:32; 359, integer:1; 360, keyword_argument; 360, 361; 360, 362; 361, identifier:grid; 362, tuple; 362, 363; 362, 364; 362, 365; 363, identifier:grid_cols; 364, identifier:grid_rows; 365, call; 365, 366; 365, 367; 366, identifier:int; 367, argument_list; 367, 368; 368, identifier:scale_count; 369, expression_statement; 369, 370; 370, assignment; 370, 371; 370, 374; 371, pattern_list; 371, 372; 371, 373; 372, identifier:gpu_in1; 373, identifier:gpu_out1; 374, expression_list; 374, 375; 374, 376; 375, identifier:gpu_out1; 376, identifier:gpu_in1; 377, expression_statement; 377, 378; 378, augmented_assignment:+=; 378, 379; 378, 380; 379, identifier:gpu_scale; 380, integer:1; 381, if_statement; 381, 382; 381, 383; 381, 386; 381, 401; 382, identifier:store_on_gpu; 383, block; 383, 384; 384, return_statement; 384, 385; 385, identifier:detail_coeffs; 386, elif_clause; 386, 387; 386, 388; 387, identifier:store_smoothed; 388, block; 388, 389; 389, return_statement; 389, 390; 390, expression_list; 390, 391; 390, 396; 391, call; 391, 392; 391, 395; 392, attribute; 392, 393; 392, 394; 393, identifier:detail_coeffs; 394, identifier:get; 395, argument_list; 396, call; 396, 397; 396, 400; 397, attribute; 397, 398; 397, 399; 398, identifier:gpu_in1; 399, identifier:get; 400, argument_list; 401, else_clause; 401, 402; 402, block; 402, 403; 403, return_statement; 403, 404; 404, call; 404, 405; 404, 408; 405, attribute; 405, 406; 405, 407; 406, identifier:detail_coeffs; 407, identifier:get; 408, argument_list | def gpu_iuwt_decomposition(in1, scale_count, scale_adjust, store_smoothed, store_on_gpu):
ker = SourceModule(
)
wavelet_filter = (1./16)*np.array([1,4,6,4,1], dtype=np.float32)
wavelet_filter = gpuarray.to_gpu_async(wavelet_filter)
detail_coeffs = gpuarray.empty([scale_count-scale_adjust, in1.shape[0], in1.shape[1]], np.float32)
try:
gpu_in1 = gpuarray.to_gpu_async(in1.astype(np.float32))
except:
gpu_in1 = in1
gpu_tmp = gpuarray.empty_like(gpu_in1)
gpu_out1 = gpuarray.empty_like(gpu_in1)
gpu_out2 = gpuarray.empty_like(gpu_in1)
gpu_scale = gpuarray.zeros([1], np.int32)
gpu_adjust = gpuarray.zeros([1], np.int32)
gpu_adjust += scale_adjust
gpu_a_trous_row_kernel, gpu_a_trous_col_kernel = gpu_a_trous()
gpu_store_detail_coeffs = ker.get_function("gpu_store_detail_coeffs")
grid_rows = int(in1.shape[0]//32)
grid_cols = int(in1.shape[1]//32)
if scale_adjust>0:
for i in range(0, scale_adjust):
gpu_a_trous_row_kernel(gpu_in1, gpu_tmp, wavelet_filter, gpu_scale,
block=(32,32,1), grid=(grid_cols, grid_rows))
gpu_a_trous_col_kernel(gpu_tmp, gpu_out1, wavelet_filter, gpu_scale,
block=(32,32,1), grid=(grid_cols, grid_rows))
gpu_in1, gpu_out1 = gpu_out1, gpu_in1
gpu_scale += 1
for i in range(scale_adjust, scale_count):
gpu_a_trous_row_kernel(gpu_in1, gpu_tmp, wavelet_filter, gpu_scale,
block=(32,32,1), grid=(grid_cols, grid_rows))
gpu_a_trous_col_kernel(gpu_tmp, gpu_out1, wavelet_filter, gpu_scale,
block=(32,32,1), grid=(grid_cols, grid_rows))
gpu_a_trous_row_kernel(gpu_out1, gpu_tmp, wavelet_filter, gpu_scale,
block=(32,32,1), grid=(grid_cols, grid_rows))
gpu_a_trous_col_kernel(gpu_tmp, gpu_out2, wavelet_filter, gpu_scale,
block=(32,32,1), grid=(grid_cols, grid_rows))
gpu_store_detail_coeffs(gpu_in1, gpu_out2, detail_coeffs, gpu_scale, gpu_adjust,
block=(32,32,1), grid=(grid_cols, grid_rows, int(scale_count)))
gpu_in1, gpu_out1 = gpu_out1, gpu_in1
gpu_scale += 1
if store_on_gpu:
return detail_coeffs
elif store_smoothed:
return detail_coeffs.get(), gpu_in1.get()
else:
return detail_coeffs.get() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:gpu_iuwt_recomposition; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:in1; 5, identifier:scale_adjust; 6, identifier:store_on_gpu; 7, identifier:smoothed_array; 8, block; 8, 9; 8, 33; 8, 42; 8, 52; 8, 97; 8, 121; 8, 130; 8, 143; 8, 149; 8, 157; 8, 170; 8, 183; 8, 258; 8, 318; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:wavelet_filter; 12, binary_operator:*; 12, 13; 12, 17; 13, parenthesized_expression; 13, 14; 14, binary_operator:/; 14, 15; 14, 16; 15, float:1.; 16, integer:16; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:np; 20, identifier:array; 21, argument_list; 21, 22; 21, 28; 22, list:[1,4,6,4,1]; 22, 23; 22, 24; 22, 25; 22, 26; 22, 27; 23, integer:1; 24, integer:4; 25, integer:6; 26, integer:4; 27, integer:1; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:dtype; 30, attribute; 30, 31; 30, 32; 31, identifier:np; 32, identifier:float32; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:wavelet_filter; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:gpuarray; 39, identifier:to_gpu_async; 40, argument_list; 40, 41; 41, identifier:wavelet_filter; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:max_scale; 45, binary_operator:+; 45, 46; 45, 51; 46, subscript; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:in1; 49, identifier:shape; 50, integer:0; 51, identifier:scale_adjust; 52, if_statement; 52, 53; 52, 56; 52, 79; 53, comparison_operator:is; 53, 54; 53, 55; 54, identifier:smoothed_array; 55, None; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:recomposition; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:gpuarray; 63, identifier:zeros; 64, argument_list; 64, 65; 64, 76; 65, list:[in1.shape[1], in1.shape[2]]; 65, 66; 65, 71; 66, subscript; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:in1; 69, identifier:shape; 70, integer:1; 71, subscript; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:in1; 74, identifier:shape; 75, integer:2; 76, attribute; 76, 77; 76, 78; 77, identifier:np; 78, identifier:float32; 79, else_clause; 79, 80; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:recomposition; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:gpuarray; 87, identifier:to_gpu; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:smoothed_array; 92, identifier:astype; 93, argument_list; 93, 94; 94, attribute; 94, 95; 94, 96; 95, identifier:np; 96, identifier:float32; 97, try_statement; 97, 98; 97, 115; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:gpu_in1; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:gpuarray; 105, identifier:to_gpu_async; 106, argument_list; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:in1; 110, identifier:astype; 111, argument_list; 111, 112; 112, attribute; 112, 113; 112, 114; 113, identifier:np; 114, identifier:float32; 115, except_clause; 115, 116; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:gpu_in1; 120, identifier:in1; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:gpu_tmp; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:gpuarray; 127, identifier:empty_like; 128, argument_list; 128, 129; 129, identifier:recomposition; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:gpu_scale; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:gpuarray; 136, identifier:zeros; 137, argument_list; 137, 138; 137, 140; 138, list:[1]; 138, 139; 139, integer:1; 140, attribute; 140, 141; 140, 142; 141, identifier:np; 142, identifier:int32; 143, expression_statement; 143, 144; 144, augmented_assignment:+=; 144, 145; 144, 146; 145, identifier:gpu_scale; 146, binary_operator:-; 146, 147; 146, 148; 147, identifier:max_scale; 148, integer:1; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 154; 151, pattern_list; 151, 152; 151, 153; 152, identifier:gpu_a_trous_row_kernel; 153, identifier:gpu_a_trous_col_kernel; 154, call; 154, 155; 154, 156; 155, identifier:gpu_a_trous; 156, argument_list; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:grid_rows; 160, call; 160, 161; 160, 162; 161, identifier:int; 162, argument_list; 162, 163; 163, binary_operator://; 163, 164; 163, 169; 164, subscript; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:in1; 167, identifier:shape; 168, integer:1; 169, integer:32; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:grid_cols; 173, call; 173, 174; 173, 175; 174, identifier:int; 175, argument_list; 175, 176; 176, binary_operator://; 176, 177; 176, 182; 177, subscript; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:in1; 180, identifier:shape; 181, integer:2; 182, integer:32; 183, for_statement; 183, 184; 183, 185; 183, 196; 184, identifier:i; 185, call; 185, 186; 185, 187; 186, identifier:range; 187, argument_list; 187, 188; 187, 191; 187, 194; 188, binary_operator:-; 188, 189; 188, 190; 189, identifier:max_scale; 190, integer:1; 191, binary_operator:-; 191, 192; 191, 193; 192, identifier:scale_adjust; 193, integer:1; 194, unary_operator:-; 194, 195; 195, integer:1; 196, block; 196, 197; 196, 216; 196, 235; 196, 254; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 200; 199, identifier:gpu_a_trous_row_kernel; 200, argument_list; 200, 201; 200, 202; 200, 203; 200, 204; 200, 205; 200, 211; 201, identifier:recomposition; 202, identifier:gpu_tmp; 203, identifier:wavelet_filter; 204, identifier:gpu_scale; 205, keyword_argument; 205, 206; 205, 207; 206, identifier:block; 207, tuple; 207, 208; 207, 209; 207, 210; 208, integer:32; 209, integer:32; 210, integer:1; 211, keyword_argument; 211, 212; 211, 213; 212, identifier:grid; 213, tuple; 213, 214; 213, 215; 214, identifier:grid_cols; 215, identifier:grid_rows; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 219; 218, identifier:gpu_a_trous_col_kernel; 219, argument_list; 219, 220; 219, 221; 219, 222; 219, 223; 219, 224; 219, 230; 220, identifier:gpu_tmp; 221, identifier:recomposition; 222, identifier:wavelet_filter; 223, identifier:gpu_scale; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:block; 226, tuple; 226, 227; 226, 228; 226, 229; 227, integer:32; 228, integer:32; 229, integer:1; 230, keyword_argument; 230, 231; 230, 232; 231, identifier:grid; 232, tuple; 232, 233; 232, 234; 233, identifier:grid_cols; 234, identifier:grid_rows; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:recomposition; 238, binary_operator:+; 238, 239; 238, 245; 239, subscript; 239, 240; 239, 241; 239, 243; 240, identifier:recomposition; 241, slice; 241, 242; 242, colon; 243, slice; 243, 244; 244, colon; 245, subscript; 245, 246; 245, 247; 245, 250; 245, 252; 246, identifier:gpu_in1; 247, binary_operator:-; 247, 248; 247, 249; 248, identifier:i; 249, identifier:scale_adjust; 250, slice; 250, 251; 251, colon; 252, slice; 252, 253; 253, colon; 254, expression_statement; 254, 255; 255, augmented_assignment:-=; 255, 256; 255, 257; 256, identifier:gpu_scale; 257, integer:1; 258, if_statement; 258, 259; 258, 262; 259, comparison_operator:>; 259, 260; 259, 261; 260, identifier:scale_adjust; 261, integer:0; 262, block; 262, 263; 263, for_statement; 263, 264; 263, 265; 263, 275; 264, identifier:i; 265, call; 265, 266; 265, 267; 266, identifier:range; 267, argument_list; 267, 268; 267, 271; 267, 273; 268, binary_operator:-; 268, 269; 268, 270; 269, identifier:scale_adjust; 270, integer:1; 271, unary_operator:-; 271, 272; 272, integer:1; 273, unary_operator:-; 273, 274; 274, integer:1; 275, block; 275, 276; 275, 295; 275, 314; 276, expression_statement; 276, 277; 277, call; 277, 278; 277, 279; 278, identifier:gpu_a_trous_row_kernel; 279, argument_list; 279, 280; 279, 281; 279, 282; 279, 283; 279, 284; 279, 290; 280, identifier:recomposition; 281, identifier:gpu_tmp; 282, identifier:wavelet_filter; 283, identifier:gpu_scale; 284, keyword_argument; 284, 285; 284, 286; 285, identifier:block; 286, tuple; 286, 287; 286, 288; 286, 289; 287, integer:32; 288, integer:32; 289, integer:1; 290, keyword_argument; 290, 291; 290, 292; 291, identifier:grid; 292, tuple; 292, 293; 292, 294; 293, identifier:grid_cols; 294, identifier:grid_rows; 295, expression_statement; 295, 296; 296, call; 296, 297; 296, 298; 297, identifier:gpu_a_trous_col_kernel; 298, argument_list; 298, 299; 298, 300; 298, 301; 298, 302; 298, 303; 298, 309; 299, identifier:gpu_tmp; 300, identifier:recomposition; 301, identifier:wavelet_filter; 302, identifier:gpu_scale; 303, keyword_argument; 303, 304; 303, 305; 304, identifier:block; 305, tuple; 305, 306; 305, 307; 305, 308; 306, integer:32; 307, integer:32; 308, integer:1; 309, keyword_argument; 309, 310; 309, 311; 310, identifier:grid; 311, tuple; 311, 312; 311, 313; 312, identifier:grid_cols; 313, identifier:grid_rows; 314, expression_statement; 314, 315; 315, augmented_assignment:-=; 315, 316; 315, 317; 316, identifier:gpu_scale; 317, integer:1; 318, if_statement; 318, 319; 318, 320; 318, 323; 319, identifier:store_on_gpu; 320, block; 320, 321; 321, return_statement; 321, 322; 322, identifier:recomposition; 323, else_clause; 323, 324; 324, block; 324, 325; 325, return_statement; 325, 326; 326, call; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, identifier:recomposition; 329, identifier:get; 330, argument_list | def gpu_iuwt_recomposition(in1, scale_adjust, store_on_gpu, smoothed_array):
wavelet_filter = (1./16)*np.array([1,4,6,4,1], dtype=np.float32)
wavelet_filter = gpuarray.to_gpu_async(wavelet_filter)
max_scale = in1.shape[0] + scale_adjust
if smoothed_array is None:
recomposition = gpuarray.zeros([in1.shape[1], in1.shape[2]], np.float32)
else:
recomposition = gpuarray.to_gpu(smoothed_array.astype(np.float32))
try:
gpu_in1 = gpuarray.to_gpu_async(in1.astype(np.float32))
except:
gpu_in1 = in1
gpu_tmp = gpuarray.empty_like(recomposition)
gpu_scale = gpuarray.zeros([1], np.int32)
gpu_scale += max_scale-1
gpu_a_trous_row_kernel, gpu_a_trous_col_kernel = gpu_a_trous()
grid_rows = int(in1.shape[1]//32)
grid_cols = int(in1.shape[2]//32)
for i in range(max_scale-1, scale_adjust-1, -1):
gpu_a_trous_row_kernel(recomposition, gpu_tmp, wavelet_filter, gpu_scale,
block=(32,32,1), grid=(grid_cols, grid_rows))
gpu_a_trous_col_kernel(gpu_tmp, recomposition, wavelet_filter, gpu_scale,
block=(32,32,1), grid=(grid_cols, grid_rows))
recomposition = recomposition[:,:] + gpu_in1[i-scale_adjust,:,:]
gpu_scale -= 1
if scale_adjust>0:
for i in range(scale_adjust-1, -1, -1):
gpu_a_trous_row_kernel(recomposition, gpu_tmp, wavelet_filter, gpu_scale,
block=(32,32,1), grid=(grid_cols, grid_rows))
gpu_a_trous_col_kernel(gpu_tmp, recomposition, wavelet_filter, gpu_scale,
block=(32,32,1), grid=(grid_cols, grid_rows))
gpu_scale -= 1
if store_on_gpu:
return recomposition
else:
return recomposition.get() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:from_config; 3, parameters; 3, 4; 4, identifier:config; 5, block; 5, 6; 5, 10; 5, 18; 5, 172; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:matrix; 9, dictionary; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:variables; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:config; 16, identifier:keys; 17, argument_list; 18, for_statement; 18, 19; 18, 20; 18, 29; 19, identifier:entries; 20, call; 20, 21; 20, 22; 21, identifier:product; 22, argument_list; 22, 23; 23, list_splat; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:config; 27, identifier:values; 28, argument_list; 29, block; 29, 30; 29, 41; 29, 45; 29, 108; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:combination; 33, call; 33, 34; 33, 35; 34, identifier:dict; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:zip; 38, argument_list; 38, 39; 38, 40; 39, identifier:variables; 40, identifier:entries; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:include; 44, True; 45, for_statement; 45, 46; 45, 47; 45, 52; 46, identifier:value; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:combination; 50, identifier:values; 51, argument_list; 52, block; 52, 53; 53, for_statement; 53, 54; 53, 55; 53, 58; 54, identifier:reducer; 55, attribute; 55, 56; 55, 57; 56, identifier:value; 57, identifier:reducers; 58, block; 58, 59; 58, 95; 59, if_statement; 59, 60; 59, 65; 59, 77; 60, comparison_operator:==; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:reducer; 63, identifier:pattern; 64, string:'-'; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:match; 69, not_operator; 69, 70; 70, attribute; 70, 71; 70, 76; 71, subscript; 71, 72; 71, 73; 72, identifier:combination; 73, attribute; 73, 74; 73, 75; 74, identifier:reducer; 75, identifier:variable; 76, identifier:value; 77, else_clause; 77, 78; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:match; 82, call; 82, 83; 82, 84; 83, identifier:fnmatch; 84, argument_list; 84, 85; 84, 92; 85, attribute; 85, 86; 85, 91; 86, subscript; 86, 87; 86, 88; 87, identifier:combination; 88, attribute; 88, 89; 88, 90; 89, identifier:reducer; 90, identifier:variable; 91, identifier:value; 92, attribute; 92, 93; 92, 94; 93, identifier:reducer; 94, identifier:pattern; 95, if_statement; 95, 96; 95, 103; 96, conditional_expression:if; 96, 97; 96, 98; 96, 101; 97, identifier:match; 98, attribute; 98, 99; 98, 100; 99, identifier:reducer; 100, identifier:is_exclude; 101, not_operator; 101, 102; 102, identifier:match; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:include; 107, False; 108, if_statement; 108, 109; 108, 110; 109, identifier:include; 110, block; 110, 111; 110, 129; 110, 146; 110, 166; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:key; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, string:'-'; 117, identifier:join; 118, generator_expression; 118, 119; 118, 122; 118, 125; 119, attribute; 119, 120; 119, 121; 120, identifier:entry; 121, identifier:alias; 122, for_in_clause; 122, 123; 122, 124; 123, identifier:entry; 124, identifier:entries; 125, if_clause; 125, 126; 126, attribute; 126, 127; 126, 128; 127, identifier:entry; 128, identifier:alias; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:data; 132, call; 132, 133; 132, 134; 133, identifier:dict; 134, argument_list; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:zip; 137, argument_list; 137, 138; 137, 139; 138, identifier:variables; 139, generator_expression; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:entry; 142, identifier:value; 143, for_in_clause; 143, 144; 143, 145; 144, identifier:entry; 145, identifier:entries; 146, if_statement; 146, 147; 146, 156; 147, boolean_operator:and; 147, 148; 147, 151; 148, comparison_operator:in; 148, 149; 148, 150; 149, identifier:key; 150, identifier:matrix; 151, comparison_operator:!=; 151, 152; 151, 153; 152, identifier:data; 153, subscript; 153, 154; 153, 155; 154, identifier:matrix; 155, identifier:key; 156, block; 156, 157; 157, raise_statement; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:DuplicateEnvironment; 160, argument_list; 160, 161; 160, 162; 160, 163; 161, identifier:key; 162, identifier:data; 163, subscript; 163, 164; 163, 165; 164, identifier:matrix; 165, identifier:key; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 171; 168, subscript; 168, 169; 168, 170; 169, identifier:matrix; 170, identifier:key; 171, identifier:data; 172, return_statement; 172, 173; 173, identifier:matrix | def from_config(config):
matrix = {}
variables = config.keys()
for entries in product(*config.values()):
combination = dict(zip(variables, entries))
include = True
for value in combination.values():
for reducer in value.reducers:
if reducer.pattern == '-':
match = not combination[reducer.variable].value
else:
match = fnmatch(combination[reducer.variable].value, reducer.pattern)
if match if reducer.is_exclude else not match:
include = False
if include:
key = '-'.join(entry.alias for entry in entries if entry.alias)
data = dict(
zip(variables, (entry.value for entry in entries))
)
if key in matrix and data != matrix[key]:
raise DuplicateEnvironment(key, data, matrix[key])
matrix[key] = data
return matrix |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 71; 2, function_name:moresane_by_scale; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 3, 35; 3, 38; 3, 41; 3, 44; 3, 47; 3, 50; 3, 53; 3, 56; 3, 59; 3, 62; 3, 65; 3, 68; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:start_scale; 7, integer:1; 8, default_parameter; 8, 9; 8, 10; 9, identifier:stop_scale; 10, integer:20; 11, default_parameter; 11, 12; 11, 13; 12, identifier:subregion; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:sigma_level; 16, integer:4; 17, default_parameter; 17, 18; 17, 19; 18, identifier:loop_gain; 19, float:0.1; 20, default_parameter; 20, 21; 20, 22; 21, identifier:tolerance; 22, float:0.75; 23, default_parameter; 23, 24; 23, 25; 24, identifier:accuracy; 25, float:1e-6; 26, default_parameter; 26, 27; 26, 28; 27, identifier:major_loop_miter; 28, integer:100; 29, default_parameter; 29, 30; 29, 31; 30, identifier:minor_loop_miter; 31, integer:30; 32, default_parameter; 32, 33; 32, 34; 33, identifier:all_on_gpu; 34, False; 35, default_parameter; 35, 36; 35, 37; 36, identifier:decom_mode; 37, string:"ser"; 38, default_parameter; 38, 39; 38, 40; 39, identifier:core_count; 40, integer:1; 41, default_parameter; 41, 42; 41, 43; 42, identifier:conv_device; 43, string:'cpu'; 44, default_parameter; 44, 45; 44, 46; 45, identifier:conv_mode; 46, string:'linear'; 47, default_parameter; 47, 48; 47, 49; 48, identifier:extraction_mode; 49, string:'cpu'; 50, default_parameter; 50, 51; 50, 52; 51, identifier:enforce_positivity; 52, False; 53, default_parameter; 53, 54; 53, 55; 54, identifier:edge_suppression; 55, False; 56, default_parameter; 56, 57; 56, 58; 57, identifier:edge_offset; 58, integer:0; 59, default_parameter; 59, 60; 59, 61; 60, identifier:flux_threshold; 61, integer:0; 62, default_parameter; 62, 63; 62, 64; 63, identifier:neg_comp; 64, False; 65, default_parameter; 65, 66; 65, 67; 66, identifier:edge_excl; 67, integer:0; 68, default_parameter; 68, 69; 68, 70; 69, identifier:int_excl; 70, integer:0; 71, block; 71, 72; 71, 78; 71, 82; 71, 224; 71, 230; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:dirty_data; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:dirty_data; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:scale_count; 81, identifier:start_scale; 82, while_statement; 82, 83; 82, 88; 83, not_operator; 83, 84; 84, parenthesized_expression; 84, 85; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:complete; 88, block; 88, 89; 88, 101; 88, 170; 88, 178; 88, 182; 88, 210; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:logger; 93, identifier:info; 94, argument_list; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, string:"MORESANE at scale {}"; 98, identifier:format; 99, argument_list; 99, 100; 100, identifier:scale_count; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:moresane; 106, argument_list; 106, 107; 106, 110; 106, 113; 106, 116; 106, 119; 106, 122; 106, 125; 106, 128; 106, 131; 106, 134; 106, 137; 106, 140; 106, 143; 106, 146; 106, 149; 106, 152; 106, 155; 106, 158; 106, 161; 106, 164; 106, 167; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:subregion; 109, identifier:subregion; 110, keyword_argument; 110, 111; 110, 112; 111, identifier:scale_count; 112, identifier:scale_count; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:sigma_level; 115, identifier:sigma_level; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:loop_gain; 118, identifier:loop_gain; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:tolerance; 121, identifier:tolerance; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:accuracy; 124, identifier:accuracy; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:major_loop_miter; 127, identifier:major_loop_miter; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:minor_loop_miter; 130, identifier:minor_loop_miter; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:all_on_gpu; 133, identifier:all_on_gpu; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:decom_mode; 136, identifier:decom_mode; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:core_count; 139, identifier:core_count; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:conv_device; 142, identifier:conv_device; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:conv_mode; 145, identifier:conv_mode; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:extraction_mode; 148, identifier:extraction_mode; 149, keyword_argument; 149, 150; 149, 151; 150, identifier:enforce_positivity; 151, identifier:enforce_positivity; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:edge_suppression; 154, identifier:edge_suppression; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:edge_offset; 157, identifier:edge_offset; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:flux_threshold; 160, identifier:flux_threshold; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:neg_comp; 163, identifier:neg_comp; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:edge_excl; 166, identifier:edge_excl; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:int_excl; 169, identifier:int_excl; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:dirty_data; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:residual; 178, expression_statement; 178, 179; 179, augmented_assignment:+=; 179, 180; 179, 181; 180, identifier:scale_count; 181, integer:1; 182, if_statement; 182, 183; 182, 201; 183, parenthesized_expression; 183, 184; 184, comparison_operator:>; 184, 185; 184, 186; 185, identifier:scale_count; 186, binary_operator:-; 186, 187; 186, 200; 187, parenthesized_expression; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:np; 191, identifier:log2; 192, argument_list; 192, 193; 193, subscript; 193, 194; 193, 199; 194, attribute; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:self; 197, identifier:dirty_data; 198, identifier:shape; 199, integer:0; 200, integer:1; 201, block; 201, 202; 201, 209; 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, string:"Maximum scale reached - finished."; 209, break_statement; 210, if_statement; 210, 211; 210, 215; 211, parenthesized_expression; 211, 212; 212, comparison_operator:>; 212, 213; 212, 214; 213, identifier:scale_count; 214, identifier:stop_scale; 215, block; 215, 216; 215, 223; 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, string:"Maximum scale reached - finished."; 223, break_statement; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:self; 228, identifier:dirty_data; 229, identifier:dirty_data; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:self; 234, identifier:complete; 235, False | def moresane_by_scale(self, start_scale=1, stop_scale=20, subregion=None, sigma_level=4, loop_gain=0.1,
tolerance=0.75, accuracy=1e-6, major_loop_miter=100, minor_loop_miter=30, all_on_gpu=False,
decom_mode="ser", core_count=1, conv_device='cpu', conv_mode='linear', extraction_mode='cpu',
enforce_positivity=False, edge_suppression=False,
edge_offset=0, flux_threshold=0, neg_comp=False, edge_excl=0, int_excl=0):
dirty_data = self.dirty_data
scale_count = start_scale
while not (self.complete):
logger.info("MORESANE at scale {}".format(scale_count))
self.moresane(subregion=subregion, scale_count=scale_count, sigma_level=sigma_level, loop_gain=loop_gain,
tolerance=tolerance, accuracy=accuracy, major_loop_miter=major_loop_miter,
minor_loop_miter=minor_loop_miter, all_on_gpu=all_on_gpu, decom_mode=decom_mode,
core_count=core_count, conv_device=conv_device, conv_mode=conv_mode,
extraction_mode=extraction_mode, enforce_positivity=enforce_positivity,
edge_suppression=edge_suppression, edge_offset=edge_offset,
flux_threshold=flux_threshold, neg_comp=neg_comp,
edge_excl=edge_excl, int_excl=int_excl)
self.dirty_data = self.residual
scale_count += 1
if (scale_count>(np.log2(self.dirty_data.shape[0]))-1):
logger.info("Maximum scale reached - finished.")
break
if (scale_count>stop_scale):
logger.info("Maximum scale reached - finished.")
break
self.dirty_data = dirty_data
self.complete = False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:load_or_create; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:cls; 5, default_parameter; 5, 6; 5, 7; 6, identifier:filename; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:no_input; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:create_new; 13, False; 14, dictionary_splat_pattern; 14, 15; 15, identifier:kwargs; 16, block; 16, 17; 16, 25; 16, 35; 16, 45; 16, 53; 16, 67; 16, 85; 16, 119; 16, 158; 16, 193; 16, 238; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:parser; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:argparse; 23, identifier:ArgumentParser; 24, argument_list; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:parser; 29, identifier:add_argument; 30, argument_list; 30, 31; 30, 32; 31, string:'--no_input'; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:action; 34, string:'store_true'; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:parser; 39, identifier:add_argument; 40, argument_list; 40, 41; 40, 42; 41, string:'--create_new'; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:action; 44, string:'store_true'; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:args; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:parser; 51, identifier:parse_args; 52, argument_list; 53, if_statement; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:args; 56, identifier:no_input; 57, block; 57, 58; 57, 63; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:print; 61, argument_list; 61, 62; 62, string:'Parameter --no_input was given'; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:no_input; 66, True; 67, if_statement; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:args; 70, identifier:create_new; 71, block; 71, 72; 71, 77; 71, 81; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:print; 75, argument_list; 75, 76; 76, string:'Parameter --create_new was given'; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:create_new; 80, True; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:no_input; 84, True; 85, function_definition; 85, 86; 85, 87; 85, 88; 86, function_name:savefile_more_recent; 87, parameters; 88, block; 88, 89; 88, 100; 88, 115; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:time_savefile; 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:getmtime; 98, argument_list; 98, 99; 99, identifier:filename; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:time_program; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:os; 107, identifier:path; 108, identifier:getmtime; 109, argument_list; 109, 110; 110, subscript; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:sys; 113, identifier:argv; 114, integer:0; 115, return_statement; 115, 116; 116, comparison_operator:>; 116, 117; 116, 118; 117, identifier:time_savefile; 118, identifier:time_program; 119, function_definition; 119, 120; 119, 121; 119, 122; 120, function_name:load_pickle; 121, parameters; 122, block; 122, 123; 122, 146; 122, 156; 123, with_statement; 123, 124; 123, 134; 124, with_clause; 124, 125; 125, with_item; 125, 126; 126, as_pattern; 126, 127; 126, 132; 127, call; 127, 128; 127, 129; 128, identifier:open; 129, argument_list; 129, 130; 129, 131; 130, identifier:filename; 131, string:'rb'; 132, as_pattern_target; 132, 133; 133, identifier:of; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 140; 137, pattern_list; 137, 138; 137, 139; 138, identifier:statefile_version; 139, identifier:data; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:pickle; 143, identifier:load; 144, argument_list; 144, 145; 145, identifier:of; 146, if_statement; 146, 147; 146, 150; 147, comparison_operator:!=; 147, 148; 147, 149; 148, identifier:statefile_version; 149, identifier:STATEFILE_VERSION; 150, block; 150, 151; 151, raise_statement; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:RuntimeError; 154, argument_list; 154, 155; 155, string:f'Wrong statefile version, please remove state file {filename}'; 156, return_statement; 156, 157; 157, identifier:data; 158, function_definition; 158, 159; 158, 160; 158, 161; 159, function_name:load; 160, parameters; 161, block; 161, 162; 161, 169; 161, 177; 161, 191; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:print; 165, argument_list; 165, 166; 166, binary_operator:%; 166, 167; 166, 168; 167, string:'Loading %s'; 168, identifier:filename; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 174; 171, pattern_list; 171, 172; 171, 173; 172, identifier:obj_list; 173, identifier:config; 174, call; 174, 175; 174, 176; 175, identifier:load_pickle; 176, argument_list; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:system; 180, call; 180, 181; 180, 182; 181, identifier:System; 182, argument_list; 182, 183; 182, 186; 182, 189; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:load_state; 185, identifier:obj_list; 186, keyword_argument; 186, 187; 186, 188; 187, identifier:filename; 188, identifier:filename; 189, dictionary_splat; 189, 190; 190, identifier:kwargs; 191, return_statement; 191, 192; 192, identifier:system; 193, function_definition; 193, 194; 193, 195; 193, 196; 194, function_name:create; 195, parameters; 196, block; 196, 197; 196, 202; 196, 206; 196, 226; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 200; 199, identifier:print; 200, argument_list; 200, 201; 201, string:'Creating new system'; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:config; 205, None; 206, if_statement; 206, 207; 206, 208; 207, identifier:filename; 208, block; 208, 209; 209, try_statement; 209, 210; 209, 219; 210, block; 210, 211; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 216; 213, pattern_list; 213, 214; 213, 215; 214, identifier:obj_list; 215, identifier:config; 216, call; 216, 217; 216, 218; 217, identifier:load_pickle; 218, argument_list; 219, except_clause; 219, 220; 219, 221; 220, identifier:FileNotFoundError; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:config; 225, None; 226, return_statement; 226, 227; 227, call; 227, 228; 227, 229; 228, identifier:cls; 229, argument_list; 229, 230; 229, 233; 229, 236; 230, keyword_argument; 230, 231; 230, 232; 231, identifier:filename; 232, identifier:filename; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:load_config; 235, identifier:config; 236, dictionary_splat; 236, 237; 237, identifier:kwargs; 238, if_statement; 238, 239; 238, 249; 238, 304; 239, boolean_operator:and; 239, 240; 239, 241; 240, identifier:filename; 241, call; 241, 242; 241, 247; 242, attribute; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:os; 245, identifier:path; 246, identifier:isfile; 247, argument_list; 247, 248; 248, identifier:filename; 249, block; 249, 250; 250, if_statement; 250, 251; 250, 257; 250, 262; 251, boolean_operator:and; 251, 252; 251, 255; 252, call; 252, 253; 252, 254; 253, identifier:savefile_more_recent; 254, argument_list; 255, not_operator; 255, 256; 256, identifier:create_new; 257, block; 257, 258; 258, return_statement; 258, 259; 259, call; 259, 260; 259, 261; 260, identifier:load; 261, argument_list; 262, else_clause; 262, 263; 263, block; 263, 264; 263, 276; 264, if_statement; 264, 265; 264, 266; 265, identifier:no_input; 266, block; 266, 267; 266, 272; 267, expression_statement; 267, 268; 268, call; 268, 269; 268, 270; 269, identifier:print; 270, argument_list; 270, 271; 271, string:'Program file more recent. Loading that instead.'; 272, return_statement; 272, 273; 273, call; 273, 274; 273, 275; 274, identifier:create; 275, argument_list; 276, while_statement; 276, 277; 276, 278; 277, True; 278, block; 278, 279; 278, 286; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:answer; 282, call; 282, 283; 282, 284; 283, identifier:input; 284, argument_list; 284, 285; 285, string:'Program file more recent. Do you want to load it? (y/n) '; 286, if_statement; 286, 287; 286, 290; 286, 295; 287, comparison_operator:==; 287, 288; 287, 289; 288, identifier:answer; 289, string:'y'; 290, block; 290, 291; 291, return_statement; 291, 292; 292, call; 292, 293; 292, 294; 293, identifier:create; 294, argument_list; 295, elif_clause; 295, 296; 295, 299; 296, comparison_operator:==; 296, 297; 296, 298; 297, identifier:answer; 298, string:'n'; 299, block; 299, 300; 300, return_statement; 300, 301; 301, call; 301, 302; 301, 303; 302, identifier:load; 303, argument_list; 304, else_clause; 304, 305; 305, block; 305, 306; 306, return_statement; 306, 307; 307, call; 307, 308; 307, 309; 308, identifier:create; 309, argument_list | def load_or_create(cls, filename=None, no_input=False, create_new=False, **kwargs):
parser = argparse.ArgumentParser()
parser.add_argument('--no_input', action='store_true')
parser.add_argument('--create_new', action='store_true')
args = parser.parse_args()
if args.no_input:
print('Parameter --no_input was given')
no_input = True
if args.create_new:
print('Parameter --create_new was given')
create_new = True
no_input = True
def savefile_more_recent():
time_savefile = os.path.getmtime(filename)
time_program = os.path.getmtime(sys.argv[0])
return time_savefile > time_program
def load_pickle():
with open(filename, 'rb') as of:
statefile_version, data = pickle.load(of)
if statefile_version != STATEFILE_VERSION:
raise RuntimeError(f'Wrong statefile version, please remove state file {filename}')
return data
def load():
print('Loading %s' % filename)
obj_list, config = load_pickle()
system = System(load_state=obj_list, filename=filename, **kwargs)
return system
def create():
print('Creating new system')
config = None
if filename:
try:
obj_list, config = load_pickle()
except FileNotFoundError:
config = None
return cls(filename=filename, load_config=config, **kwargs)
if filename and os.path.isfile(filename):
if savefile_more_recent() and not create_new:
return load()
else:
if no_input:
print('Program file more recent. Loading that instead.')
return create()
while True:
answer = input('Program file more recent. Do you want to load it? (y/n) ')
if answer == 'y':
return create()
elif answer == 'n':
return load()
else:
return create() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:cleanup; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 24; 5, 45; 5, 54; 5, 66; 5, 75; 5, 97; 5, 106; 5, 123; 5, 132; 5, 154; 5, 163; 5, 190; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:pre_exit_trigger; 11, True; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:logger; 18, identifier:info; 19, argument_list; 19, 20; 19, 21; 20, string:"Shutting down %s, please wait a moment."; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:name; 24, for_statement; 24, 25; 24, 26; 24, 31; 25, identifier:t; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:threading; 29, identifier:enumerate; 30, argument_list; 31, block; 31, 32; 32, if_statement; 32, 33; 32, 38; 33, call; 33, 34; 33, 35; 34, identifier:isinstance; 35, argument_list; 35, 36; 35, 37; 36, identifier:t; 37, identifier:TimerClass; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:t; 43, identifier:cancel; 44, argument_list; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 52; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:logger; 51, identifier:debug; 52, argument_list; 52, 53; 53, string:'Timers cancelled'; 54, for_statement; 54, 55; 54, 56; 54, 59; 55, identifier:i; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:objects; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:i; 64, identifier:cleanup; 65, argument_list; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:logger; 72, identifier:debug; 73, argument_list; 73, 74; 74, string:'Sensors etc cleanups done'; 75, for_statement; 75, 76; 75, 77; 75, 90; 76, identifier:ser; 77, generator_expression; 77, 78; 77, 79; 77, 84; 78, identifier:i; 79, for_in_clause; 79, 80; 79, 81; 80, identifier:i; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:services; 84, if_clause; 84, 85; 85, call; 85, 86; 85, 87; 86, identifier:isinstance; 87, argument_list; 87, 88; 87, 89; 88, identifier:i; 89, identifier:AbstractUserService; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:ser; 95, identifier:cleanup_system; 96, argument_list; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 104; 99, attribute; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:logger; 103, identifier:debug; 104, argument_list; 104, 105; 105, string:'User services cleaned up'; 106, if_statement; 106, 107; 106, 114; 107, call; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:worker_thread; 112, identifier:is_alive; 113, argument_list; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 122; 117, attribute; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:worker_thread; 121, identifier:stop; 122, argument_list; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:logger; 129, identifier:debug; 130, argument_list; 130, 131; 131, string:'Worker thread really stopped'; 132, for_statement; 132, 133; 132, 134; 132, 147; 133, identifier:ser; 134, generator_expression; 134, 135; 134, 136; 134, 141; 135, identifier:i; 136, for_in_clause; 136, 137; 136, 138; 137, identifier:i; 138, attribute; 138, 139; 138, 140; 139, identifier:self; 140, identifier:services; 141, if_clause; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:isinstance; 144, argument_list; 144, 145; 144, 146; 145, identifier:i; 146, identifier:AbstractSystemService; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:ser; 152, identifier:cleanup_system; 153, argument_list; 154, expression_statement; 154, 155; 155, call; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:logger; 160, identifier:debug; 161, argument_list; 161, 162; 162, string:'System services cleaned up'; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:threads; 166, call; 166, 167; 166, 168; 167, identifier:list; 168, generator_expression; 168, 169; 168, 172; 168, 179; 169, attribute; 169, 170; 169, 171; 170, identifier:t; 171, identifier:name; 172, for_in_clause; 172, 173; 172, 174; 173, identifier:t; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:threading; 177, identifier:enumerate; 178, argument_list; 179, if_clause; 179, 180; 180, boolean_operator:and; 180, 181; 180, 186; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:t; 184, identifier:is_alive; 185, argument_list; 186, not_operator; 186, 187; 187, attribute; 187, 188; 187, 189; 188, identifier:t; 189, identifier:daemon; 190, if_statement; 190, 191; 190, 192; 191, identifier:threads; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, call; 194, 195; 194, 200; 195, attribute; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:logger; 199, identifier:info; 200, argument_list; 200, 201; 200, 204; 201, concatenated_string; 201, 202; 201, 203; 202, string:'After cleanup, we have still the following threads '; 203, string:'running: %s'; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, string:', '; 207, identifier:join; 208, argument_list; 208, 209; 209, identifier:threads | def cleanup(self):
self.pre_exit_trigger = True
self.logger.info("Shutting down %s, please wait a moment.", self.name)
for t in threading.enumerate():
if isinstance(t, TimerClass):
t.cancel()
self.logger.debug('Timers cancelled')
for i in self.objects:
i.cleanup()
self.logger.debug('Sensors etc cleanups done')
for ser in (i for i in self.services if isinstance(i, AbstractUserService)):
ser.cleanup_system()
self.logger.debug('User services cleaned up')
if self.worker_thread.is_alive():
self.worker_thread.stop()
self.logger.debug('Worker thread really stopped')
for ser in (i for i in self.services if isinstance(i, AbstractSystemService)):
ser.cleanup_system()
self.logger.debug('System services cleaned up')
threads = list(t.name for t in threading.enumerate() if t.is_alive() and not t.daemon)
if threads:
self.logger.info('After cleanup, we have still the following threads '
'running: %s', ', '.join(threads)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:write_puml; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:filename; 7, string:''; 8, block; 8, 9; 8, 42; 8, 63; 8, 70; 8, 77; 8, 103; 8, 110; 8, 333; 8, 340; 9, function_definition; 9, 10; 9, 11; 9, 13; 10, function_name:get_type; 11, parameters; 11, 12; 12, identifier:o; 13, block; 13, 14; 13, 18; 13, 40; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:type; 17, string:'program'; 18, if_statement; 18, 19; 18, 24; 18, 29; 19, call; 19, 20; 19, 21; 20, identifier:isinstance; 21, argument_list; 21, 22; 21, 23; 22, identifier:o; 23, identifier:AbstractSensor; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:type; 28, string:'sensor'; 29, elif_clause; 29, 30; 29, 35; 30, call; 30, 31; 30, 32; 31, identifier:isinstance; 32, argument_list; 32, 33; 32, 34; 33, identifier:o; 34, identifier:AbstractActuator; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:type; 39, string:'actuator'; 40, return_statement; 40, 41; 41, identifier:type; 42, if_statement; 42, 43; 42, 44; 42, 53; 43, identifier:filename; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:s; 48, call; 48, 49; 48, 50; 49, identifier:open; 50, argument_list; 50, 51; 50, 52; 51, identifier:filename; 52, string:'w'; 53, else_clause; 53, 54; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:s; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:io; 61, identifier:StringIO; 62, argument_list; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:s; 67, identifier:write; 68, argument_list; 68, 69; 69, string:'@startuml\n'; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:s; 74, identifier:write; 75, argument_list; 75, 76; 76, string:'skinparam state {\n'; 77, for_statement; 77, 78; 77, 81; 77, 91; 78, pattern_list; 78, 79; 78, 80; 79, identifier:k; 80, identifier:v; 81, call; 81, 82; 81, 83; 82, identifier:list; 83, argument_list; 83, 84; 84, call; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:background_colors; 89, identifier:items; 90, argument_list; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:s; 96, identifier:write; 97, argument_list; 97, 98; 98, binary_operator:%; 98, 99; 98, 100; 99, string:'BackGroundColor<<%s>> %s\n'; 100, tuple; 100, 101; 100, 102; 101, identifier:k; 102, identifier:v; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:s; 107, identifier:write; 108, argument_list; 108, 109; 109, string:'}\n'; 110, for_statement; 110, 111; 110, 112; 110, 117; 111, identifier:o; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:system; 116, identifier:objects; 117, block; 117, 118; 117, 130; 118, if_statement; 118, 119; 118, 128; 119, boolean_operator:or; 119, 120; 119, 125; 120, call; 120, 121; 120, 122; 121, identifier:isinstance; 122, argument_list; 122, 123; 122, 124; 123, identifier:o; 124, identifier:DefaultProgram; 125, attribute; 125, 126; 125, 127; 126, identifier:o; 127, identifier:hide_in_uml; 128, block; 128, 129; 129, continue_statement; 130, if_statement; 130, 131; 130, 136; 131, call; 131, 132; 131, 133; 132, identifier:isinstance; 133, argument_list; 133, 134; 133, 135; 134, identifier:o; 135, identifier:ProgrammableSystemObject; 136, block; 136, 137; 136, 152; 136, 165; 136, 221; 136, 242; 136, 276; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:s; 141, identifier:write; 142, argument_list; 142, 143; 143, binary_operator:%; 143, 144; 143, 145; 144, string:'state "%s" as %s <<%s>>\n'; 145, tuple; 145, 146; 145, 147; 145, 148; 146, identifier:o; 147, identifier:o; 148, call; 148, 149; 148, 150; 149, identifier:get_type; 150, argument_list; 150, 151; 151, identifier:o; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:s; 156, identifier:write; 157, argument_list; 157, 158; 158, binary_operator:%; 158, 159; 158, 160; 159, string:'%s: %s\n'; 160, tuple; 160, 161; 160, 162; 161, identifier:o; 162, attribute; 162, 163; 162, 164; 163, identifier:o; 164, identifier:class_name; 165, if_statement; 165, 166; 165, 171; 165, 201; 166, call; 166, 167; 166, 168; 167, identifier:isinstance; 168, argument_list; 168, 169; 168, 170; 169, identifier:o; 170, identifier:AbstractActuator; 171, block; 171, 172; 172, for_statement; 172, 173; 172, 174; 172, 180; 173, identifier:p; 174, call; 174, 175; 174, 176; 175, identifier:reversed; 176, argument_list; 176, 177; 177, attribute; 177, 178; 177, 179; 178, identifier:o; 179, identifier:program_stack; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:s; 185, identifier:write; 186, argument_list; 186, 187; 187, binary_operator:%; 187, 188; 187, 189; 188, string:'%s: %s :: %s\n'; 189, tuple; 189, 190; 189, 191; 189, 192; 190, identifier:o; 191, identifier:p; 192, call; 192, 193; 192, 198; 193, attribute; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:o; 196, identifier:program_status; 197, identifier:get; 198, argument_list; 198, 199; 198, 200; 199, identifier:p; 200, string:'-'; 201, elif_clause; 201, 202; 201, 207; 202, call; 202, 203; 202, 204; 203, identifier:hasattr; 204, argument_list; 204, 205; 204, 206; 205, identifier:o; 206, string:'status'; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:s; 212, identifier:write; 213, argument_list; 213, 214; 214, binary_operator:%; 214, 215; 214, 216; 215, string:'%s: Status: %s\n'; 216, tuple; 216, 217; 216, 218; 217, identifier:o; 218, attribute; 218, 219; 218, 220; 219, identifier:o; 220, identifier:status; 221, if_statement; 221, 222; 221, 228; 222, call; 222, 223; 222, 224; 223, identifier:getattr; 224, argument_list; 224, 225; 224, 226; 224, 227; 225, identifier:o; 226, string:'is_program'; 227, False; 228, block; 228, 229; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:s; 233, identifier:write; 234, argument_list; 234, 235; 235, binary_operator:%; 235, 236; 235, 237; 236, string:'%s: Priority: %s\n'; 237, tuple; 237, 238; 237, 239; 238, identifier:o; 239, attribute; 239, 240; 239, 241; 240, identifier:o; 241, identifier:priority; 242, for_statement; 242, 243; 242, 244; 242, 247; 243, identifier:t; 244, attribute; 244, 245; 244, 246; 245, identifier:o; 246, identifier:actual_triggers; 247, block; 247, 248; 247, 260; 248, if_statement; 248, 249; 248, 258; 249, boolean_operator:or; 249, 250; 249, 255; 250, call; 250, 251; 250, 252; 251, identifier:isinstance; 252, argument_list; 252, 253; 252, 254; 253, identifier:t; 254, identifier:DefaultProgram; 255, attribute; 255, 256; 255, 257; 256, identifier:t; 257, identifier:hide_in_uml; 258, block; 258, 259; 259, continue_statement; 260, expression_statement; 260, 261; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:s; 264, identifier:write; 265, argument_list; 265, 266; 266, binary_operator:%; 266, 267; 266, 268; 267, string:'%s -[%s]-> %s\n'; 268, tuple; 268, 269; 268, 270; 268, 275; 269, identifier:t; 270, subscript; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:self; 273, identifier:arrow_colors; 274, string:'trigger'; 275, identifier:o; 276, for_statement; 276, 277; 276, 278; 276, 281; 277, identifier:t; 278, attribute; 278, 279; 278, 280; 279, identifier:o; 280, identifier:actual_targets; 281, block; 281, 282; 281, 288; 281, 303; 281, 317; 282, if_statement; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:t; 285, identifier:hide_in_uml; 286, block; 286, 287; 287, continue_statement; 288, if_statement; 288, 289; 288, 292; 288, 297; 289, attribute; 289, 290; 289, 291; 290, identifier:o; 291, identifier:active; 292, block; 292, 293; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 296; 295, identifier:color; 296, string:'active_target'; 297, else_clause; 297, 298; 298, block; 298, 299; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:color; 302, string:'inactive_target'; 303, if_statement; 303, 304; 303, 312; 304, comparison_operator:==; 304, 305; 304, 311; 305, call; 305, 306; 305, 307; 306, identifier:getattr; 307, argument_list; 307, 308; 307, 309; 307, 310; 308, identifier:t; 309, string:'program'; 310, None; 311, identifier:o; 312, block; 312, 313; 313, expression_statement; 313, 314; 314, assignment; 314, 315; 314, 316; 315, identifier:color; 316, string:'controlled_target'; 317, expression_statement; 317, 318; 318, call; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:s; 321, identifier:write; 322, argument_list; 322, 323; 323, binary_operator:%; 323, 324; 323, 325; 324, string:'%s -[%s]-> %s\n'; 325, tuple; 325, 326; 325, 327; 325, 332; 326, identifier:o; 327, subscript; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:self; 330, identifier:arrow_colors; 331, identifier:color; 332, identifier:t; 333, expression_statement; 333, 334; 334, call; 334, 335; 334, 338; 335, attribute; 335, 336; 335, 337; 336, identifier:s; 337, identifier:write; 338, argument_list; 338, 339; 339, string:'@enduml\n'; 340, if_statement; 340, 341; 340, 342; 340, 349; 341, identifier:filename; 342, block; 342, 343; 343, expression_statement; 343, 344; 344, call; 344, 345; 344, 348; 345, attribute; 345, 346; 345, 347; 346, identifier:s; 347, identifier:close; 348, argument_list; 349, else_clause; 349, 350; 350, block; 350, 351; 351, return_statement; 351, 352; 352, call; 352, 353; 352, 356; 353, attribute; 353, 354; 353, 355; 354, identifier:s; 355, identifier:getvalue; 356, argument_list | def write_puml(self, filename=''):
def get_type(o):
type = 'program'
if isinstance(o, AbstractSensor):
type = 'sensor'
elif isinstance(o, AbstractActuator):
type = 'actuator'
return type
if filename:
s = open(filename, 'w')
else:
s = io.StringIO()
s.write('@startuml\n')
s.write('skinparam state {\n')
for k, v in list(self.background_colors.items()):
s.write('BackGroundColor<<%s>> %s\n' % (k, v))
s.write('}\n')
for o in self.system.objects:
if isinstance(o, DefaultProgram) or o.hide_in_uml:
continue
if isinstance(o, ProgrammableSystemObject):
s.write('state "%s" as %s <<%s>>\n' % (o, o, get_type(o)))
s.write('%s: %s\n' % (o, o.class_name))
if isinstance(o, AbstractActuator):
for p in reversed(o.program_stack):
s.write('%s: %s :: %s\n' % (o, p, o.program_status.get(p, '-')))
elif hasattr(o, 'status'):
s.write('%s: Status: %s\n' % (o, o.status))
if getattr(o, 'is_program', False):
s.write('%s: Priority: %s\n' % (o, o.priority))
for t in o.actual_triggers:
if isinstance(t, DefaultProgram) or t.hide_in_uml:
continue
s.write('%s -[%s]-> %s\n' % (t, self.arrow_colors['trigger'], o))
for t in o.actual_targets:
if t.hide_in_uml:
continue
if o.active:
color = 'active_target'
else:
color = 'inactive_target'
if getattr(t, 'program', None) == o:
color = 'controlled_target'
s.write('%s -[%s]-> %s\n' % (o, self.arrow_colors[color], t))
s.write('@enduml\n')
if filename:
s.close()
else:
return s.getvalue() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:fit; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:X; 6, default_parameter; 6, 7; 6, 8; 7, identifier:y; 8, None; 9, block; 9, 10; 9, 18; 9, 32; 9, 44; 9, 52; 9, 63; 9, 89; 9, 106; 9, 118; 9, 170; 9, 187; 9, 191; 9, 203; 9, 225; 9, 263; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:N; 13, subscript; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:X; 16, identifier:shape; 17, integer:0; 18, if_statement; 18, 19; 18, 22; 19, comparison_operator:is; 19, 20; 19, 21; 20, identifier:y; 21, None; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:y; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:np; 29, identifier:zeros; 30, argument_list; 30, 31; 31, identifier:N; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:classes; 37, call; 37, 38; 37, 39; 38, identifier:list; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:set; 42, argument_list; 42, 43; 43, identifier:y; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:classes; 50, identifier:sort; 51, argument_list; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:n_classes; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:classes; 63, if_statement; 63, 64; 63, 68; 64, not_operator; 64, 65; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:sigma; 68, block; 68, 69; 68, 78; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:sigma; 74, call; 74, 75; 74, 76; 75, identifier:median_kneighbour_distance; 76, argument_list; 76, 77; 77, identifier:X; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:gamma; 83, binary_operator:**; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:sigma; 87, unary_operator:-; 87, 88; 88, integer:2; 89, if_statement; 89, 90; 89, 94; 90, not_operator; 90, 91; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:gamma; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:gamma; 100, binary_operator:**; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:sigma; 104, unary_operator:-; 104, 105; 105, integer:2; 106, if_statement; 106, 107; 106, 111; 107, not_operator; 107, 108; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:rho; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:rho; 117, float:0.1; 118, if_statement; 118, 119; 118, 124; 118, 158; 119, comparison_operator:is; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:kernel_pos; 123, None; 124, block; 124, 125; 124, 135; 124, 146; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:B; 128, call; 128, 129; 128, 130; 129, identifier:min; 130, argument_list; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:n_kernels_max; 134, identifier:N; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:kernel_idx; 138, call; 138, 139; 138, 144; 139, attribute; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:np; 142, identifier:random; 143, identifier:permutation; 144, argument_list; 144, 145; 145, identifier:N; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:kernel_pos; 151, subscript; 151, 152; 151, 153; 152, identifier:X; 153, subscript; 153, 154; 153, 155; 154, identifier:kernel_idx; 155, slice; 155, 156; 155, 157; 156, colon; 157, identifier:B; 158, else_clause; 158, 159; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:B; 163, subscript; 163, 164; 163, 169; 164, attribute; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:kernel_pos; 168, identifier:shape; 169, integer:0; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:Phi; 173, call; 173, 174; 173, 179; 174, attribute; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:metrics; 177, identifier:pairwise; 178, identifier:rbf_kernel; 179, argument_list; 179, 180; 179, 181; 179, 184; 180, identifier:X; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:kernel_pos; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:gamma; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:theta; 190, dictionary; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:Phi_PhiT; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:np; 197, identifier:dot; 198, argument_list; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:Phi; 201, identifier:T; 202, identifier:Phi; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:inverse_term; 206, call; 206, 207; 206, 212; 207, attribute; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:np; 210, identifier:linalg; 211, identifier:inv; 212, argument_list; 212, 213; 213, binary_operator:+; 213, 214; 213, 215; 214, identifier:Phi_PhiT; 215, binary_operator:*; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:rho; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:np; 222, identifier:eye; 223, argument_list; 223, 224; 224, identifier:B; 225, for_statement; 225, 226; 225, 227; 225, 230; 226, identifier:c; 227, attribute; 227, 228; 227, 229; 228, identifier:self; 229, identifier:classes; 230, block; 230, 231; 230, 243; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:m; 234, call; 234, 235; 234, 241; 235, attribute; 235, 236; 235, 240; 236, parenthesized_expression; 236, 237; 237, comparison_operator:==; 237, 238; 237, 239; 238, identifier:y; 239, identifier:c; 240, identifier:astype; 241, argument_list; 241, 242; 242, identifier:int; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 248; 245, subscript; 245, 246; 245, 247; 246, identifier:theta; 247, identifier:c; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:np; 251, identifier:dot; 252, argument_list; 252, 253; 252, 254; 253, identifier:inverse_term; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:np; 257, identifier:dot; 258, argument_list; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:Phi; 261, identifier:T; 262, identifier:m; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:self; 267, identifier:theta; 268, identifier:theta | def fit(self, X, y=None):
N = X.shape[0]
if y is None:
y = np.zeros(N)
self.classes = list(set(y))
self.classes.sort()
self.n_classes = len(self.classes)
if not self.sigma:
self.sigma = median_kneighbour_distance(X)
self.gamma = self.sigma**-2
if not self.gamma:
self.gamma = self.sigma**-2
if not self.rho:
self.rho = 0.1
if self.kernel_pos is None:
B = min(self.n_kernels_max, N)
kernel_idx = np.random.permutation(N)
self.kernel_pos = X[kernel_idx[:B]]
else:
B = self.kernel_pos.shape[0]
Phi = metrics.pairwise.rbf_kernel(X, self.kernel_pos, self.gamma)
theta = {}
Phi_PhiT = np.dot(Phi.T, Phi)
inverse_term = np.linalg.inv(Phi_PhiT + self.rho*np.eye(B))
for c in self.classes:
m = (y == c).astype(int)
theta[c] = np.dot(inverse_term, np.dot(Phi.T, m))
self.theta = theta |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:predict_sequence; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:X; 6, identifier:A; 7, identifier:pi; 8, default_parameter; 8, 9; 8, 10; 9, identifier:inference; 10, string:'smoothing'; 11, block; 11, 12; 11, 21; 11, 29; 11, 40; 11, 48; 11, 114; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:obsll; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:predict_proba; 19, argument_list; 19, 20; 20, identifier:X; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 26; 23, pattern_list; 23, 24; 23, 25; 24, identifier:T; 25, identifier:S; 26, attribute; 26, 27; 26, 28; 27, identifier:obsll; 28, identifier:shape; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:alpha; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:np; 35, identifier:zeros; 36, argument_list; 36, 37; 37, tuple; 37, 38; 37, 39; 38, identifier:T; 39, identifier:S; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 47; 42, subscript; 42, 43; 42, 44; 42, 45; 43, identifier:alpha; 44, integer:0; 45, slice; 45, 46; 46, colon; 47, identifier:pi; 48, for_statement; 48, 49; 48, 50; 48, 55; 49, identifier:t; 50, call; 50, 51; 50, 52; 51, identifier:range; 52, argument_list; 52, 53; 52, 54; 53, integer:1; 54, identifier:T; 55, block; 55, 56; 55, 76; 55, 93; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 63; 58, subscript; 58, 59; 58, 60; 58, 61; 59, identifier:alpha; 60, identifier:t; 61, slice; 61, 62; 62, colon; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:np; 66, identifier:dot; 67, argument_list; 67, 68; 67, 75; 68, subscript; 68, 69; 68, 70; 68, 73; 69, identifier:alpha; 70, binary_operator:-; 70, 71; 70, 72; 71, identifier:t; 72, integer:1; 73, slice; 73, 74; 74, colon; 75, identifier:A; 76, for_statement; 76, 77; 76, 78; 76, 82; 77, identifier:s; 78, call; 78, 79; 78, 80; 79, identifier:range; 80, argument_list; 80, 81; 81, identifier:S; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, augmented_assignment:*=; 84, 85; 84, 89; 85, subscript; 85, 86; 85, 87; 85, 88; 86, identifier:alpha; 87, identifier:t; 88, identifier:s; 89, subscript; 89, 90; 89, 91; 89, 92; 90, identifier:obsll; 91, identifier:t; 92, identifier:s; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 100; 95, subscript; 95, 96; 95, 97; 95, 98; 96, identifier:alpha; 97, identifier:t; 98, slice; 98, 99; 99, colon; 100, binary_operator:/; 100, 101; 100, 106; 101, subscript; 101, 102; 101, 103; 101, 104; 102, identifier:alpha; 103, identifier:t; 104, slice; 104, 105; 105, colon; 106, call; 106, 107; 106, 108; 107, identifier:sum; 108, argument_list; 108, 109; 109, subscript; 109, 110; 109, 111; 109, 112; 110, identifier:alpha; 111, identifier:t; 112, slice; 112, 113; 113, colon; 114, if_statement; 114, 115; 114, 118; 114, 121; 115, comparison_operator:==; 115, 116; 115, 117; 116, identifier:inference; 117, string:'filtering'; 118, block; 118, 119; 119, return_statement; 119, 120; 120, identifier:alpha; 121, else_clause; 121, 122; 122, block; 122, 123; 122, 134; 122, 145; 122, 160; 122, 232; 122, 278; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:beta; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:np; 129, identifier:zeros; 130, argument_list; 130, 131; 131, tuple; 131, 132; 131, 133; 132, identifier:T; 133, identifier:S; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:gamma; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:np; 140, identifier:zeros; 141, argument_list; 141, 142; 142, tuple; 142, 143; 142, 144; 143, identifier:T; 144, identifier:S; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 154; 147, subscript; 147, 148; 147, 149; 147, 152; 148, identifier:beta; 149, binary_operator:-; 149, 150; 149, 151; 150, identifier:T; 151, integer:1; 152, slice; 152, 153; 153, colon; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:np; 157, identifier:ones; 158, argument_list; 158, 159; 159, identifier:S; 160, for_statement; 160, 161; 160, 162; 160, 172; 161, identifier:t; 162, call; 162, 163; 162, 164; 163, identifier:range; 164, argument_list; 164, 165; 164, 168; 164, 170; 165, binary_operator:-; 165, 166; 165, 167; 166, identifier:T; 167, integer:2; 168, unary_operator:-; 168, 169; 169, integer:1; 170, unary_operator:-; 170, 171; 171, integer:1; 172, block; 172, 173; 172, 211; 173, for_statement; 173, 174; 173, 175; 173, 179; 174, identifier:i; 175, call; 175, 176; 175, 177; 176, identifier:range; 177, argument_list; 177, 178; 178, identifier:S; 179, block; 179, 180; 180, for_statement; 180, 181; 180, 182; 180, 186; 181, identifier:j; 182, call; 182, 183; 182, 184; 183, identifier:range; 184, argument_list; 184, 185; 185, identifier:S; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, augmented_assignment:+=; 188, 189; 188, 193; 189, subscript; 189, 190; 189, 191; 189, 192; 190, identifier:beta; 191, identifier:t; 192, identifier:i; 193, binary_operator:*; 193, 194; 193, 205; 194, binary_operator:*; 194, 195; 194, 199; 195, subscript; 195, 196; 195, 197; 195, 198; 196, identifier:A; 197, identifier:i; 198, identifier:j; 199, subscript; 199, 200; 199, 201; 199, 204; 200, identifier:obsll; 201, binary_operator:+; 201, 202; 201, 203; 202, identifier:t; 203, integer:1; 204, identifier:j; 205, subscript; 205, 206; 205, 207; 205, 210; 206, identifier:beta; 207, binary_operator:+; 207, 208; 207, 209; 208, identifier:t; 209, integer:1; 210, identifier:j; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 218; 213, subscript; 213, 214; 213, 215; 213, 216; 214, identifier:beta; 215, identifier:t; 216, slice; 216, 217; 217, colon; 218, binary_operator:/; 218, 219; 218, 224; 219, subscript; 219, 220; 219, 221; 219, 222; 220, identifier:beta; 221, identifier:t; 222, slice; 222, 223; 223, colon; 224, call; 224, 225; 224, 226; 225, identifier:sum; 226, argument_list; 226, 227; 227, subscript; 227, 228; 227, 229; 227, 230; 228, identifier:beta; 229, identifier:t; 230, slice; 230, 231; 231, colon; 232, for_statement; 232, 233; 232, 234; 232, 238; 233, identifier:t; 234, call; 234, 235; 234, 236; 235, identifier:range; 236, argument_list; 236, 237; 237, identifier:T; 238, block; 238, 239; 238, 257; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 246; 241, subscript; 241, 242; 241, 243; 241, 244; 242, identifier:gamma; 243, identifier:t; 244, slice; 244, 245; 245, colon; 246, binary_operator:*; 246, 247; 246, 252; 247, subscript; 247, 248; 247, 249; 247, 250; 248, identifier:alpha; 249, identifier:t; 250, slice; 250, 251; 251, colon; 252, subscript; 252, 253; 252, 254; 252, 255; 253, identifier:beta; 254, identifier:t; 255, slice; 255, 256; 256, colon; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 264; 259, subscript; 259, 260; 259, 261; 259, 262; 260, identifier:gamma; 261, identifier:t; 262, slice; 262, 263; 263, colon; 264, binary_operator:/; 264, 265; 264, 270; 265, subscript; 265, 266; 265, 267; 265, 268; 266, identifier:gamma; 267, identifier:t; 268, slice; 268, 269; 269, colon; 270, call; 270, 271; 270, 272; 271, identifier:sum; 272, argument_list; 272, 273; 273, subscript; 273, 274; 273, 275; 273, 276; 274, identifier:gamma; 275, identifier:t; 276, slice; 276, 277; 277, colon; 278, return_statement; 278, 279; 279, identifier:gamma | def predict_sequence(self, X, A, pi, inference='smoothing'):
obsll = self.predict_proba(X)
T, S = obsll.shape
alpha = np.zeros((T, S))
alpha[0, :] = pi
for t in range(1, T):
alpha[t, :] = np.dot(alpha[t-1, :], A)
for s in range(S):
alpha[t, s] *= obsll[t, s]
alpha[t, :] = alpha[t, :]/sum(alpha[t, :])
if inference == 'filtering':
return alpha
else:
beta = np.zeros((T, S))
gamma = np.zeros((T, S))
beta[T-1, :] = np.ones(S)
for t in range(T-2, -1, -1):
for i in range(S):
for j in range(S):
beta[t, i] += A[i, j]*obsll[t+1, j]*beta[t+1, j]
beta[t, :] = beta[t, :]/sum(beta[t, :])
for t in range(T):
gamma[t, :] = alpha[t, :]*beta[t, :]
gamma[t, :] = gamma[t, :]/sum(gamma[t, :])
return gamma |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:add_bgcolor; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:colname; 6, default_parameter; 6, 7; 6, 8; 7, identifier:cmap; 8, string:'copper'; 9, default_parameter; 9, 10; 9, 11; 10, identifier:mode; 11, string:'absmax'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:threshold; 14, integer:2; 15, block; 15, 16; 15, 28; 15, 38; 15, 47; 15, 148; 15, 164; 15, 179; 15, 189; 15, 216; 15, 227; 15, 231; 16, try_statement; 16, 17; 16, 25; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:cmap; 21, call; 21, 22; 21, 23; 22, identifier:cmap_builder; 23, argument_list; 23, 24; 24, identifier:cmap; 25, except_clause; 25, 26; 26, block; 26, 27; 27, pass_statement; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:data; 31, attribute; 31, 32; 31, 37; 32, subscript; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:df; 36, identifier:colname; 37, identifier:values; 38, if_statement; 38, 39; 38, 45; 39, comparison_operator:==; 39, 40; 39, 44; 40, call; 40, 41; 40, 42; 41, identifier:len; 42, argument_list; 42, 43; 43, identifier:data; 44, integer:0; 45, block; 45, 46; 46, return_statement; 47, if_statement; 47, 48; 47, 51; 47, 69; 47, 121; 48, comparison_operator:==; 48, 49; 48, 50; 49, identifier:mode; 50, string:'clip'; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:data; 55, list_comprehension; 55, 56; 55, 66; 56, binary_operator:/; 56, 57; 56, 62; 57, call; 57, 58; 57, 59; 58, identifier:min; 59, argument_list; 59, 60; 59, 61; 60, identifier:x; 61, identifier:threshold; 62, call; 62, 63; 62, 64; 63, identifier:float; 64, argument_list; 64, 65; 65, identifier:threshold; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:x; 68, identifier:data; 69, elif_clause; 69, 70; 69, 73; 70, comparison_operator:==; 70, 71; 70, 72; 71, identifier:mode; 72, string:'absmax'; 73, block; 73, 74; 73, 85; 73, 96; 73, 105; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:m; 77, call; 77, 78; 77, 79; 78, identifier:abs; 79, argument_list; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:data; 83, identifier:min; 84, argument_list; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:M; 88, call; 88, 89; 88, 90; 89, identifier:abs; 90, argument_list; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:data; 94, identifier:max; 95, argument_list; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:M; 99, call; 99, 100; 99, 101; 100, identifier:max; 101, argument_list; 101, 102; 102, list:[m, M]; 102, 103; 102, 104; 103, identifier:m; 104, identifier:M; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:!=; 106, 107; 106, 108; 107, identifier:M; 108, integer:0; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:data; 113, binary_operator:/; 113, 114; 113, 120; 114, parenthesized_expression; 114, 115; 115, binary_operator:+; 115, 116; 115, 119; 116, binary_operator:/; 116, 117; 116, 118; 117, identifier:data; 118, identifier:M; 119, integer:1; 120, float:2.; 121, elif_clause; 121, 122; 121, 125; 122, comparison_operator:==; 122, 123; 122, 124; 123, identifier:mode; 124, string:'max'; 125, block; 125, 126; 126, if_statement; 126, 127; 126, 134; 127, comparison_operator:!=; 127, 128; 127, 133; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:data; 131, identifier:max; 132, argument_list; 133, integer:0; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:data; 138, binary_operator:/; 138, 139; 138, 140; 139, identifier:data; 140, call; 140, 141; 140, 142; 141, identifier:float; 142, argument_list; 142, 143; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:data; 146, identifier:max; 147, argument_list; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:rgbcolors; 151, list_comprehension; 151, 152; 151, 161; 152, subscript; 152, 153; 152, 157; 153, call; 153, 154; 153, 155; 154, identifier:cmap; 155, argument_list; 155, 156; 156, identifier:x; 157, slice; 157, 158; 157, 159; 157, 160; 158, integer:0; 159, colon; 160, integer:3; 161, for_in_clause; 161, 162; 161, 163; 162, identifier:x; 163, identifier:data; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:hexcolors; 167, list_comprehension; 167, 168; 167, 176; 168, call; 168, 169; 168, 170; 169, identifier:rgb2hex; 170, argument_list; 170, 171; 170, 173; 171, list_splat; 171, 172; 172, identifier:x; 173, keyword_argument; 173, 174; 173, 175; 174, identifier:normalised; 175, True; 176, for_in_clause; 176, 177; 176, 178; 177, identifier:x; 178, identifier:rgbcolors; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:data; 182, attribute; 182, 183; 182, 188; 183, subscript; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:df; 187, identifier:colname; 188, identifier:values; 189, function_definition; 189, 190; 189, 191; 189, 193; 190, function_name:prec; 191, parameters; 191, 192; 192, identifier:x; 193, block; 193, 194; 194, try_statement; 194, 195; 194, 212; 195, block; 195, 196; 195, 210; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:x; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:easydev; 202, identifier:precision; 203, argument_list; 203, 204; 203, 205; 204, identifier:x; 205, subscript; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:self; 208, identifier:pd_options; 209, string:'precision'; 210, return_statement; 210, 211; 211, identifier:x; 212, except_clause; 212, 213; 213, block; 213, 214; 214, return_statement; 214, 215; 215, identifier:x; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:data; 219, list_comprehension; 219, 220; 219, 224; 220, call; 220, 221; 220, 222; 221, identifier:prec; 222, argument_list; 222, 223; 223, identifier:x; 224, for_in_clause; 224, 225; 224, 226; 225, identifier:x; 226, identifier:data; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:html_formatter; 230, string:'<p style="background-color:{0}">{1}</p>'; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 238; 233, subscript; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:self; 236, identifier:df; 237, identifier:colname; 238, list_comprehension; 238, 239; 238, 246; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:html_formatter; 242, identifier:format; 243, argument_list; 243, 244; 243, 245; 244, identifier:x; 245, identifier:y; 246, for_in_clause; 246, 247; 246, 250; 247, pattern_list; 247, 248; 247, 249; 248, identifier:x; 249, identifier:y; 250, call; 250, 251; 250, 252; 251, identifier:zip; 252, argument_list; 252, 253; 252, 254; 253, identifier:hexcolors; 254, identifier:data | def add_bgcolor(self, colname, cmap='copper', mode='absmax',
threshold=2):
try:
cmap = cmap_builder(cmap)
except:
pass
data = self.df[colname].values
if len(data) == 0:
return
if mode == 'clip':
data = [min(x, threshold)/float(threshold) for x in data]
elif mode == 'absmax':
m = abs(data.min())
M = abs(data.max())
M = max([m, M])
if M != 0:
data = (data / M + 1)/2.
elif mode == 'max':
if data.max() != 0:
data = data / float(data.max())
rgbcolors = [cmap(x)[0:3] for x in data]
hexcolors = [rgb2hex(*x, normalised=True) for x in rgbcolors]
data = self.df[colname].values
def prec(x):
try:
x = easydev.precision(x, self.pd_options['precision'])
return x
except:
return x
data = [prec(x) for x in data]
html_formatter = '<p style="background-color:{0}">{1}</p>'
self.df[colname] = [html_formatter.format(x, y)
for x, y in zip(hexcolors, data)] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:list; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:filter; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:type; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:limit; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:page; 19, None; 20, block; 20, 21; 20, 27; 20, 45; 20, 65; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:schema; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:LIST_SCHEMA; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:resp; 30, call; 30, 31; 30, 36; 31, attribute; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:service; 35, identifier:list; 36, argument_list; 36, 37; 36, 40; 36, 41; 36, 42; 36, 43; 36, 44; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:base; 40, identifier:filter; 41, identifier:type; 42, identifier:sort; 43, identifier:limit; 44, identifier:page; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, pattern_list; 47, 48; 47, 49; 48, identifier:cs; 49, identifier:l; 50, call; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:service; 55, identifier:decode; 56, argument_list; 56, 57; 56, 58; 56, 59; 56, 62; 57, identifier:schema; 58, identifier:resp; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:many; 61, True; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:links; 64, True; 65, return_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:Page; 68, argument_list; 68, 69; 68, 70; 69, identifier:cs; 70, identifier:l | def list(self, filter=None, type=None, sort=None, limit=None, page=None):
schema = self.LIST_SCHEMA
resp = self.service.list(self.base, filter, type, sort, limit, page)
cs, l = self.service.decode(schema, resp, many=True, links=True)
return Page(cs, l) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:signup_handler; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:remote; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 20; 9, 27; 9, 36; 9, 45; 9, 70; 9, 79; 9, 302; 9, 313; 9, 331; 10, if_statement; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:current_user; 13, identifier:is_authenticated; 14, block; 14, 15; 15, return_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:redirect; 18, argument_list; 18, 19; 19, string:'/'; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:oauth_token; 23, call; 23, 24; 23, 25; 24, identifier:token_getter; 25, argument_list; 25, 26; 26, identifier:remote; 27, if_statement; 27, 28; 27, 30; 28, not_operator; 28, 29; 29, identifier:oauth_token; 30, block; 30, 31; 31, return_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:redirect; 34, argument_list; 34, 35; 35, string:'/'; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:session_prefix; 39, call; 39, 40; 39, 41; 40, identifier:token_session_key; 41, argument_list; 41, 42; 42, attribute; 42, 43; 42, 44; 43, identifier:remote; 44, identifier:name; 45, if_statement; 45, 46; 45, 56; 46, not_operator; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:session; 50, identifier:get; 51, argument_list; 51, 52; 51, 55; 52, binary_operator:+; 52, 53; 52, 54; 53, identifier:session_prefix; 54, string:'_autoregister'; 55, False; 56, block; 56, 57; 57, return_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:redirect; 60, argument_list; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:url_for; 63, argument_list; 63, 64; 63, 65; 64, string:'.login'; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:remote_app; 67, attribute; 67, 68; 67, 69; 68, identifier:remote; 69, identifier:name; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:form; 73, call; 73, 74; 73, 75; 74, identifier:create_registrationform; 75, argument_list; 75, 76; 76, attribute; 76, 77; 76, 78; 77, identifier:request; 78, identifier:form; 79, if_statement; 79, 80; 79, 85; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:form; 83, identifier:validate_on_submit; 84, argument_list; 85, block; 85, 86; 85, 97; 85, 108; 85, 115; 85, 126; 85, 136; 85, 154; 85, 164; 85, 175; 85, 237; 85, 258; 85, 268; 85, 278; 85, 287; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:account_info; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:session; 92, identifier:get; 93, argument_list; 93, 94; 94, binary_operator:+; 94, 95; 94, 96; 95, identifier:session_prefix; 96, string:'_account_info'; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:response; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:session; 103, identifier:get; 104, argument_list; 104, 105; 105, binary_operator:+; 105, 106; 105, 107; 106, identifier:session_prefix; 107, string:'_response'; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:user; 111, call; 111, 112; 111, 113; 112, identifier:oauth_register; 113, argument_list; 113, 114; 114, identifier:form; 115, if_statement; 115, 116; 115, 119; 116, comparison_operator:is; 116, 117; 116, 118; 117, identifier:user; 118, None; 119, block; 119, 120; 120, raise_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:OAuthError; 123, argument_list; 123, 124; 123, 125; 124, string:'Could not create user.'; 125, identifier:remote; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:session; 130, identifier:pop; 131, argument_list; 131, 132; 131, 135; 132, binary_operator:+; 132, 133; 132, 134; 133, identifier:session_prefix; 134, string:'_autoregister'; 135, None; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:token; 139, call; 139, 140; 139, 141; 140, identifier:token_setter; 141, argument_list; 141, 142; 141, 143; 141, 146; 141, 151; 142, identifier:remote; 143, subscript; 143, 144; 143, 145; 144, identifier:oauth_token; 145, integer:0; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:secret; 148, subscript; 148, 149; 148, 150; 149, identifier:oauth_token; 150, integer:1; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:user; 153, identifier:user; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:handlers; 157, subscript; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:current_oauthclient; 160, identifier:signup_handlers; 161, attribute; 161, 162; 161, 163; 162, identifier:remote; 163, identifier:name; 164, if_statement; 164, 165; 164, 168; 165, comparison_operator:is; 165, 166; 165, 167; 166, identifier:token; 167, None; 168, block; 168, 169; 169, raise_statement; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:OAuthError; 172, argument_list; 172, 173; 172, 174; 173, string:'Could not create token for user.'; 174, identifier:remote; 175, if_statement; 175, 176; 175, 182; 175, 227; 176, not_operator; 176, 177; 177, attribute; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:token; 180, identifier:remote_account; 181, identifier:extra_data; 182, block; 182, 183; 182, 193; 182, 209; 182, 217; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:account_setup; 186, call; 186, 187; 186, 190; 187, subscript; 187, 188; 187, 189; 188, identifier:handlers; 189, string:'setup'; 190, argument_list; 190, 191; 190, 192; 191, identifier:token; 192, identifier:response; 193, expression_statement; 193, 194; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:account_setup_received; 197, identifier:send; 198, argument_list; 198, 199; 198, 200; 198, 203; 198, 206; 199, identifier:remote; 200, keyword_argument; 200, 201; 200, 202; 201, identifier:token; 202, identifier:token; 203, keyword_argument; 203, 204; 203, 205; 204, identifier:response; 205, identifier:response; 206, keyword_argument; 206, 207; 206, 208; 207, identifier:account_setup; 208, identifier:account_setup; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 216; 211, attribute; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:db; 214, identifier:session; 215, identifier:commit; 216, argument_list; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:account_setup_committed; 221, identifier:send; 222, argument_list; 222, 223; 222, 224; 223, identifier:remote; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:token; 226, identifier:token; 227, else_clause; 227, 228; 228, block; 228, 229; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 236; 231, attribute; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:db; 234, identifier:session; 235, identifier:commit; 236, argument_list; 237, if_statement; 237, 238; 237, 249; 238, not_operator; 238, 239; 239, call; 239, 240; 239, 241; 240, identifier:oauth_authenticate; 241, argument_list; 241, 242; 241, 245; 241, 246; 242, attribute; 242, 243; 242, 244; 243, identifier:remote; 244, identifier:consumer_key; 245, identifier:user; 246, keyword_argument; 246, 247; 246, 248; 247, identifier:require_existing_link; 248, False; 249, block; 249, 250; 250, return_statement; 250, 251; 251, call; 251, 252; 251, 253; 252, identifier:redirect; 253, argument_list; 253, 254; 254, call; 254, 255; 254, 256; 255, identifier:url_for; 256, argument_list; 256, 257; 257, string:'security.login'; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:session; 262, identifier:pop; 263, argument_list; 263, 264; 263, 267; 264, binary_operator:+; 264, 265; 264, 266; 265, identifier:session_prefix; 266, string:'_account_info'; 267, None; 268, expression_statement; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:session; 272, identifier:pop; 273, argument_list; 273, 274; 273, 277; 274, binary_operator:+; 274, 275; 274, 276; 275, identifier:session_prefix; 276, string:'_response'; 277, None; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:next_url; 281, call; 281, 282; 281, 283; 282, identifier:get_session_next_url; 283, argument_list; 283, 284; 284, attribute; 284, 285; 284, 286; 285, identifier:remote; 286, identifier:name; 287, if_statement; 287, 288; 287, 289; 287, 295; 288, identifier:next_url; 289, block; 289, 290; 290, return_statement; 290, 291; 291, call; 291, 292; 291, 293; 292, identifier:redirect; 293, argument_list; 293, 294; 294, identifier:next_url; 295, else_clause; 295, 296; 296, block; 296, 297; 297, return_statement; 297, 298; 298, call; 298, 299; 298, 300; 299, identifier:redirect; 300, argument_list; 300, 301; 301, string:'/'; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 305; 304, identifier:account_info; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:session; 308, identifier:get; 309, argument_list; 309, 310; 310, binary_operator:+; 310, 311; 310, 312; 311, identifier:session_prefix; 312, string:'_account_info'; 313, if_statement; 313, 314; 313, 320; 314, not_operator; 314, 315; 315, call; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:form; 318, identifier:is_submitted; 319, argument_list; 320, block; 320, 321; 321, expression_statement; 321, 322; 322, assignment; 322, 323; 322, 324; 323, identifier:form; 324, call; 324, 325; 324, 326; 325, identifier:fill_form; 326, argument_list; 326, 327; 326, 328; 327, identifier:form; 328, subscript; 328, 329; 328, 330; 329, identifier:account_info; 330, string:'user'; 331, return_statement; 331, 332; 332, call; 332, 333; 332, 334; 333, identifier:render_template; 334, argument_list; 334, 335; 334, 340; 334, 343; 334, 346; 334, 363; 334, 380; 335, subscript; 335, 336; 335, 339; 336, attribute; 336, 337; 336, 338; 337, identifier:current_app; 338, identifier:config; 339, string:'OAUTHCLIENT_SIGNUP_TEMPLATE'; 340, keyword_argument; 340, 341; 340, 342; 341, identifier:form; 342, identifier:form; 343, keyword_argument; 343, 344; 343, 345; 344, identifier:remote; 345, identifier:remote; 346, keyword_argument; 346, 347; 346, 348; 347, identifier:app_title; 348, call; 348, 349; 348, 360; 349, attribute; 349, 350; 349, 359; 350, subscript; 350, 351; 350, 356; 351, subscript; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:current_app; 354, identifier:config; 355, string:'OAUTHCLIENT_REMOTE_APPS'; 356, attribute; 356, 357; 356, 358; 357, identifier:remote; 358, identifier:name; 359, identifier:get; 360, argument_list; 360, 361; 360, 362; 361, string:'title'; 362, string:''; 363, keyword_argument; 363, 364; 363, 365; 364, identifier:app_description; 365, call; 365, 366; 365, 377; 366, attribute; 366, 367; 366, 376; 367, subscript; 367, 368; 367, 373; 368, subscript; 368, 369; 368, 372; 369, attribute; 369, 370; 369, 371; 370, identifier:current_app; 371, identifier:config; 372, string:'OAUTHCLIENT_REMOTE_APPS'; 373, attribute; 373, 374; 373, 375; 374, identifier:remote; 375, identifier:name; 376, identifier:get; 377, argument_list; 377, 378; 377, 379; 378, string:'description'; 379, string:''; 380, keyword_argument; 380, 381; 380, 382; 381, identifier:app_icon; 382, call; 382, 383; 382, 394; 383, attribute; 383, 384; 383, 393; 384, subscript; 384, 385; 384, 390; 385, subscript; 385, 386; 385, 389; 386, attribute; 386, 387; 386, 388; 387, identifier:current_app; 388, identifier:config; 389, string:'OAUTHCLIENT_REMOTE_APPS'; 390, attribute; 390, 391; 390, 392; 391, identifier:remote; 392, identifier:name; 393, identifier:get; 394, argument_list; 394, 395; 394, 396; 395, string:'icon'; 396, None | def signup_handler(remote, *args, **kwargs):
if current_user.is_authenticated:
return redirect('/')
oauth_token = token_getter(remote)
if not oauth_token:
return redirect('/')
session_prefix = token_session_key(remote.name)
if not session.get(session_prefix + '_autoregister', False):
return redirect(url_for('.login', remote_app=remote.name))
form = create_registrationform(request.form)
if form.validate_on_submit():
account_info = session.get(session_prefix + '_account_info')
response = session.get(session_prefix + '_response')
user = oauth_register(form)
if user is None:
raise OAuthError('Could not create user.', remote)
session.pop(session_prefix + '_autoregister', None)
token = token_setter(remote, oauth_token[0], secret=oauth_token[1],
user=user)
handlers = current_oauthclient.signup_handlers[remote.name]
if token is None:
raise OAuthError('Could not create token for user.', remote)
if not token.remote_account.extra_data:
account_setup = handlers['setup'](token, response)
account_setup_received.send(
remote, token=token, response=response,
account_setup=account_setup
)
db.session.commit()
account_setup_committed.send(remote, token=token)
else:
db.session.commit()
if not oauth_authenticate(remote.consumer_key, user,
require_existing_link=False):
return redirect(url_for('security.login'))
session.pop(session_prefix + '_account_info', None)
session.pop(session_prefix + '_response', None)
next_url = get_session_next_url(remote.name)
if next_url:
return redirect(next_url)
else:
return redirect('/')
account_info = session.get(session_prefix + '_account_info')
if not form.is_submitted():
form = fill_form(form, account_info['user'])
return render_template(
current_app.config['OAUTHCLIENT_SIGNUP_TEMPLATE'],
form=form,
remote=remote,
app_title=current_app.config['OAUTHCLIENT_REMOTE_APPS'][
remote.name].get('title', ''),
app_description=current_app.config['OAUTHCLIENT_REMOTE_APPS'][
remote.name].get('description', ''),
app_icon=current_app.config['OAUTHCLIENT_REMOTE_APPS'][
remote.name].get('icon', None),
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:list_csv; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:filter; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:type; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:limit; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:page; 19, None; 20, block; 20, 21; 21, return_statement; 21, 22; 22, attribute; 22, 23; 22, 41; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:service; 28, identifier:list; 29, argument_list; 29, 30; 29, 33; 29, 34; 29, 35; 29, 36; 29, 37; 29, 38; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:base; 33, identifier:filter; 34, identifier:type; 35, identifier:sort; 36, identifier:limit; 37, identifier:page; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:format; 40, string:'csv'; 41, identifier:text | def list_csv(self, filter=None, type=None, sort=None, limit=None, page=None):
return self.service.list(self.base, filter, type, sort, limit, page, format='csv').text |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:list_logdir; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:id; 6, default_parameter; 6, 7; 6, 8; 7, identifier:filter; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, None; 12, block; 12, 13; 12, 19; 12, 41; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:schema; 16, call; 16, 17; 16, 18; 17, identifier:LogDirFileSchema; 18, argument_list; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:resp; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:service; 27, identifier:list; 28, argument_list; 28, 29; 28, 39; 28, 40; 29, binary_operator:+; 29, 30; 29, 38; 30, binary_operator:+; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:base; 34, call; 34, 35; 34, 36; 35, identifier:str; 36, argument_list; 36, 37; 37, identifier:id; 38, string:'/logdir/'; 39, identifier:filter; 40, identifier:sort; 41, return_statement; 41, 42; 42, call; 42, 43; 42, 48; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:service; 47, identifier:decode; 48, argument_list; 48, 49; 48, 50; 48, 51; 49, identifier:schema; 50, identifier:resp; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:many; 53, True | def list_logdir(self, id, filter=None, sort=None):
schema = LogDirFileSchema()
resp = self.service.list(self.base+str(id)+'/logdir/', filter, sort)
return self.service.decode(schema, resp, many=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_init_report; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 18; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:sections; 11, list:[]; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:section_names; 17, list:[]; 18, try_statement; 18, 19; 18, 86; 18, 90; 19, block; 19, 20; 19, 60; 20, if_statement; 20, 21; 20, 33; 21, comparison_operator:is; 21, 22; 21, 32; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:os; 26, identifier:path; 27, identifier:isdir; 28, argument_list; 28, 29; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:directory; 32, False; 33, block; 33, 34; 33, 51; 34, if_statement; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:verbose; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:print; 42, argument_list; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, string:"Created directory {}"; 46, identifier:format; 47, argument_list; 47, 48; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:directory; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:os; 55, identifier:mkdir; 56, argument_list; 56, 57; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:directory; 60, for_statement; 60, 61; 60, 62; 60, 65; 61, identifier:this; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:_to_create; 65, block; 65, 66; 66, try_statement; 66, 67; 66, 83; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:os; 72, identifier:mkdir; 73, argument_list; 73, 74; 74, binary_operator:+; 74, 75; 74, 82; 75, binary_operator:+; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:directory; 79, attribute; 79, 80; 79, 81; 80, identifier:os; 81, identifier:sep; 82, identifier:this; 83, except_clause; 83, 84; 84, block; 84, 85; 85, pass_statement; 86, except_clause; 86, 87; 86, 88; 87, identifier:Exception; 88, block; 88, 89; 89, pass_statement; 90, finally_clause; 90, 91; 91, block; 91, 92; 91, 101; 91, 115; 91, 134; 91, 154; 91, 160; 91, 199; 91, 256; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:temp_path; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:easydev; 98, identifier:get_package_location; 99, argument_list; 99, 100; 100, string:"reports"; 101, expression_statement; 101, 102; 102, augmented_assignment:+=; 102, 103; 102, 104; 103, identifier:temp_path; 104, binary_operator:+; 104, 105; 104, 114; 105, binary_operator:+; 105, 106; 105, 111; 106, binary_operator:+; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:os; 109, identifier:sep; 110, string:"reports"; 111, attribute; 111, 112; 111, 113; 112, identifier:os; 113, identifier:sep; 114, string:"resources"; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:filenames; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:glob; 121, identifier:glob; 122, argument_list; 122, 123; 123, call; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:os; 127, identifier:sep; 128, identifier:join; 129, argument_list; 129, 130; 130, list:[temp_path, "css", "*.css"]; 130, 131; 130, 132; 130, 133; 131, identifier:temp_path; 132, string:"css"; 133, string:"*.css"; 134, expression_statement; 134, 135; 135, augmented_assignment:+=; 135, 136; 135, 137; 136, identifier:filenames; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:glob; 140, identifier:glob; 141, argument_list; 141, 142; 142, call; 142, 143; 142, 148; 143, attribute; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:os; 146, identifier:sep; 147, identifier:join; 148, argument_list; 148, 149; 149, list:[self.searchpath, '*.css']; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:searchpath; 153, string:'*.css'; 154, expression_statement; 154, 155; 155, augmented_assignment:+=; 155, 156; 155, 157; 156, identifier:filenames; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:extra_css_list; 160, for_statement; 160, 161; 160, 162; 160, 163; 161, identifier:filename; 162, identifier:filenames; 163, block; 163, 164; 163, 179; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:target; 167, call; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:os; 171, identifier:sep; 172, identifier:join; 173, argument_list; 173, 174; 174, list:[self.directory, 'css' ]; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:directory; 178, string:'css'; 179, if_statement; 179, 180; 179, 190; 180, comparison_operator:is; 180, 181; 180, 189; 181, call; 181, 182; 181, 187; 182, attribute; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:os; 185, identifier:path; 186, identifier:isfile; 187, argument_list; 187, 188; 188, identifier:target; 189, False; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:shutil; 195, identifier:copy; 196, argument_list; 196, 197; 196, 198; 197, identifier:filename; 198, identifier:target; 199, for_statement; 199, 200; 199, 201; 199, 205; 200, identifier:filename; 201, list:['sorttable.js', 'highlight.pack.js', "jquery-1.12.3.min.js"]; 201, 202; 201, 203; 201, 204; 202, string:'sorttable.js'; 203, string:'highlight.pack.js'; 204, string:"jquery-1.12.3.min.js"; 205, block; 205, 206; 205, 222; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:target; 209, call; 209, 210; 209, 215; 210, attribute; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:os; 213, identifier:sep; 214, identifier:join; 215, argument_list; 215, 216; 216, list:[self.directory, 'js', filename ]; 216, 217; 216, 220; 216, 221; 217, attribute; 217, 218; 217, 219; 218, identifier:self; 219, identifier:directory; 220, string:'js'; 221, identifier:filename; 222, if_statement; 222, 223; 222, 233; 223, comparison_operator:is; 223, 224; 223, 232; 224, call; 224, 225; 224, 230; 225, attribute; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:os; 228, identifier:path; 229, identifier:isfile; 230, argument_list; 230, 231; 231, identifier:target; 232, False; 233, block; 233, 234; 233, 248; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:filename; 237, call; 237, 238; 237, 243; 238, attribute; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:os; 241, identifier:sep; 242, identifier:join; 243, argument_list; 243, 244; 244, list:[temp_path, "javascript", filename]; 244, 245; 244, 246; 244, 247; 245, identifier:temp_path; 246, string:"javascript"; 247, identifier:filename; 248, expression_statement; 248, 249; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:shutil; 252, identifier:copy; 253, argument_list; 253, 254; 253, 255; 254, identifier:filename; 255, identifier:target; 256, for_statement; 256, 257; 256, 258; 256, 261; 257, identifier:filename; 258, attribute; 258, 259; 258, 260; 259, identifier:self; 260, identifier:extra_js_list; 261, block; 261, 262; 261, 273; 261, 289; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:basename; 265, call; 265, 266; 265, 271; 266, attribute; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:os; 269, identifier:path; 270, identifier:basename; 271, argument_list; 271, 272; 272, identifier:filename; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:target; 276, call; 276, 277; 276, 282; 277, attribute; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:os; 280, identifier:sep; 281, identifier:join; 282, argument_list; 282, 283; 283, list:[self.directory, 'js', basename ]; 283, 284; 283, 287; 283, 288; 284, attribute; 284, 285; 284, 286; 285, identifier:self; 286, identifier:directory; 287, string:'js'; 288, identifier:basename; 289, if_statement; 289, 290; 289, 300; 290, comparison_operator:is; 290, 291; 290, 299; 291, call; 291, 292; 291, 297; 292, attribute; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:os; 295, identifier:path; 296, identifier:isfile; 297, argument_list; 297, 298; 298, identifier:target; 299, False; 300, block; 300, 301; 301, expression_statement; 301, 302; 302, call; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:shutil; 305, identifier:copy; 306, argument_list; 306, 307; 306, 308; 307, identifier:filename; 308, identifier:target | def _init_report(self):
self.sections = []
self.section_names = []
try:
if os.path.isdir(self.directory) is False:
if self.verbose:
print("Created directory {}".format(self.directory))
os.mkdir(self.directory)
for this in self._to_create:
try:
os.mkdir(self.directory + os.sep + this)
except:
pass
except Exception:
pass
finally:
temp_path = easydev.get_package_location("reports")
temp_path += os.sep + "reports" + os.sep + "resources"
filenames = glob.glob(os.sep.join([temp_path, "css", "*.css"]))
filenames += glob.glob(os.sep.join([self.searchpath, '*.css']))
filenames += self.extra_css_list
for filename in filenames:
target = os.sep.join([self.directory, 'css' ])
if os.path.isfile(target) is False:
shutil.copy(filename, target)
for filename in ['sorttable.js', 'highlight.pack.js', "jquery-1.12.3.min.js"]:
target = os.sep.join([self.directory, 'js', filename ])
if os.path.isfile(target) is False:
filename = os.sep.join([temp_path, "javascript", filename])
shutil.copy(filename, target)
for filename in self.extra_js_list:
basename = os.path.basename(filename)
target = os.sep.join([self.directory, 'js', basename ])
if os.path.isfile(target) is False:
shutil.copy(filename, target) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:check_instance; 3, parameters; 3, 4; 4, identifier:function; 5, block; 5, 6; 5, 271; 6, function_definition; 6, 7; 6, 8; 6, 14; 7, function_name:wrapper; 8, parameters; 8, 9; 8, 10; 8, 12; 9, identifier:self; 10, list_splat_pattern; 10, 11; 11, identifier:args; 12, dictionary_splat_pattern; 12, 13; 13, identifier:kwargs; 14, block; 14, 15; 14, 82; 14, 168; 14, 262; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:func_trans; 18, dictionary; 18, 19; 18, 24; 18, 29; 18, 34; 18, 39; 18, 44; 18, 49; 18, 54; 18, 61; 18, 68; 18, 75; 19, pair; 19, 20; 19, 21; 20, string:"commit"; 21, attribute; 21, 22; 21, 23; 22, identifier:manager; 23, identifier:Manager; 24, pair; 24, 25; 24, 26; 25, string:"compare_config"; 26, attribute; 26, 27; 26, 28; 27, identifier:manager; 28, identifier:Manager; 29, pair; 29, 30; 29, 31; 30, string:"commit_check"; 31, attribute; 31, 32; 31, 33; 32, identifier:manager; 33, identifier:Manager; 34, pair; 34, 35; 34, 36; 35, string:"device_info"; 36, attribute; 36, 37; 36, 38; 37, identifier:manager; 38, identifier:Manager; 39, pair; 39, 40; 39, 41; 40, string:"diff_config"; 41, attribute; 41, 42; 41, 43; 42, identifier:manager; 43, identifier:Manager; 44, pair; 44, 45; 44, 46; 45, string:"health_check"; 46, attribute; 46, 47; 46, 48; 47, identifier:manager; 48, identifier:Manager; 49, pair; 49, 50; 49, 51; 50, string:"interface_errors"; 51, attribute; 51, 52; 51, 53; 52, identifier:manager; 53, identifier:Manager; 54, pair; 54, 55; 54, 56; 55, string:"op_cmd"; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:paramiko; 59, identifier:client; 60, identifier:SSHClient; 61, pair; 61, 62; 61, 63; 62, string:"shell_cmd"; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:paramiko; 66, identifier:client; 67, identifier:SSHClient; 68, pair; 68, 69; 68, 70; 69, string:"scp_pull"; 70, attribute; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:paramiko; 73, identifier:client; 74, identifier:SSHClient; 75, pair; 75, 76; 75, 77; 76, string:"scp_push"; 77, attribute; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:paramiko; 80, identifier:client; 81, identifier:SSHClient; 82, if_statement; 82, 83; 82, 94; 82, 137; 83, boolean_operator:and; 83, 84; 83, 89; 84, comparison_operator:==; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:username; 88, string:"root"; 89, comparison_operator:==; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:function; 92, identifier:__name__; 93, string:"op_cmd"; 94, block; 94, 95; 94, 113; 94, 131; 95, if_statement; 95, 96; 95, 100; 96, not_operator; 96, 97; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:_session; 100, block; 100, 101; 100, 107; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:conn_type; 106, string:"paramiko"; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:connect; 112, argument_list; 113, if_statement; 113, 114; 113, 118; 114, not_operator; 114, 115; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:_shell; 118, block; 118, 119; 118, 125; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:conn_type; 124, string:"root"; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:connect; 130, argument_list; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:shell_to_cli; 136, argument_list; 137, elif_clause; 137, 138; 137, 143; 138, comparison_operator:==; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:function; 141, identifier:__name__; 142, string:'shell_cmd'; 143, block; 143, 144; 143, 162; 144, if_statement; 144, 145; 144, 149; 145, not_operator; 145, 146; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:_shell; 149, block; 149, 150; 149, 156; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:conn_type; 155, string:"shell"; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:connect; 161, argument_list; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:cli_to_shell; 167, argument_list; 168, if_statement; 168, 169; 168, 180; 168, 212; 169, call; 169, 170; 169, 171; 170, identifier:isinstance; 171, argument_list; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:_session; 175, subscript; 175, 176; 175, 177; 176, identifier:func_trans; 177, attribute; 177, 178; 177, 179; 178, identifier:function; 179, identifier:__name__; 180, block; 180, 181; 181, if_statement; 181, 182; 181, 189; 182, comparison_operator:in; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:function; 185, identifier:__name__; 186, list:['scp_pull', 'scp_push']; 186, 187; 186, 188; 187, string:'scp_pull'; 188, string:'scp_push'; 189, block; 189, 190; 190, if_statement; 190, 191; 190, 199; 191, not_operator; 191, 192; 192, call; 192, 193; 192, 194; 193, identifier:isinstance; 194, argument_list; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:self; 197, identifier:_scp; 198, identifier:SCPClient; 199, block; 199, 200; 199, 206; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:self; 204, identifier:conn_type; 205, string:"scp"; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:self; 210, identifier:connect; 211, argument_list; 212, else_clause; 212, 213; 213, block; 213, 214; 213, 220; 213, 256; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:disconnect; 219, argument_list; 220, if_statement; 220, 221; 220, 226; 220, 233; 220, 248; 221, comparison_operator:==; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:function; 224, identifier:__name__; 225, string:"op_cmd"; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:self; 231, identifier:conn_type; 232, string:"paramiko"; 233, elif_clause; 233, 234; 233, 241; 234, comparison_operator:in; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:function; 237, identifier:__name__; 238, list:["scp_pull", "scp_push"]; 238, 239; 238, 240; 239, string:"scp_pull"; 240, string:"scp_push"; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:self; 246, identifier:conn_type; 247, string:"scp"; 248, else_clause; 248, 249; 249, block; 249, 250; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:self; 254, identifier:conn_type; 255, string:"ncclient"; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:self; 260, identifier:connect; 261, argument_list; 262, return_statement; 262, 263; 263, call; 263, 264; 263, 265; 264, identifier:function; 265, argument_list; 265, 266; 265, 267; 265, 269; 266, identifier:self; 267, list_splat; 267, 268; 268, identifier:args; 269, dictionary_splat; 269, 270; 270, identifier:kwargs; 271, return_statement; 271, 272; 272, identifier:wrapper | def check_instance(function):
def wrapper(self, *args, **kwargs):
func_trans = {
"commit": manager.Manager,
"compare_config": manager.Manager,
"commit_check": manager.Manager,
"device_info": manager.Manager,
"diff_config": manager.Manager,
"health_check": manager.Manager,
"interface_errors": manager.Manager,
"op_cmd": paramiko.client.SSHClient,
"shell_cmd": paramiko.client.SSHClient,
"scp_pull": paramiko.client.SSHClient,
"scp_push": paramiko.client.SSHClient
}
if self.username == "root" and function.__name__ == "op_cmd":
if not self._session:
self.conn_type = "paramiko"
self.connect()
if not self._shell:
self.conn_type = "root"
self.connect()
self.shell_to_cli()
elif function.__name__ == 'shell_cmd':
if not self._shell:
self.conn_type = "shell"
self.connect()
self.cli_to_shell()
if isinstance(self._session, func_trans[function.__name__]):
if function.__name__ in ['scp_pull', 'scp_push']:
if not isinstance(self._scp, SCPClient):
self.conn_type = "scp"
self.connect()
else:
self.disconnect()
if function.__name__ == "op_cmd":
self.conn_type = "paramiko"
elif function.__name__ in ["scp_pull", "scp_push"]:
self.conn_type = "scp"
else:
self.conn_type = "ncclient"
self.connect()
return function(self, *args, **kwargs)
return wrapper |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:commit; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:commands; 7, string:""; 8, default_parameter; 8, 9; 8, 10; 9, identifier:confirmed; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:comment; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:at_time; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:synchronize; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:req_format; 22, string:'text'; 23, block; 23, 24; 23, 32; 23, 36; 23, 50; 23, 56; 23, 70; 23, 74; 23, 123; 23, 129; 23, 253; 24, if_statement; 24, 25; 24, 27; 25, not_operator; 25, 26; 26, identifier:commands; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:commands; 31, string:'annotate system ""'; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:clean_cmds; 35, list:[]; 36, for_statement; 36, 37; 36, 38; 36, 42; 37, identifier:cmd; 38, call; 38, 39; 38, 40; 39, identifier:clean_lines; 40, argument_list; 40, 41; 41, identifier:commands; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:clean_cmds; 47, identifier:append; 48, argument_list; 48, 49; 49, identifier:cmd; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:lock; 55, argument_list; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 63; 58, attribute; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:_session; 62, identifier:load_configuration; 63, argument_list; 63, 64; 63, 67; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:action; 66, string:'set'; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:config; 69, identifier:commands; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:results; 73, string:""; 74, if_statement; 74, 75; 74, 76; 74, 102; 75, identifier:confirmed; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:results; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:_session; 85, identifier:commit; 86, argument_list; 86, 87; 86, 90; 86, 96; 86, 99; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:confirmed; 89, True; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:timeout; 92, call; 92, 93; 92, 94; 93, identifier:str; 94, argument_list; 94, 95; 95, identifier:confirmed; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:comment; 98, identifier:comment; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:synchronize; 101, identifier:synchronize; 102, else_clause; 102, 103; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:results; 107, call; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:_session; 112, identifier:commit; 113, argument_list; 113, 114; 113, 117; 113, 120; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:comment; 116, identifier:comment; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:at_time; 119, identifier:at_time; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:synchronize; 122, identifier:synchronize; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:unlock; 128, argument_list; 129, if_statement; 129, 130; 129, 131; 130, identifier:results; 131, block; 131, 132; 131, 139; 131, 150; 131, 154; 131, 251; 132, if_statement; 132, 133; 132, 136; 133, comparison_operator:==; 133, 134; 133, 135; 134, identifier:req_format; 135, string:'xml'; 136, block; 136, 137; 137, return_statement; 137, 138; 138, identifier:results; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:results; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:ET; 145, identifier:fromstring; 146, argument_list; 146, 147; 147, attribute; 147, 148; 147, 149; 148, identifier:results; 149, identifier:tostring; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:out; 153, string:''; 154, for_statement; 154, 155; 154, 156; 154, 161; 155, identifier:i; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:results; 159, identifier:iter; 160, argument_list; 161, block; 161, 162; 162, if_statement; 162, 163; 162, 168; 162, 173; 162, 184; 162, 195; 162, 227; 163, comparison_operator:==; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:i; 166, identifier:tag; 167, string:'commit-check-success'; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, augmented_assignment:+=; 170, 171; 170, 172; 171, identifier:out; 172, string:'configuration check succeeds\n'; 173, elif_clause; 173, 174; 173, 179; 174, comparison_operator:==; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:i; 177, identifier:tag; 178, string:'commit-success'; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, augmented_assignment:+=; 181, 182; 181, 183; 182, identifier:out; 183, string:'commit complete\n'; 184, elif_clause; 184, 185; 184, 190; 185, comparison_operator:==; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:i; 188, identifier:tag; 189, string:'ok'; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, augmented_assignment:+=; 192, 193; 192, 194; 193, identifier:out; 194, string:'commit complete\n'; 195, elif_clause; 195, 196; 195, 201; 196, comparison_operator:is; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:i; 199, identifier:text; 200, None; 201, block; 201, 202; 202, if_statement; 202, 203; 202, 214; 203, comparison_operator:!=; 203, 204; 203, 213; 204, binary_operator:+; 204, 205; 204, 212; 205, call; 205, 206; 205, 211; 206, attribute; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:i; 209, identifier:text; 210, identifier:strip; 211, argument_list; 212, string:'\n'; 213, string:'\n'; 214, block; 214, 215; 215, expression_statement; 215, 216; 216, augmented_assignment:+=; 216, 217; 216, 218; 217, identifier:out; 218, binary_operator:+; 218, 219; 218, 226; 219, call; 219, 220; 219, 225; 220, attribute; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:i; 223, identifier:text; 224, identifier:strip; 225, argument_list; 226, string:'\n'; 227, elif_clause; 227, 228; 227, 233; 228, comparison_operator:is; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:i; 231, identifier:text; 232, None; 233, block; 233, 234; 234, if_statement; 234, 235; 234, 242; 235, comparison_operator:!=; 235, 236; 235, 241; 236, binary_operator:+; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:i; 239, identifier:tag; 240, string:'\n'; 241, string:'\n'; 242, block; 242, 243; 243, expression_statement; 243, 244; 244, augmented_assignment:+=; 244, 245; 244, 246; 245, identifier:out; 246, binary_operator:+; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:i; 249, identifier:tag; 250, string:'\n'; 251, return_statement; 251, 252; 252, identifier:out; 253, return_statement; 253, 254; 254, False | def commit(self, commands="", confirmed=None, comment=None,
at_time=None, synchronize=False, req_format='text'):
if not commands:
commands = 'annotate system ""'
clean_cmds = []
for cmd in clean_lines(commands):
clean_cmds.append(cmd)
self.lock()
self._session.load_configuration(action='set', config=commands)
results = ""
if confirmed:
results = self._session.commit(confirmed=True,
timeout=str(confirmed),
comment=comment,
synchronize=synchronize)
else:
results = self._session.commit(comment=comment, at_time=at_time,
synchronize=synchronize)
self.unlock()
if results:
if req_format == 'xml':
return results
results = ET.fromstring(results.tostring)
out = ''
for i in results.iter():
if i.tag == 'commit-check-success':
out += 'configuration check succeeds\n'
elif i.tag == 'commit-success':
out += 'commit complete\n'
elif i.tag == 'ok':
out += 'commit complete\n'
elif i.text is not None:
if i.text.strip() + '\n' != '\n':
out += i.text.strip() + '\n'
elif i.text is None:
if i.tag + '\n' != '\n':
out += i.tag + '\n'
return out
return False |
Subsets and Splits