sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:is_prime; 3, parameters; 3, 4; 3, 5; 4, identifier:n; 5, default_parameter; 5, 6; 5, 7; 6, identifier:k; 7, integer:64; 8, block; 8, 9; 8, 16; 8, 29; 8, 46; 8, 50; 8, 56; 8, 83; 8, 113; 9, if_statement; 9, 10; 9, 13; 10, comparison_operator:==; 10, 11; 10, 12; 11, identifier:n; 12, integer:2; 13, block; 13, 14; 14, return_statement; 14, 15; 15, True; 16, if_statement; 16, 17; 16, 26; 17, boolean_operator:or; 17, 18; 17, 21; 18, comparison_operator:<; 18, 19; 18, 20; 19, identifier:n; 20, integer:2; 21, comparison_operator:==; 21, 22; 21, 25; 22, binary_operator:%; 22, 23; 22, 24; 23, identifier:n; 24, integer:2; 25, integer:0; 26, block; 26, 27; 27, return_statement; 27, 28; 28, False; 29, for_statement; 29, 30; 29, 31; 29, 36; 30, identifier:i; 31, call; 31, 32; 31, 33; 32, identifier:range; 33, argument_list; 33, 34; 33, 35; 34, integer:3; 35, integer:2048; 36, block; 36, 37; 37, if_statement; 37, 38; 37, 43; 38, comparison_operator:==; 38, 39; 38, 42; 39, binary_operator:%; 39, 40; 39, 41; 40, identifier:n; 41, identifier:i; 42, integer:0; 43, block; 43, 44; 44, return_statement; 44, 45; 45, False; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:s; 49, integer:0; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:d; 53, binary_operator:-; 53, 54; 53, 55; 54, identifier:n; 55, integer:1; 56, while_statement; 56, 57; 56, 58; 57, True; 58, block; 58, 59; 58, 69; 58, 75; 58, 79; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 64; 61, pattern_list; 61, 62; 61, 63; 62, identifier:q; 63, identifier:r; 64, call; 64, 65; 64, 66; 65, identifier:divmod; 66, argument_list; 66, 67; 66, 68; 67, identifier:d; 68, integer:2; 69, if_statement; 69, 70; 69, 73; 70, comparison_operator:==; 70, 71; 70, 72; 71, identifier:r; 72, integer:1; 73, block; 73, 74; 74, break_statement; 75, expression_statement; 75, 76; 76, augmented_assignment:+=; 76, 77; 76, 78; 77, identifier:s; 78, integer:1; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:d; 82, identifier:q; 83, for_statement; 83, 84; 83, 85; 83, 89; 84, identifier:i; 85, call; 85, 86; 85, 87; 86, identifier:range; 87, argument_list; 87, 88; 88, identifier:k; 89, block; 89, 90; 89, 102; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:a; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:random; 96, identifier:randint; 97, argument_list; 97, 98; 97, 99; 98, integer:2; 99, binary_operator:-; 99, 100; 99, 101; 100, identifier:n; 101, integer:1; 102, if_statement; 102, 103; 102, 110; 103, call; 103, 104; 103, 105; 104, identifier:check_candidate; 105, argument_list; 105, 106; 105, 107; 105, 108; 105, 109; 106, identifier:a; 107, identifier:d; 108, identifier:n; 109, identifier:s; 110, block; 110, 111; 111, return_statement; 111, 112; 112, False; 113, return_statement; 113, 114; 114, True | def is_prime(n, k=64):
if n == 2:
return True
if n < 2 or n % 2 == 0:
return False
for i in range(3, 2048):
if n % i == 0:
return False
s = 0
d = n - 1
while True:
q, r = divmod(d, 2)
if r == 1:
break
s += 1
d = q
for i in range(k):
a = random.randint(2, n - 1)
if check_candidate(a, d, n, s):
return False
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:iterrows; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:workbook; 7, None; 8, block; 8, 9; 8, 13; 8, 17; 8, 21; 8, 27; 8, 141; 8, 173; 8, 187; 8, 245; 8, 315; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:resolved_tables; 12, list:[]; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:max_height; 16, integer:0; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:max_width; 20, integer:0; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:__formula_values; 26, dictionary; 27, for_statement; 27, 28; 27, 35; 27, 45; 28, pattern_list; 28, 29; 28, 30; 29, identifier:name; 30, tuple_pattern; 30, 31; 30, 32; 31, identifier:table; 32, tuple_pattern; 32, 33; 32, 34; 33, identifier:row; 34, identifier:col; 35, call; 35, 36; 35, 37; 36, identifier:list; 37, argument_list; 37, 38; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:__tables; 43, identifier:items; 44, argument_list; 45, block; 45, 46; 45, 58; 45, 72; 45, 78; 45, 86; 45, 92; 45, 106; 45, 118; 45, 130; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 53; 48, subscript; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:__tables; 52, None; 53, tuple; 53, 54; 53, 55; 54, identifier:table; 55, tuple; 55, 56; 55, 57; 56, identifier:row; 57, identifier:col; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:data; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:table; 64, identifier:get_data; 65, argument_list; 65, 66; 65, 67; 65, 68; 65, 69; 66, identifier:workbook; 67, identifier:row; 68, identifier:col; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:__formula_values; 72, delete_statement; 72, 73; 73, subscript; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:__tables; 77, None; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, pattern_list; 80, 81; 80, 82; 81, identifier:height; 82, identifier:width; 83, attribute; 83, 84; 83, 85; 84, identifier:data; 85, identifier:shape; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:upper_left; 89, tuple; 89, 90; 89, 91; 90, identifier:row; 91, identifier:col; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:lower_right; 95, tuple; 95, 96; 95, 101; 96, binary_operator:-; 96, 97; 96, 100; 97, binary_operator:+; 97, 98; 97, 99; 98, identifier:row; 99, identifier:height; 100, integer:1; 101, binary_operator:-; 101, 102; 101, 105; 102, binary_operator:+; 102, 103; 102, 104; 103, identifier:col; 104, identifier:width; 105, integer:1; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:max_height; 109, call; 109, 110; 109, 111; 110, identifier:max; 111, argument_list; 111, 112; 111, 113; 112, identifier:max_height; 113, binary_operator:+; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:lower_right; 116, integer:0; 117, integer:1; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:max_width; 121, call; 121, 122; 121, 123; 122, identifier:max; 123, argument_list; 123, 124; 123, 125; 124, identifier:max_width; 125, binary_operator:+; 125, 126; 125, 129; 126, subscript; 126, 127; 126, 128; 127, identifier:lower_right; 128, integer:1; 129, integer:1; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:resolved_tables; 134, identifier:append; 135, argument_list; 135, 136; 136, tuple; 136, 137; 136, 138; 136, 139; 136, 140; 137, identifier:name; 138, identifier:data; 139, identifier:upper_left; 140, identifier:lower_right; 141, for_statement; 141, 142; 141, 145; 141, 152; 142, pattern_list; 142, 143; 142, 144; 143, identifier:row; 144, identifier:col; 145, call; 145, 146; 145, 151; 146, attribute; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:__values; 150, identifier:keys; 151, argument_list; 152, block; 152, 153; 152, 163; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:max_width; 156, call; 156, 157; 156, 158; 157, identifier:max; 158, argument_list; 158, 159; 158, 160; 159, identifier:max_width; 160, binary_operator:+; 160, 161; 160, 162; 161, identifier:row; 162, integer:1; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:max_height; 166, call; 166, 167; 166, 168; 167, identifier:max; 168, argument_list; 168, 169; 168, 170; 169, identifier:max_height; 170, binary_operator:+; 170, 171; 170, 172; 171, identifier:col; 172, integer:1; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:table; 176, list_comprehension; 176, 177; 176, 181; 177, binary_operator:*; 177, 178; 177, 180; 178, list:[None]; 178, 179; 179, None; 180, identifier:max_width; 181, for_in_clause; 181, 182; 181, 183; 182, identifier:i; 183, call; 183, 184; 183, 185; 184, identifier:range; 185, argument_list; 185, 186; 186, identifier:max_height; 187, for_statement; 187, 188; 187, 193; 187, 194; 188, pattern_list; 188, 189; 188, 190; 188, 191; 188, 192; 189, identifier:name; 190, identifier:data; 191, identifier:upper_left; 192, identifier:lower_right; 193, identifier:resolved_tables; 194, block; 194, 195; 195, for_statement; 195, 196; 195, 199; 195, 213; 196, pattern_list; 196, 197; 196, 198; 197, identifier:i; 198, identifier:r; 199, call; 199, 200; 199, 201; 200, identifier:enumerate; 201, argument_list; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:range; 204, argument_list; 204, 205; 204, 208; 205, subscript; 205, 206; 205, 207; 206, identifier:upper_left; 207, integer:0; 208, binary_operator:+; 208, 209; 208, 212; 209, subscript; 209, 210; 209, 211; 210, identifier:lower_right; 211, integer:0; 212, integer:1; 213, block; 213, 214; 214, for_statement; 214, 215; 214, 218; 214, 232; 215, pattern_list; 215, 216; 215, 217; 216, identifier:j; 217, identifier:c; 218, call; 218, 219; 218, 220; 219, identifier:enumerate; 220, argument_list; 220, 221; 221, call; 221, 222; 221, 223; 222, identifier:range; 223, argument_list; 223, 224; 223, 227; 224, subscript; 224, 225; 224, 226; 225, identifier:upper_left; 226, integer:1; 227, binary_operator:+; 227, 228; 227, 231; 228, subscript; 228, 229; 228, 230; 229, identifier:lower_right; 230, integer:1; 231, integer:1; 232, block; 232, 233; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 240; 235, subscript; 235, 236; 235, 239; 236, subscript; 236, 237; 236, 238; 237, identifier:table; 238, identifier:r; 239, identifier:c; 240, subscript; 240, 241; 240, 244; 241, subscript; 241, 242; 241, 243; 242, identifier:data; 243, identifier:i; 244, identifier:j; 245, for_statement; 245, 246; 245, 251; 245, 258; 246, pattern_list; 246, 247; 246, 250; 247, tuple_pattern; 247, 248; 247, 249; 248, identifier:r; 249, identifier:c; 250, identifier:value; 251, call; 251, 252; 251, 257; 252, attribute; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:self; 255, identifier:__values; 256, identifier:items; 257, argument_list; 258, block; 258, 259; 258, 272; 258, 307; 259, if_statement; 259, 260; 259, 265; 260, call; 260, 261; 260, 262; 261, identifier:isinstance; 262, argument_list; 262, 263; 262, 264; 263, identifier:value; 264, identifier:Value; 265, block; 265, 266; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:value; 269, attribute; 269, 270; 269, 271; 270, identifier:value; 271, identifier:value; 272, if_statement; 272, 273; 272, 278; 273, call; 273, 274; 273, 275; 274, identifier:isinstance; 275, argument_list; 275, 276; 275, 277; 276, identifier:value; 277, identifier:Expression; 278, block; 278, 279; 278, 296; 279, if_statement; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:value; 282, identifier:has_value; 283, block; 283, 284; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 293; 286, subscript; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:self; 289, identifier:__formula_values; 290, tuple; 290, 291; 290, 292; 291, identifier:r; 292, identifier:c; 293, attribute; 293, 294; 293, 295; 294, identifier:value; 295, identifier:value; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 299; 298, identifier:value; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:value; 302, identifier:get_formula; 303, argument_list; 303, 304; 303, 305; 303, 306; 304, identifier:workbook; 305, identifier:r; 306, identifier:c; 307, expression_statement; 307, 308; 308, assignment; 308, 309; 308, 314; 309, subscript; 309, 310; 309, 313; 310, subscript; 310, 311; 310, 312; 311, identifier:table; 312, identifier:r; 313, identifier:c; 314, identifier:value; 315, for_statement; 315, 316; 315, 317; 315, 318; 316, identifier:row; 317, identifier:table; 318, block; 318, 319; 319, expression_statement; 319, 320; 320, yield; 320, 321; 321, identifier:row | def iterrows(self, workbook=None):
resolved_tables = []
max_height = 0
max_width = 0
self.__formula_values = {}
for name, (table, (row, col)) in list(self.__tables.items()):
self.__tables[None] = (table, (row, col))
data = table.get_data(workbook, row, col, self.__formula_values)
del self.__tables[None]
height, width = data.shape
upper_left = (row, col)
lower_right = (row + height - 1, col + width - 1)
max_height = max(max_height, lower_right[0] + 1)
max_width = max(max_width, lower_right[1] + 1)
resolved_tables.append((name, data, upper_left, lower_right))
for row, col in self.__values.keys():
max_width = max(max_width, row+1)
max_height = max(max_height, col+1)
table = [[None] * max_width for i in range(max_height)]
for name, data, upper_left, lower_right in resolved_tables:
for i, r in enumerate(range(upper_left[0], lower_right[0]+1)):
for j, c in enumerate(range(upper_left[1], lower_right[1]+1)):
table[r][c] = data[i][j]
for (r, c), value in self.__values.items():
if isinstance(value, Value):
value = value.value
if isinstance(value, Expression):
if value.has_value:
self.__formula_values[(r, c)] = value.value
value = value.get_formula(workbook, r, c)
table[r][c] = value
for row in table:
yield row |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:format_listfield_nodes; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:field_name; 5, identifier:field; 6, identifier:field_id; 7, identifier:state; 8, identifier:lineno; 9, block; 9, 10; 9, 18; 9, 29; 9, 37; 9, 50; 9, 54; 9, 58; 9, 110; 9, 114; 9, 166; 9, 170; 9, 222; 9, 230; 9, 244; 9, 252; 9, 260; 9, 279; 9, 289; 9, 309; 9, 324; 9, 328; 9, 332; 9, 342; 9, 351; 9, 362; 9, 366; 9, 374; 9, 382; 9, 386; 9, 393; 9, 400; 9, 407; 9, 415; 9, 426; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:itemtype_node; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:nodes; 16, identifier:definition_list_item; 17, argument_list; 18, expression_statement; 18, 19; 19, augmented_assignment:+=; 19, 20; 19, 21; 20, identifier:itemtype_node; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:nodes; 24, identifier:term; 25, argument_list; 25, 26; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:text; 28, string:'Item type'; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:itemtype_def; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:nodes; 35, identifier:definition; 36, argument_list; 37, expression_statement; 37, 38; 38, augmented_assignment:+=; 38, 39; 38, 40; 39, identifier:itemtype_def; 40, call; 40, 41; 40, 42; 41, identifier:make_python_xref_nodes_for_type; 42, argument_list; 42, 43; 42, 46; 42, 47; 43, attribute; 43, 44; 43, 45; 44, identifier:field; 45, identifier:itemtype; 46, identifier:state; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:hide_namespace; 49, False; 50, expression_statement; 50, 51; 51, augmented_assignment:+=; 51, 52; 51, 53; 52, identifier:itemtype_node; 53, identifier:itemtype_def; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:minlength_node; 57, None; 58, if_statement; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:field; 61, identifier:minLength; 62, block; 62, 63; 62, 71; 62, 82; 62, 90; 62, 106; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:minlength_node; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:nodes; 69, identifier:definition_list_item; 70, argument_list; 71, expression_statement; 71, 72; 72, augmented_assignment:+=; 72, 73; 72, 74; 73, identifier:minlength_node; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:nodes; 77, identifier:term; 78, argument_list; 78, 79; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:text; 81, string:'Minimum length'; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:minlength_def; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:nodes; 88, identifier:definition; 89, argument_list; 90, expression_statement; 90, 91; 91, augmented_assignment:+=; 91, 92; 91, 93; 92, identifier:minlength_def; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:nodes; 96, identifier:paragraph; 97, argument_list; 97, 98; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:text; 100, call; 100, 101; 100, 102; 101, identifier:str; 102, argument_list; 102, 103; 103, attribute; 103, 104; 103, 105; 104, identifier:field; 105, identifier:minLength; 106, expression_statement; 106, 107; 107, augmented_assignment:+=; 107, 108; 107, 109; 108, identifier:minlength_node; 109, identifier:minlength_def; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:maxlength_node; 113, None; 114, if_statement; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:field; 117, identifier:maxLength; 118, block; 118, 119; 118, 127; 118, 138; 118, 146; 118, 162; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:maxlength_node; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:nodes; 125, identifier:definition_list_item; 126, argument_list; 127, expression_statement; 127, 128; 128, augmented_assignment:+=; 128, 129; 128, 130; 129, identifier:maxlength_node; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:nodes; 133, identifier:term; 134, argument_list; 134, 135; 135, keyword_argument; 135, 136; 135, 137; 136, identifier:text; 137, string:'Maximum length'; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:maxlength_def; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:nodes; 144, identifier:definition; 145, argument_list; 146, expression_statement; 146, 147; 147, augmented_assignment:+=; 147, 148; 147, 149; 148, identifier:maxlength_def; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:nodes; 152, identifier:paragraph; 153, argument_list; 153, 154; 154, keyword_argument; 154, 155; 154, 156; 155, identifier:text; 156, call; 156, 157; 156, 158; 157, identifier:str; 158, argument_list; 158, 159; 159, attribute; 159, 160; 159, 161; 160, identifier:field; 161, identifier:maxLength; 162, expression_statement; 162, 163; 163, augmented_assignment:+=; 163, 164; 163, 165; 164, identifier:maxlength_node; 165, identifier:maxlength_def; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:length_node; 169, None; 170, if_statement; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:field; 173, identifier:length; 174, block; 174, 175; 174, 183; 174, 194; 174, 202; 174, 218; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:length_node; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:nodes; 181, identifier:definition_list_item; 182, argument_list; 183, expression_statement; 183, 184; 184, augmented_assignment:+=; 184, 185; 184, 186; 185, identifier:length_node; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:nodes; 189, identifier:term; 190, argument_list; 190, 191; 191, keyword_argument; 191, 192; 191, 193; 192, identifier:text; 193, string:'Required length'; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:length_def; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:nodes; 200, identifier:definition; 201, argument_list; 202, expression_statement; 202, 203; 203, augmented_assignment:+=; 203, 204; 203, 205; 204, identifier:length_def; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:nodes; 208, identifier:paragraph; 209, argument_list; 209, 210; 210, keyword_argument; 210, 211; 210, 212; 211, identifier:text; 212, call; 212, 213; 212, 214; 213, identifier:str; 214, argument_list; 214, 215; 215, attribute; 215, 216; 215, 217; 216, identifier:field; 217, identifier:length; 218, expression_statement; 218, 219; 219, augmented_assignment:+=; 219, 220; 219, 221; 220, identifier:length_node; 221, identifier:length_def; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:field_type_item; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:nodes; 228, identifier:definition_list_item; 229, argument_list; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:field_type_item; 234, identifier:append; 235, argument_list; 235, 236; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:nodes; 239, identifier:term; 240, argument_list; 240, 241; 241, keyword_argument; 241, 242; 241, 243; 242, identifier:text; 243, string:"Field type"; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 247; 246, identifier:field_type_item_content; 247, call; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:nodes; 250, identifier:definition; 251, argument_list; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:field_type_item_content_p; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:nodes; 258, identifier:paragraph; 259, argument_list; 260, expression_statement; 260, 261; 261, augmented_assignment:+=; 261, 262; 261, 263; 262, identifier:field_type_item_content_p; 263, subscript; 263, 264; 263, 278; 264, attribute; 264, 265; 264, 277; 265, subscript; 265, 266; 265, 276; 266, call; 266, 267; 266, 268; 267, identifier:make_python_xref_nodes_for_type; 268, argument_list; 268, 269; 268, 272; 268, 273; 269, attribute; 269, 270; 269, 271; 270, identifier:field; 271, identifier:itemtype; 272, identifier:state; 273, keyword_argument; 273, 274; 273, 275; 274, identifier:hide_namespace; 275, False; 276, integer:0; 277, identifier:children; 278, integer:0; 279, expression_statement; 279, 280; 280, augmented_assignment:+=; 280, 281; 280, 282; 281, identifier:field_type_item_content_p; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:nodes; 285, identifier:Text; 286, argument_list; 286, 287; 286, 288; 287, string:' '; 288, string:' '; 289, expression_statement; 289, 290; 290, augmented_assignment:+=; 290, 291; 290, 292; 291, identifier:field_type_item_content_p; 292, subscript; 292, 293; 292, 308; 293, attribute; 293, 294; 293, 307; 294, subscript; 294, 295; 294, 306; 295, call; 295, 296; 295, 297; 296, identifier:make_python_xref_nodes_for_type; 297, argument_list; 297, 298; 297, 302; 297, 303; 298, call; 298, 299; 298, 300; 299, identifier:type; 300, argument_list; 300, 301; 301, identifier:field; 302, identifier:state; 303, keyword_argument; 303, 304; 303, 305; 304, identifier:hide_namespace; 305, True; 306, integer:0; 307, identifier:children; 308, integer:0; 309, if_statement; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:field; 312, identifier:optional; 313, block; 313, 314; 314, expression_statement; 314, 315; 315, augmented_assignment:+=; 315, 316; 315, 317; 316, identifier:field_type_item_content_p; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:nodes; 320, identifier:Text; 321, argument_list; 321, 322; 321, 323; 322, string:' (optional)'; 323, string:' (optional)'; 324, expression_statement; 324, 325; 325, augmented_assignment:+=; 325, 326; 325, 327; 326, identifier:field_type_item_content; 327, identifier:field_type_item_content_p; 328, expression_statement; 328, 329; 329, augmented_assignment:+=; 329, 330; 329, 331; 330, identifier:field_type_item; 331, identifier:field_type_item_content; 332, expression_statement; 332, 333; 333, assignment; 333, 334; 333, 335; 334, identifier:env; 335, attribute; 335, 336; 335, 341; 336, attribute; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:state; 339, identifier:document; 340, identifier:settings; 341, identifier:env; 342, expression_statement; 342, 343; 343, assignment; 343, 344; 343, 345; 344, identifier:ref_target; 345, call; 345, 346; 345, 347; 346, identifier:create_configfield_ref_target_node; 347, argument_list; 347, 348; 347, 349; 347, 350; 348, identifier:field_id; 349, identifier:env; 350, identifier:lineno; 351, expression_statement; 351, 352; 352, assignment; 352, 353; 352, 354; 353, identifier:title; 354, call; 354, 355; 354, 358; 355, attribute; 355, 356; 355, 357; 356, identifier:nodes; 357, identifier:title; 358, argument_list; 358, 359; 359, keyword_argument; 359, 360; 359, 361; 360, identifier:text; 361, identifier:field_name; 362, expression_statement; 362, 363; 363, augmented_assignment:+=; 363, 364; 363, 365; 364, identifier:title; 365, identifier:ref_target; 366, expression_statement; 366, 367; 367, assignment; 367, 368; 367, 369; 368, identifier:dl; 369, call; 369, 370; 369, 373; 370, attribute; 370, 371; 370, 372; 371, identifier:nodes; 372, identifier:definition_list; 373, argument_list; 374, expression_statement; 374, 375; 375, augmented_assignment:+=; 375, 376; 375, 377; 376, identifier:dl; 377, call; 377, 378; 377, 379; 378, identifier:create_default_item_node; 379, argument_list; 379, 380; 379, 381; 380, identifier:field; 381, identifier:state; 382, expression_statement; 382, 383; 383, augmented_assignment:+=; 383, 384; 383, 385; 384, identifier:dl; 385, identifier:field_type_item; 386, if_statement; 386, 387; 386, 388; 387, identifier:minlength_node; 388, block; 388, 389; 389, expression_statement; 389, 390; 390, augmented_assignment:+=; 390, 391; 390, 392; 391, identifier:dl; 392, identifier:minlength_node; 393, if_statement; 393, 394; 393, 395; 394, identifier:maxlength_node; 395, block; 395, 396; 396, expression_statement; 396, 397; 397, augmented_assignment:+=; 397, 398; 397, 399; 398, identifier:dl; 399, identifier:maxlength_node; 400, if_statement; 400, 401; 400, 402; 401, identifier:length_node; 402, block; 402, 403; 403, expression_statement; 403, 404; 404, augmented_assignment:+=; 404, 405; 404, 406; 405, identifier:dl; 406, identifier:length_node; 407, expression_statement; 407, 408; 408, assignment; 408, 409; 408, 410; 409, identifier:desc_node; 410, call; 410, 411; 410, 412; 411, identifier:create_description_node; 412, argument_list; 412, 413; 412, 414; 413, identifier:field; 414, identifier:state; 415, expression_statement; 415, 416; 416, assignment; 416, 417; 416, 418; 417, identifier:title; 418, call; 418, 419; 418, 420; 419, identifier:create_title_node; 420, argument_list; 420, 421; 420, 422; 420, 423; 420, 424; 420, 425; 421, identifier:field_name; 422, identifier:field; 423, identifier:field_id; 424, identifier:state; 425, identifier:lineno; 426, return_statement; 426, 427; 427, list:[title, dl, desc_node]; 427, 428; 427, 429; 427, 430; 428, identifier:title; 429, identifier:dl; 430, identifier:desc_node | def format_listfield_nodes(field_name, field, field_id, state, lineno):
itemtype_node = nodes.definition_list_item()
itemtype_node += nodes.term(text='Item type')
itemtype_def = nodes.definition()
itemtype_def += make_python_xref_nodes_for_type(
field.itemtype,
state,
hide_namespace=False)
itemtype_node += itemtype_def
minlength_node = None
if field.minLength:
minlength_node = nodes.definition_list_item()
minlength_node += nodes.term(text='Minimum length')
minlength_def = nodes.definition()
minlength_def += nodes.paragraph(text=str(field.minLength))
minlength_node += minlength_def
maxlength_node = None
if field.maxLength:
maxlength_node = nodes.definition_list_item()
maxlength_node += nodes.term(text='Maximum length')
maxlength_def = nodes.definition()
maxlength_def += nodes.paragraph(text=str(field.maxLength))
maxlength_node += maxlength_def
length_node = None
if field.length:
length_node = nodes.definition_list_item()
length_node += nodes.term(text='Required length')
length_def = nodes.definition()
length_def += nodes.paragraph(text=str(field.length))
length_node += length_def
field_type_item = nodes.definition_list_item()
field_type_item.append(nodes.term(text="Field type"))
field_type_item_content = nodes.definition()
field_type_item_content_p = nodes.paragraph()
field_type_item_content_p += make_python_xref_nodes_for_type(
field.itemtype,
state,
hide_namespace=False)[0].children[0]
field_type_item_content_p += nodes.Text(' ', ' ')
field_type_item_content_p += make_python_xref_nodes_for_type(
type(field),
state,
hide_namespace=True)[0].children[0]
if field.optional:
field_type_item_content_p += nodes.Text(' (optional)', ' (optional)')
field_type_item_content += field_type_item_content_p
field_type_item += field_type_item_content
env = state.document.settings.env
ref_target = create_configfield_ref_target_node(field_id, env, lineno)
title = nodes.title(text=field_name)
title += ref_target
dl = nodes.definition_list()
dl += create_default_item_node(field, state)
dl += field_type_item
if minlength_node:
dl += minlength_node
if maxlength_node:
dl += maxlength_node
if length_node:
dl += length_node
desc_node = create_description_node(field, state)
title = create_title_node(field_name, field, field_id, state, lineno)
return [title, dl, desc_node] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:format_choicefield_nodes; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:field_name; 5, identifier:field; 6, identifier:field_id; 7, identifier:state; 8, identifier:lineno; 9, block; 9, 10; 9, 18; 9, 97; 9, 105; 9, 119; 9, 127; 9, 134; 9, 141; 9, 149; 9, 163; 9, 171; 9, 179; 9, 198; 9, 208; 9, 228; 9, 243; 9, 247; 9, 251; 9, 259; 9, 267; 9, 271; 9, 275; 9, 283; 9, 294; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:choice_dl; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:nodes; 16, identifier:definition_list; 17, argument_list; 18, for_statement; 18, 19; 18, 22; 18, 29; 19, pattern_list; 19, 20; 19, 21; 20, identifier:choice_value; 21, identifier:choice_doc; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:field; 26, identifier:allowed; 27, identifier:items; 28, argument_list; 29, block; 29, 30; 29, 38; 29, 46; 29, 60; 29, 64; 29, 72; 29, 86; 29, 90; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:item; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:nodes; 36, identifier:definition_list_item; 37, argument_list; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:item_term; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:nodes; 44, identifier:term; 45, argument_list; 46, expression_statement; 46, 47; 47, augmented_assignment:+=; 47, 48; 47, 49; 48, identifier:item_term; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:nodes; 52, identifier:literal; 53, argument_list; 53, 54; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:text; 56, call; 56, 57; 56, 58; 57, identifier:repr; 58, argument_list; 58, 59; 59, identifier:choice_value; 60, expression_statement; 60, 61; 61, augmented_assignment:+=; 61, 62; 61, 63; 62, identifier:item; 63, identifier:item_term; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:item_definition; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:nodes; 70, identifier:definition; 71, argument_list; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:item_definition; 76, identifier:append; 77, argument_list; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:nodes; 81, identifier:paragraph; 82, argument_list; 82, 83; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:text; 85, identifier:choice_doc; 86, expression_statement; 86, 87; 87, augmented_assignment:+=; 87, 88; 87, 89; 88, identifier:item; 89, identifier:item_definition; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:choice_dl; 94, identifier:append; 95, argument_list; 95, 96; 96, identifier:item; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:choices_node; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:nodes; 103, identifier:definition_list_item; 104, argument_list; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:choices_node; 109, identifier:append; 110, argument_list; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:nodes; 114, identifier:term; 115, argument_list; 115, 116; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:text; 118, string:'Choices'; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:choices_definition; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:nodes; 125, identifier:definition; 126, argument_list; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:choices_definition; 131, identifier:append; 132, argument_list; 132, 133; 133, identifier:choice_dl; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:choices_node; 138, identifier:append; 139, argument_list; 139, 140; 140, identifier:choices_definition; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:field_type_item; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:nodes; 147, identifier:definition_list_item; 148, argument_list; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:field_type_item; 153, identifier:append; 154, argument_list; 154, 155; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:nodes; 158, identifier:term; 159, argument_list; 159, 160; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:text; 162, string:"Field type"; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:field_type_item_content; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:nodes; 169, identifier:definition; 170, argument_list; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:field_type_item_content_p; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:nodes; 177, identifier:paragraph; 178, argument_list; 179, expression_statement; 179, 180; 180, augmented_assignment:+=; 180, 181; 180, 182; 181, identifier:field_type_item_content_p; 182, subscript; 182, 183; 182, 197; 183, attribute; 183, 184; 183, 196; 184, subscript; 184, 185; 184, 195; 185, call; 185, 186; 185, 187; 186, identifier:make_python_xref_nodes_for_type; 187, argument_list; 187, 188; 187, 191; 187, 192; 188, attribute; 188, 189; 188, 190; 189, identifier:field; 190, identifier:dtype; 191, identifier:state; 192, keyword_argument; 192, 193; 192, 194; 193, identifier:hide_namespace; 194, False; 195, integer:0; 196, identifier:children; 197, integer:0; 198, expression_statement; 198, 199; 199, augmented_assignment:+=; 199, 200; 199, 201; 200, identifier:field_type_item_content_p; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:nodes; 204, identifier:Text; 205, argument_list; 205, 206; 205, 207; 206, string:' '; 207, string:' '; 208, expression_statement; 208, 209; 209, augmented_assignment:+=; 209, 210; 209, 211; 210, identifier:field_type_item_content_p; 211, subscript; 211, 212; 211, 227; 212, attribute; 212, 213; 212, 226; 213, subscript; 213, 214; 213, 225; 214, call; 214, 215; 214, 216; 215, identifier:make_python_xref_nodes_for_type; 216, argument_list; 216, 217; 216, 221; 216, 222; 217, call; 217, 218; 217, 219; 218, identifier:type; 219, argument_list; 219, 220; 220, identifier:field; 221, identifier:state; 222, keyword_argument; 222, 223; 222, 224; 223, identifier:hide_namespace; 224, True; 225, integer:0; 226, identifier:children; 227, integer:0; 228, if_statement; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:field; 231, identifier:optional; 232, block; 232, 233; 233, expression_statement; 233, 234; 234, augmented_assignment:+=; 234, 235; 234, 236; 235, identifier:field_type_item_content_p; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:nodes; 239, identifier:Text; 240, argument_list; 240, 241; 240, 242; 241, string:' (optional)'; 242, string:' (optional)'; 243, expression_statement; 243, 244; 244, augmented_assignment:+=; 244, 245; 244, 246; 245, identifier:field_type_item_content; 246, identifier:field_type_item_content_p; 247, expression_statement; 247, 248; 248, augmented_assignment:+=; 248, 249; 248, 250; 249, identifier:field_type_item; 250, identifier:field_type_item_content; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:dl; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:nodes; 257, identifier:definition_list; 258, argument_list; 259, expression_statement; 259, 260; 260, augmented_assignment:+=; 260, 261; 260, 262; 261, identifier:dl; 262, call; 262, 263; 262, 264; 263, identifier:create_default_item_node; 264, argument_list; 264, 265; 264, 266; 265, identifier:field; 266, identifier:state; 267, expression_statement; 267, 268; 268, augmented_assignment:+=; 268, 269; 268, 270; 269, identifier:dl; 270, identifier:field_type_item; 271, expression_statement; 271, 272; 272, augmented_assignment:+=; 272, 273; 272, 274; 273, identifier:dl; 274, identifier:choices_node; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 278; 277, identifier:desc_node; 278, call; 278, 279; 278, 280; 279, identifier:create_description_node; 280, argument_list; 280, 281; 280, 282; 281, identifier:field; 282, identifier:state; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:title; 286, call; 286, 287; 286, 288; 287, identifier:create_title_node; 288, argument_list; 288, 289; 288, 290; 288, 291; 288, 292; 288, 293; 289, identifier:field_name; 290, identifier:field; 291, identifier:field_id; 292, identifier:state; 293, identifier:lineno; 294, return_statement; 294, 295; 295, list:[title, dl, desc_node]; 295, 296; 295, 297; 295, 298; 296, identifier:title; 297, identifier:dl; 298, identifier:desc_node | def format_choicefield_nodes(field_name, field, field_id, state, lineno):
choice_dl = nodes.definition_list()
for choice_value, choice_doc in field.allowed.items():
item = nodes.definition_list_item()
item_term = nodes.term()
item_term += nodes.literal(text=repr(choice_value))
item += item_term
item_definition = nodes.definition()
item_definition.append(nodes.paragraph(text=choice_doc))
item += item_definition
choice_dl.append(item)
choices_node = nodes.definition_list_item()
choices_node.append(nodes.term(text='Choices'))
choices_definition = nodes.definition()
choices_definition.append(choice_dl)
choices_node.append(choices_definition)
field_type_item = nodes.definition_list_item()
field_type_item.append(nodes.term(text="Field type"))
field_type_item_content = nodes.definition()
field_type_item_content_p = nodes.paragraph()
field_type_item_content_p += make_python_xref_nodes_for_type(
field.dtype,
state,
hide_namespace=False)[0].children[0]
field_type_item_content_p += nodes.Text(' ', ' ')
field_type_item_content_p += make_python_xref_nodes_for_type(
type(field),
state,
hide_namespace=True)[0].children[0]
if field.optional:
field_type_item_content_p += nodes.Text(' (optional)', ' (optional)')
field_type_item_content += field_type_item_content_p
field_type_item += field_type_item_content
dl = nodes.definition_list()
dl += create_default_item_node(field, state)
dl += field_type_item
dl += choices_node
desc_node = create_description_node(field, state)
title = create_title_node(field_name, field, field_id, state, lineno)
return [title, dl, desc_node] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:format_configchoicefield_nodes; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:field_name; 5, identifier:field; 6, identifier:field_id; 7, identifier:state; 8, identifier:lineno; 9, block; 9, 10; 9, 18; 9, 119; 9, 127; 9, 141; 9, 149; 9, 156; 9, 163; 9, 171; 9, 185; 9, 193; 9, 201; 9, 216; 9, 226; 9, 246; 9, 261; 9, 265; 9, 269; 9, 277; 9, 285; 9, 289; 9, 293; 9, 301; 9, 312; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:choice_dl; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:nodes; 16, identifier:definition_list; 17, argument_list; 18, for_statement; 18, 19; 18, 22; 18, 29; 19, pattern_list; 19, 20; 19, 21; 20, identifier:choice_value; 21, identifier:choice_class; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:field; 26, identifier:typemap; 27, identifier:items; 28, argument_list; 29, block; 29, 30; 29, 38; 29, 46; 29, 60; 29, 64; 29, 72; 29, 80; 29, 95; 29, 104; 29, 108; 29, 112; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:item; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:nodes; 36, identifier:definition_list_item; 37, argument_list; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:item_term; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:nodes; 44, identifier:term; 45, argument_list; 46, expression_statement; 46, 47; 47, augmented_assignment:+=; 47, 48; 47, 49; 48, identifier:item_term; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:nodes; 52, identifier:literal; 53, argument_list; 53, 54; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:text; 56, call; 56, 57; 56, 58; 57, identifier:repr; 58, argument_list; 58, 59; 59, identifier:choice_value; 60, expression_statement; 60, 61; 61, augmented_assignment:+=; 61, 62; 61, 63; 62, identifier:item; 63, identifier:item_term; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:item_definition; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:nodes; 70, identifier:definition; 71, argument_list; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:def_para; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:nodes; 78, identifier:paragraph; 79, argument_list; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:name; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, string:'.'; 86, identifier:join; 87, argument_list; 87, 88; 88, tuple; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:choice_class; 91, identifier:__module__; 92, attribute; 92, 93; 92, 94; 93, identifier:choice_class; 94, identifier:__name__; 95, expression_statement; 95, 96; 96, augmented_assignment:+=; 96, 97; 96, 98; 97, identifier:def_para; 98, call; 98, 99; 98, 100; 99, identifier:pending_config_xref; 100, argument_list; 100, 101; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:rawsource; 103, identifier:name; 104, expression_statement; 104, 105; 105, augmented_assignment:+=; 105, 106; 105, 107; 106, identifier:item_definition; 107, identifier:def_para; 108, expression_statement; 108, 109; 109, augmented_assignment:+=; 109, 110; 109, 111; 110, identifier:item; 111, identifier:item_definition; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:choice_dl; 116, identifier:append; 117, argument_list; 117, 118; 118, identifier:item; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:choices_node; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:nodes; 125, identifier:definition_list_item; 126, argument_list; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:choices_node; 131, identifier:append; 132, argument_list; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:nodes; 136, identifier:term; 137, argument_list; 137, 138; 138, keyword_argument; 138, 139; 138, 140; 139, identifier:text; 140, string:'Choices'; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:choices_definition; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:nodes; 147, identifier:definition; 148, argument_list; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:choices_definition; 153, identifier:append; 154, argument_list; 154, 155; 155, identifier:choice_dl; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:choices_node; 160, identifier:append; 161, argument_list; 161, 162; 162, identifier:choices_definition; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:field_type_item; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:nodes; 169, identifier:definition_list_item; 170, argument_list; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:field_type_item; 175, identifier:append; 176, argument_list; 176, 177; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:nodes; 180, identifier:term; 181, argument_list; 181, 182; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:text; 184, string:"Field type"; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:field_type_item_content; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:nodes; 191, identifier:definition; 192, argument_list; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:field_type_item_content_p; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:nodes; 199, identifier:paragraph; 200, argument_list; 201, if_statement; 201, 202; 201, 205; 201, 210; 202, attribute; 202, 203; 202, 204; 203, identifier:field; 204, identifier:multi; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:multi_text; 209, string:"Multi-selection "; 210, else_clause; 210, 211; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:multi_text; 215, string:"Single-selection "; 216, expression_statement; 216, 217; 217, augmented_assignment:+=; 217, 218; 217, 219; 218, identifier:field_type_item_content_p; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:nodes; 222, identifier:Text; 223, argument_list; 223, 224; 223, 225; 224, identifier:multi_text; 225, identifier:multi_text; 226, expression_statement; 226, 227; 227, augmented_assignment:+=; 227, 228; 227, 229; 228, identifier:field_type_item_content_p; 229, subscript; 229, 230; 229, 245; 230, attribute; 230, 231; 230, 244; 231, subscript; 231, 232; 231, 243; 232, call; 232, 233; 232, 234; 233, identifier:make_python_xref_nodes_for_type; 234, argument_list; 234, 235; 234, 239; 234, 240; 235, call; 235, 236; 235, 237; 236, identifier:type; 237, argument_list; 237, 238; 238, identifier:field; 239, identifier:state; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:hide_namespace; 242, True; 243, integer:0; 244, identifier:children; 245, integer:0; 246, if_statement; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:field; 249, identifier:optional; 250, block; 250, 251; 251, expression_statement; 251, 252; 252, augmented_assignment:+=; 252, 253; 252, 254; 253, identifier:field_type_item_content_p; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:nodes; 257, identifier:Text; 258, argument_list; 258, 259; 258, 260; 259, string:' (optional)'; 260, string:' (optional)'; 261, expression_statement; 261, 262; 262, augmented_assignment:+=; 262, 263; 262, 264; 263, identifier:field_type_item_content; 264, identifier:field_type_item_content_p; 265, expression_statement; 265, 266; 266, augmented_assignment:+=; 266, 267; 266, 268; 267, identifier:field_type_item; 268, identifier:field_type_item_content; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:dl; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:nodes; 275, identifier:definition_list; 276, argument_list; 277, expression_statement; 277, 278; 278, augmented_assignment:+=; 278, 279; 278, 280; 279, identifier:dl; 280, call; 280, 281; 280, 282; 281, identifier:create_default_item_node; 282, argument_list; 282, 283; 282, 284; 283, identifier:field; 284, identifier:state; 285, expression_statement; 285, 286; 286, augmented_assignment:+=; 286, 287; 286, 288; 287, identifier:dl; 288, identifier:field_type_item; 289, expression_statement; 289, 290; 290, augmented_assignment:+=; 290, 291; 290, 292; 291, identifier:dl; 292, identifier:choices_node; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 296; 295, identifier:desc_node; 296, call; 296, 297; 296, 298; 297, identifier:create_description_node; 298, argument_list; 298, 299; 298, 300; 299, identifier:field; 300, identifier:state; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:title; 304, call; 304, 305; 304, 306; 305, identifier:create_title_node; 306, argument_list; 306, 307; 306, 308; 306, 309; 306, 310; 306, 311; 307, identifier:field_name; 308, identifier:field; 309, identifier:field_id; 310, identifier:state; 311, identifier:lineno; 312, return_statement; 312, 313; 313, list:[title, dl, desc_node]; 313, 314; 313, 315; 313, 316; 314, identifier:title; 315, identifier:dl; 316, identifier:desc_node | def format_configchoicefield_nodes(field_name, field, field_id, state, lineno):
choice_dl = nodes.definition_list()
for choice_value, choice_class in field.typemap.items():
item = nodes.definition_list_item()
item_term = nodes.term()
item_term += nodes.literal(text=repr(choice_value))
item += item_term
item_definition = nodes.definition()
def_para = nodes.paragraph()
name = '.'.join((choice_class.__module__, choice_class.__name__))
def_para += pending_config_xref(rawsource=name)
item_definition += def_para
item += item_definition
choice_dl.append(item)
choices_node = nodes.definition_list_item()
choices_node.append(nodes.term(text='Choices'))
choices_definition = nodes.definition()
choices_definition.append(choice_dl)
choices_node.append(choices_definition)
field_type_item = nodes.definition_list_item()
field_type_item.append(nodes.term(text="Field type"))
field_type_item_content = nodes.definition()
field_type_item_content_p = nodes.paragraph()
if field.multi:
multi_text = "Multi-selection "
else:
multi_text = "Single-selection "
field_type_item_content_p += nodes.Text(multi_text, multi_text)
field_type_item_content_p += make_python_xref_nodes_for_type(
type(field),
state,
hide_namespace=True)[0].children[0]
if field.optional:
field_type_item_content_p += nodes.Text(' (optional)', ' (optional)')
field_type_item_content += field_type_item_content_p
field_type_item += field_type_item_content
dl = nodes.definition_list()
dl += create_default_item_node(field, state)
dl += field_type_item
dl += choices_node
desc_node = create_description_node(field, state)
title = create_title_node(field_name, field, field_id, state, lineno)
return [title, dl, desc_node] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:format_registryfield_nodes; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:field_name; 5, identifier:field; 6, identifier:field_id; 7, identifier:state; 8, identifier:lineno; 9, block; 9, 10; 9, 18; 9, 26; 9, 192; 9, 200; 9, 214; 9, 222; 9, 229; 9, 236; 9, 244; 9, 258; 9, 266; 9, 274; 9, 289; 9, 299; 9, 319; 9, 334; 9, 338; 9, 342; 9, 350; 9, 358; 9, 362; 9, 366; 9, 374; 9, 385; 10, import_from_statement; 10, 11; 10, 16; 11, dotted_name; 11, 12; 11, 13; 11, 14; 11, 15; 12, identifier:lsst; 13, identifier:pex; 14, identifier:config; 15, identifier:registry; 16, dotted_name; 16, 17; 17, identifier:ConfigurableWrapper; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:choice_dl; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:nodes; 24, identifier:definition_list; 25, argument_list; 26, for_statement; 26, 27; 26, 30; 26, 37; 27, pattern_list; 27, 28; 27, 29; 28, identifier:choice_value; 29, identifier:choice_class; 30, call; 30, 31; 30, 36; 31, attribute; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:field; 34, identifier:registry; 35, identifier:items; 36, argument_list; 37, block; 37, 38; 37, 118; 37, 126; 37, 134; 37, 148; 37, 152; 37, 160; 37, 168; 37, 177; 37, 181; 37, 185; 38, if_statement; 38, 39; 38, 51; 38, 67; 38, 97; 39, boolean_operator:and; 39, 40; 39, 45; 39, 46; 40, call; 40, 41; 40, 42; 41, identifier:hasattr; 42, argument_list; 42, 43; 42, 44; 43, identifier:choice_class; 44, string:'__module__'; 45, line_continuation:\; 46, call; 46, 47; 46, 48; 47, identifier:hasattr; 48, argument_list; 48, 49; 48, 50; 49, identifier:choice_class; 50, string:'__name__'; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:name; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, string:'.'; 58, identifier:join; 59, argument_list; 59, 60; 60, tuple; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:choice_class; 63, identifier:__module__; 64, attribute; 64, 65; 64, 66; 65, identifier:choice_class; 66, identifier:__name__; 67, elif_clause; 67, 68; 67, 73; 68, call; 68, 69; 68, 70; 69, identifier:isinstance; 70, argument_list; 70, 71; 70, 72; 71, identifier:choice_class; 72, identifier:ConfigurableWrapper; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:name; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, string:'.'; 80, identifier:join; 81, argument_list; 81, 82; 82, tuple; 82, 83; 82, 90; 83, attribute; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:choice_class; 87, identifier:_target; 88, identifier:__class__; 89, identifier:__module__; 90, attribute; 90, 91; 90, 96; 91, attribute; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:choice_class; 94, identifier:_target; 95, identifier:__class__; 96, identifier:__name__; 97, else_clause; 97, 98; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:name; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, string:'.'; 105, identifier:join; 106, argument_list; 106, 107; 107, tuple; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:choice_class; 111, identifier:__class__; 112, identifier:__module__; 113, attribute; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:choice_class; 116, identifier:__class__; 117, identifier:__name__; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:item; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:nodes; 124, identifier:definition_list_item; 125, argument_list; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:item_term; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:nodes; 132, identifier:term; 133, argument_list; 134, expression_statement; 134, 135; 135, augmented_assignment:+=; 135, 136; 135, 137; 136, identifier:item_term; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:nodes; 140, identifier:literal; 141, argument_list; 141, 142; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:text; 144, call; 144, 145; 144, 146; 145, identifier:repr; 146, argument_list; 146, 147; 147, identifier:choice_value; 148, expression_statement; 148, 149; 149, augmented_assignment:+=; 149, 150; 149, 151; 150, identifier:item; 151, identifier:item_term; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:item_definition; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:nodes; 158, identifier:definition; 159, argument_list; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:def_para; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:nodes; 166, identifier:paragraph; 167, argument_list; 168, expression_statement; 168, 169; 169, augmented_assignment:+=; 169, 170; 169, 171; 170, identifier:def_para; 171, call; 171, 172; 171, 173; 172, identifier:pending_task_xref; 173, argument_list; 173, 174; 174, keyword_argument; 174, 175; 174, 176; 175, identifier:rawsource; 176, identifier:name; 177, expression_statement; 177, 178; 178, augmented_assignment:+=; 178, 179; 178, 180; 179, identifier:item_definition; 180, identifier:def_para; 181, expression_statement; 181, 182; 182, augmented_assignment:+=; 182, 183; 182, 184; 183, identifier:item; 184, identifier:item_definition; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:choice_dl; 189, identifier:append; 190, argument_list; 190, 191; 191, identifier:item; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:choices_node; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:nodes; 198, identifier:definition_list_item; 199, argument_list; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:choices_node; 204, identifier:append; 205, argument_list; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:nodes; 209, identifier:term; 210, argument_list; 210, 211; 211, keyword_argument; 211, 212; 211, 213; 212, identifier:text; 213, string:'Choices'; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:choices_definition; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:nodes; 220, identifier:definition; 221, argument_list; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:choices_definition; 226, identifier:append; 227, argument_list; 227, 228; 228, identifier:choice_dl; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:choices_node; 233, identifier:append; 234, argument_list; 234, 235; 235, identifier:choices_definition; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:field_type_item; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:nodes; 242, identifier:definition_list_item; 243, argument_list; 244, expression_statement; 244, 245; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:field_type_item; 248, identifier:append; 249, argument_list; 249, 250; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:nodes; 253, identifier:term; 254, argument_list; 254, 255; 255, keyword_argument; 255, 256; 255, 257; 256, identifier:text; 257, string:"Field type"; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:field_type_item_content; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:nodes; 264, identifier:definition; 265, argument_list; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:field_type_item_content_p; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:nodes; 272, identifier:paragraph; 273, argument_list; 274, if_statement; 274, 275; 274, 278; 274, 283; 275, attribute; 275, 276; 275, 277; 276, identifier:field; 277, identifier:multi; 278, block; 278, 279; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:multi_text; 282, string:"Multi-selection "; 283, else_clause; 283, 284; 284, block; 284, 285; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:multi_text; 288, string:"Single-selection "; 289, expression_statement; 289, 290; 290, augmented_assignment:+=; 290, 291; 290, 292; 291, identifier:field_type_item_content_p; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:nodes; 295, identifier:Text; 296, argument_list; 296, 297; 296, 298; 297, identifier:multi_text; 298, identifier:multi_text; 299, expression_statement; 299, 300; 300, augmented_assignment:+=; 300, 301; 300, 302; 301, identifier:field_type_item_content_p; 302, subscript; 302, 303; 302, 318; 303, attribute; 303, 304; 303, 317; 304, subscript; 304, 305; 304, 316; 305, call; 305, 306; 305, 307; 306, identifier:make_python_xref_nodes_for_type; 307, argument_list; 307, 308; 307, 312; 307, 313; 308, call; 308, 309; 308, 310; 309, identifier:type; 310, argument_list; 310, 311; 311, identifier:field; 312, identifier:state; 313, keyword_argument; 313, 314; 313, 315; 314, identifier:hide_namespace; 315, True; 316, integer:0; 317, identifier:children; 318, integer:0; 319, if_statement; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:field; 322, identifier:optional; 323, block; 323, 324; 324, expression_statement; 324, 325; 325, augmented_assignment:+=; 325, 326; 325, 327; 326, identifier:field_type_item_content_p; 327, call; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:nodes; 330, identifier:Text; 331, argument_list; 331, 332; 331, 333; 332, string:' (optional)'; 333, string:' (optional)'; 334, expression_statement; 334, 335; 335, augmented_assignment:+=; 335, 336; 335, 337; 336, identifier:field_type_item_content; 337, identifier:field_type_item_content_p; 338, expression_statement; 338, 339; 339, augmented_assignment:+=; 339, 340; 339, 341; 340, identifier:field_type_item; 341, identifier:field_type_item_content; 342, expression_statement; 342, 343; 343, assignment; 343, 344; 343, 345; 344, identifier:dl; 345, call; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:nodes; 348, identifier:definition_list; 349, argument_list; 350, expression_statement; 350, 351; 351, augmented_assignment:+=; 351, 352; 351, 353; 352, identifier:dl; 353, call; 353, 354; 353, 355; 354, identifier:create_default_item_node; 355, argument_list; 355, 356; 355, 357; 356, identifier:field; 357, identifier:state; 358, expression_statement; 358, 359; 359, augmented_assignment:+=; 359, 360; 359, 361; 360, identifier:dl; 361, identifier:field_type_item; 362, expression_statement; 362, 363; 363, augmented_assignment:+=; 363, 364; 363, 365; 364, identifier:dl; 365, identifier:choices_node; 366, expression_statement; 366, 367; 367, assignment; 367, 368; 367, 369; 368, identifier:desc_node; 369, call; 369, 370; 369, 371; 370, identifier:create_description_node; 371, argument_list; 371, 372; 371, 373; 372, identifier:field; 373, identifier:state; 374, expression_statement; 374, 375; 375, assignment; 375, 376; 375, 377; 376, identifier:title; 377, call; 377, 378; 377, 379; 378, identifier:create_title_node; 379, argument_list; 379, 380; 379, 381; 379, 382; 379, 383; 379, 384; 380, identifier:field_name; 381, identifier:field; 382, identifier:field_id; 383, identifier:state; 384, identifier:lineno; 385, return_statement; 385, 386; 386, list:[title, dl, desc_node]; 386, 387; 386, 388; 386, 389; 387, identifier:title; 388, identifier:dl; 389, identifier:desc_node | def format_registryfield_nodes(field_name, field, field_id, state, lineno):
from lsst.pex.config.registry import ConfigurableWrapper
choice_dl = nodes.definition_list()
for choice_value, choice_class in field.registry.items():
if hasattr(choice_class, '__module__') \
and hasattr(choice_class, '__name__'):
name = '.'.join((choice_class.__module__, choice_class.__name__))
elif isinstance(choice_class, ConfigurableWrapper):
name = '.'.join((choice_class._target.__class__.__module__,
choice_class._target.__class__.__name__))
else:
name = '.'.join((choice_class.__class__.__module__,
choice_class.__class__.__name__))
item = nodes.definition_list_item()
item_term = nodes.term()
item_term += nodes.literal(text=repr(choice_value))
item += item_term
item_definition = nodes.definition()
def_para = nodes.paragraph()
def_para += pending_task_xref(rawsource=name)
item_definition += def_para
item += item_definition
choice_dl.append(item)
choices_node = nodes.definition_list_item()
choices_node.append(nodes.term(text='Choices'))
choices_definition = nodes.definition()
choices_definition.append(choice_dl)
choices_node.append(choices_definition)
field_type_item = nodes.definition_list_item()
field_type_item.append(nodes.term(text="Field type"))
field_type_item_content = nodes.definition()
field_type_item_content_p = nodes.paragraph()
if field.multi:
multi_text = "Multi-selection "
else:
multi_text = "Single-selection "
field_type_item_content_p += nodes.Text(multi_text, multi_text)
field_type_item_content_p += make_python_xref_nodes_for_type(
type(field),
state,
hide_namespace=True)[0].children[0]
if field.optional:
field_type_item_content_p += nodes.Text(' (optional)', ' (optional)')
field_type_item_content += field_type_item_content_p
field_type_item += field_type_item_content
dl = nodes.definition_list()
dl += create_default_item_node(field, state)
dl += field_type_item
dl += choices_node
desc_node = create_description_node(field, state)
title = create_title_node(field_name, field, field_id, state, lineno)
return [title, dl, desc_node] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:translate_argv; 3, parameters; 3, 4; 4, identifier:raw_args; 5, block; 5, 6; 5, 10; 5, 57; 5, 64; 5, 86; 5, 93; 5, 147; 5, 154; 5, 165; 5, 172; 5, 183; 5, 190; 5, 204; 5, 211; 5, 225; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:kwargs; 9, dictionary; 10, function_definition; 10, 11; 10, 12; 10, 14; 11, function_name:get_parameter; 12, parameters; 12, 13; 13, identifier:param_str; 14, block; 14, 15; 14, 55; 15, for_statement; 15, 16; 15, 19; 15, 23; 16, pattern_list; 16, 17; 16, 18; 17, identifier:i; 18, identifier:a; 19, call; 19, 20; 19, 21; 20, identifier:enumerate; 21, argument_list; 21, 22; 22, identifier:raw_args; 23, block; 23, 24; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:==; 25, 26; 25, 27; 26, identifier:a; 27, identifier:param_str; 28, block; 28, 29; 28, 49; 29, assert_statement; 29, 30; 29, 48; 30, boolean_operator:and; 30, 31; 30, 39; 31, comparison_operator:==; 31, 32; 31, 36; 32, call; 32, 33; 32, 34; 33, identifier:len; 34, argument_list; 34, 35; 35, identifier:raw_args; 36, binary_operator:+; 36, 37; 36, 38; 37, identifier:i; 38, integer:2; 39, comparison_operator:!=; 39, 40; 39, 47; 40, subscript; 40, 41; 40, 46; 41, subscript; 41, 42; 41, 43; 42, identifier:raw_args; 43, binary_operator:+; 43, 44; 43, 45; 44, identifier:i; 45, integer:1; 46, integer:0; 47, string:'-'; 48, string:'All arguments must have a value, e.g. `-testing true`'; 49, return_statement; 49, 50; 50, subscript; 50, 51; 50, 52; 51, identifier:raw_args; 52, binary_operator:+; 52, 53; 52, 54; 53, identifier:i; 54, integer:1; 55, return_statement; 55, 56; 56, None; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:value; 60, call; 60, 61; 60, 62; 61, identifier:get_parameter; 62, argument_list; 62, 63; 63, string:'-testing'; 64, if_statement; 64, 65; 64, 79; 65, boolean_operator:and; 65, 66; 65, 69; 66, comparison_operator:is; 66, 67; 66, 68; 67, identifier:value; 68, None; 69, comparison_operator:in; 69, 70; 69, 75; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:value; 73, identifier:lower; 74, argument_list; 75, tuple; 75, 76; 75, 77; 75, 78; 76, string:'true'; 77, string:'t'; 78, string:'yes'; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 85; 82, subscript; 82, 83; 82, 84; 83, identifier:kwargs; 84, string:'testing'; 85, True; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:value; 89, call; 89, 90; 89, 91; 90, identifier:get_parameter; 91, argument_list; 91, 92; 92, string:'-connect'; 93, if_statement; 93, 94; 93, 97; 94, comparison_operator:is; 94, 95; 94, 96; 95, identifier:value; 96, None; 97, block; 97, 98; 97, 107; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:colon; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:value; 104, identifier:find; 105, argument_list; 105, 106; 106, string:':'; 107, if_statement; 107, 108; 107, 112; 107, 139; 108, comparison_operator:>; 108, 109; 108, 110; 109, identifier:colon; 110, unary_operator:-; 110, 111; 111, integer:1; 112, block; 112, 113; 112, 124; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 118; 115, subscript; 115, 116; 115, 117; 116, identifier:kwargs; 117, string:'host'; 118, subscript; 118, 119; 118, 120; 119, identifier:value; 120, slice; 120, 121; 120, 122; 120, 123; 121, integer:0; 122, colon; 123, identifier:colon; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 129; 126, subscript; 126, 127; 126, 128; 127, identifier:kwargs; 128, string:'port'; 129, call; 129, 130; 129, 131; 130, identifier:int; 131, argument_list; 131, 132; 132, subscript; 132, 133; 132, 134; 133, identifier:value; 134, slice; 134, 135; 134, 138; 135, binary_operator:+; 135, 136; 135, 137; 136, identifier:colon; 137, integer:1; 138, colon; 139, else_clause; 139, 140; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 146; 143, subscript; 143, 144; 143, 145; 144, identifier:kwargs; 145, string:'host'; 146, identifier:value; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:value; 150, call; 150, 151; 150, 152; 151, identifier:get_parameter; 152, argument_list; 152, 153; 153, string:'-name'; 154, if_statement; 154, 155; 154, 158; 155, comparison_operator:is; 155, 156; 155, 157; 156, identifier:value; 157, None; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 164; 161, subscript; 161, 162; 161, 163; 162, identifier:kwargs; 163, string:'name'; 164, identifier:value; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:value; 168, call; 168, 169; 168, 170; 169, identifier:get_parameter; 170, argument_list; 170, 171; 171, string:'-group'; 172, if_statement; 172, 173; 172, 176; 173, comparison_operator:is; 173, 174; 173, 175; 174, identifier:value; 175, None; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, subscript; 179, 180; 179, 181; 180, identifier:kwargs; 181, string:'group_name'; 182, identifier:value; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:value; 186, call; 186, 187; 186, 188; 187, identifier:get_parameter; 188, argument_list; 188, 189; 189, string:'-scan'; 190, if_statement; 190, 191; 190, 197; 191, comparison_operator:in; 191, 192; 191, 193; 192, identifier:value; 193, tuple; 193, 194; 193, 195; 193, 196; 194, string:'true'; 195, string:'t'; 196, string:'yes'; 197, block; 197, 198; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 200, subscript; 200, 201; 200, 202; 201, identifier:kwargs; 202, string:'scan_for_port'; 203, True; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:value; 207, call; 207, 208; 207, 209; 208, identifier:get_parameter; 209, argument_list; 209, 210; 210, string:'-debug'; 211, if_statement; 211, 212; 211, 218; 212, comparison_operator:in; 212, 213; 212, 214; 213, identifier:value; 214, tuple; 214, 215; 214, 216; 214, 217; 215, string:'true'; 216, string:'t'; 217, string:'yes'; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 224; 221, subscript; 221, 222; 221, 223; 222, identifier:kwargs; 223, string:'debug'; 224, True; 225, return_statement; 225, 226; 226, identifier:kwargs | def translate_argv(raw_args):
kwargs = {}
def get_parameter(param_str):
for i, a in enumerate(raw_args):
if a == param_str:
assert len(raw_args) == i+2 and raw_args[i+1][0] != '-', \
'All arguments must have a value, e.g. `-testing true`'
return raw_args[i+1]
return None
value = get_parameter('-testing')
if value is not None and value.lower() in ('true', 't', 'yes'):
kwargs['testing'] = True
value = get_parameter('-connect')
if value is not None:
colon = value.find(':')
if colon > -1:
kwargs['host'] = value[0:colon]
kwargs['port'] = int(value[colon+1:])
else:
kwargs['host'] = value
value = get_parameter('-name')
if value is not None:
kwargs['name'] = value
value = get_parameter('-group')
if value is not None:
kwargs['group_name'] = value
value = get_parameter('-scan')
if value in ('true', 't', 'yes'):
kwargs['scan_for_port'] = True
value = get_parameter('-debug')
if value in ('true', 't', 'yes'):
kwargs['debug'] = True
return kwargs |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:run; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 37; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:document; 9, attribute; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:state; 13, identifier:document; 14, if_statement; 14, 15; 14, 21; 15, not_operator; 15, 16; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:document; 19, identifier:settings; 20, identifier:file_insertion_enabled; 21, block; 21, 22; 22, return_statement; 22, 23; 23, list:[document.reporter.warning('File insertion disabled',
line=self.lineno)]; 23, 24; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:document; 28, identifier:reporter; 29, identifier:warning; 30, argument_list; 30, 31; 30, 32; 31, string:'File insertion disabled'; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:line; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:lineno; 37, try_statement; 37, 38; 37, 292; 38, block; 38, 39; 38, 52; 38, 60; 38, 73; 38, 86; 38, 96; 38, 102; 38, 135; 38, 158; 38, 172; 38, 180; 38, 244; 38, 252; 38, 282; 38, 289; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:location; 42, call; 42, 43; 42, 48; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:state_machine; 47, identifier:get_source_and_line; 48, argument_list; 48, 49; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:lineno; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:url; 55, subscript; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:arguments; 59, integer:0; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:reader; 63, call; 63, 64; 63, 65; 64, identifier:RemoteCodeBlockReader; 65, argument_list; 65, 66; 65, 67; 65, 70; 66, identifier:url; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:options; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:config; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 78; 75, pattern_list; 75, 76; 75, 77; 76, identifier:text; 77, identifier:lines; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:reader; 81, identifier:read; 82, argument_list; 82, 83; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:location; 85, identifier:location; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:retnode; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:nodes; 92, identifier:literal_block; 93, argument_list; 93, 94; 93, 95; 94, identifier:text; 95, identifier:text; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:set_source_info; 99, argument_list; 99, 100; 99, 101; 100, identifier:self; 101, identifier:retnode; 102, if_statement; 102, 103; 102, 111; 102, 118; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:options; 108, identifier:get; 109, argument_list; 109, 110; 110, string:'diff'; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:retnode; 116, string:'language'; 117, string:'udiff'; 118, elif_clause; 118, 119; 118, 124; 119, comparison_operator:in; 119, 120; 119, 121; 120, string:'language'; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:options; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:retnode; 129, string:'language'; 130, subscript; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:options; 134, string:'language'; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:retnode; 139, string:'linenos'; 140, parenthesized_expression; 140, 141; 141, boolean_operator:or; 141, 142; 141, 153; 142, boolean_operator:or; 142, 143; 142, 148; 143, comparison_operator:in; 143, 144; 143, 145; 144, string:'linenos'; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:options; 148, comparison_operator:in; 148, 149; 148, 150; 149, string:'lineno-start'; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:options; 153, comparison_operator:in; 153, 154; 153, 155; 154, string:'lineno-match'; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:options; 158, expression_statement; 158, 159; 159, augmented_assignment:+=; 159, 160; 159, 163; 160, subscript; 160, 161; 160, 162; 161, identifier:retnode; 162, string:'classes'; 163, call; 163, 164; 163, 169; 164, attribute; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:options; 168, identifier:get; 169, argument_list; 169, 170; 169, 171; 170, string:'class'; 171, list:[]; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:extra_args; 175, assignment; 175, 176; 175, 179; 176, subscript; 176, 177; 176, 178; 177, identifier:retnode; 178, string:'highlight_args'; 179, dictionary; 180, if_statement; 180, 181; 180, 186; 181, comparison_operator:in; 181, 182; 181, 183; 182, string:'emphasize-lines'; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:options; 186, block; 186, 187; 186, 199; 186, 228; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:hl_lines; 190, call; 190, 191; 190, 192; 191, identifier:parselinenos; 192, argument_list; 192, 193; 192, 198; 193, subscript; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:self; 196, identifier:options; 197, string:'emphasize-lines'; 198, identifier:lines; 199, if_statement; 199, 200; 199, 209; 200, call; 200, 201; 200, 202; 201, identifier:any; 202, generator_expression; 202, 203; 202, 206; 203, comparison_operator:>=; 203, 204; 203, 205; 204, identifier:i; 205, identifier:lines; 206, for_in_clause; 206, 207; 206, 208; 207, identifier:i; 208, identifier:hl_lines; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:logger; 214, identifier:warning; 215, argument_list; 215, 216; 215, 225; 216, binary_operator:%; 216, 217; 216, 218; 217, string:'line number spec is out of range(1-%d): %r'; 218, tuple; 218, 219; 218, 220; 219, identifier:lines; 220, subscript; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:self; 223, identifier:options; 224, string:'emphasize-lines'; 225, keyword_argument; 225, 226; 225, 227; 226, identifier:location; 227, identifier:location; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 233; 230, subscript; 230, 231; 230, 232; 231, identifier:extra_args; 232, string:'hl_lines'; 233, list_comprehension; 233, 234; 233, 237; 233, 240; 234, binary_operator:+; 234, 235; 234, 236; 235, identifier:x; 236, integer:1; 237, for_in_clause; 237, 238; 237, 239; 238, identifier:x; 239, identifier:hl_lines; 240, if_clause; 240, 241; 241, comparison_operator:<; 241, 242; 241, 243; 242, identifier:x; 243, identifier:lines; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 249; 246, subscript; 246, 247; 246, 248; 247, identifier:extra_args; 248, string:'linenostart'; 249, attribute; 249, 250; 249, 251; 250, identifier:reader; 251, identifier:lineno_start; 252, if_statement; 252, 253; 252, 258; 253, comparison_operator:in; 253, 254; 253, 255; 254, string:'caption'; 255, attribute; 255, 256; 255, 257; 256, identifier:self; 257, identifier:options; 258, block; 258, 259; 258, 273; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:caption; 262, boolean_operator:or; 262, 263; 262, 268; 263, subscript; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:self; 266, identifier:options; 267, string:'caption'; 268, subscript; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:self; 271, identifier:arguments; 272, integer:0; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:retnode; 276, call; 276, 277; 276, 278; 277, identifier:container_wrapper; 278, argument_list; 278, 279; 278, 280; 278, 281; 279, identifier:self; 280, identifier:retnode; 281, identifier:caption; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:self; 286, identifier:add_name; 287, argument_list; 287, 288; 288, identifier:retnode; 289, return_statement; 289, 290; 290, list:[retnode]; 290, 291; 291, identifier:retnode; 292, except_clause; 292, 293; 292, 297; 293, as_pattern; 293, 294; 293, 295; 294, identifier:Exception; 295, as_pattern_target; 295, 296; 296, identifier:exc; 297, block; 297, 298; 298, return_statement; 298, 299; 299, list:[document.reporter.warning(str(exc), line=self.lineno)]; 299, 300; 300, call; 300, 301; 300, 306; 301, attribute; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:document; 304, identifier:reporter; 305, identifier:warning; 306, argument_list; 306, 307; 306, 311; 307, call; 307, 308; 307, 309; 308, identifier:str; 309, argument_list; 309, 310; 310, identifier:exc; 311, keyword_argument; 311, 312; 311, 313; 312, identifier:line; 313, attribute; 313, 314; 313, 315; 314, identifier:self; 315, identifier:lineno | def run(self):
document = self.state.document
if not document.settings.file_insertion_enabled:
return [document.reporter.warning('File insertion disabled',
line=self.lineno)]
try:
location = self.state_machine.get_source_and_line(self.lineno)
url = self.arguments[0]
reader = RemoteCodeBlockReader(url, self.options, self.config)
text, lines = reader.read(location=location)
retnode = nodes.literal_block(text, text)
set_source_info(self, retnode)
if self.options.get('diff'):
retnode['language'] = 'udiff'
elif 'language' in self.options:
retnode['language'] = self.options['language']
retnode['linenos'] = ('linenos' in self.options or
'lineno-start' in self.options or
'lineno-match' in self.options)
retnode['classes'] += self.options.get('class', [])
extra_args = retnode['highlight_args'] = {}
if 'emphasize-lines' in self.options:
hl_lines = parselinenos(self.options['emphasize-lines'], lines)
if any(i >= lines for i in hl_lines):
logger.warning(
'line number spec is out of range(1-%d): %r' %
(lines, self.options['emphasize-lines']),
location=location)
extra_args['hl_lines'] = [x + 1 for x in hl_lines if x < lines]
extra_args['linenostart'] = reader.lineno_start
if 'caption' in self.options:
caption = self.options['caption'] or self.arguments[0]
retnode = container_wrapper(self, retnode, caption)
self.add_name(retnode)
return [retnode]
except Exception as exc:
return [document.reporter.warning(str(exc), line=self.lineno)] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:aggregate_duplicates; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:X; 5, identifier:Y; 6, default_parameter; 6, 7; 6, 8; 7, identifier:aggregator; 8, string:"mean"; 9, default_parameter; 9, 10; 9, 11; 10, identifier:precision; 11, identifier:precision; 12, block; 12, 13; 12, 139; 12, 147; 12, 158; 12, 170; 12, 177; 12, 184; 12, 193; 12, 208; 12, 223; 12, 238; 12, 285; 12, 297; 13, if_statement; 13, 14; 13, 18; 13, 20; 13, 35; 13, 50; 13, 65; 13, 82; 13, 100; 13, 119; 14, call; 14, 15; 14, 16; 15, identifier:callable; 16, argument_list; 16, 17; 17, identifier:aggregator; 18, block; 18, 19; 19, pass_statement; 20, elif_clause; 20, 21; 20, 28; 21, comparison_operator:in; 21, 22; 21, 23; 22, string:"min"; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:aggregator; 26, identifier:lower; 27, argument_list; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:aggregator; 32, attribute; 32, 33; 32, 34; 33, identifier:np; 34, identifier:min; 35, elif_clause; 35, 36; 35, 43; 36, comparison_operator:in; 36, 37; 36, 38; 37, string:"max"; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:aggregator; 41, identifier:lower; 42, argument_list; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:aggregator; 47, attribute; 47, 48; 47, 49; 48, identifier:np; 49, identifier:max; 50, elif_clause; 50, 51; 50, 58; 51, comparison_operator:in; 51, 52; 51, 53; 52, string:"median"; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:aggregator; 56, identifier:lower; 57, argument_list; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:aggregator; 62, attribute; 62, 63; 62, 64; 63, identifier:np; 64, identifier:median; 65, elif_clause; 65, 66; 65, 75; 66, comparison_operator:in; 66, 67; 66, 72; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:aggregator; 70, identifier:lower; 71, argument_list; 72, list:["average", "mean"]; 72, 73; 72, 74; 73, string:"average"; 74, string:"mean"; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:aggregator; 79, attribute; 79, 80; 79, 81; 80, identifier:np; 81, identifier:mean; 82, elif_clause; 82, 83; 82, 90; 83, comparison_operator:in; 83, 84; 83, 85; 84, string:"first"; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:aggregator; 88, identifier:lower; 89, argument_list; 90, block; 90, 91; 91, function_definition; 91, 92; 91, 93; 91, 95; 92, function_name:aggregator; 93, parameters; 93, 94; 94, identifier:x; 95, block; 95, 96; 96, return_statement; 96, 97; 97, subscript; 97, 98; 97, 99; 98, identifier:x; 99, integer:0; 100, elif_clause; 100, 101; 100, 108; 101, comparison_operator:in; 101, 102; 101, 103; 102, string:"last"; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:aggregator; 106, identifier:lower; 107, argument_list; 108, block; 108, 109; 109, function_definition; 109, 110; 109, 111; 109, 113; 110, function_name:aggregator; 111, parameters; 111, 112; 112, identifier:x; 113, block; 113, 114; 114, return_statement; 114, 115; 115, subscript; 115, 116; 115, 117; 116, identifier:x; 117, unary_operator:-; 117, 118; 118, integer:1; 119, else_clause; 119, 120; 120, block; 120, 121; 120, 135; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:warnings; 125, identifier:warn; 126, argument_list; 126, 127; 127, call; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, concatenated_string; 129, 130; 129, 131; 130, string:'Aggregator "{}" not understood. Skipping sample '; 131, string:"aggregation."; 132, identifier:format; 133, argument_list; 133, 134; 134, identifier:aggregator; 135, return_statement; 135, 136; 136, expression_list; 136, 137; 136, 138; 137, identifier:X; 138, identifier:Y; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:is_y_multivariate; 142, comparison_operator:>; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:Y; 145, identifier:ndim; 146, integer:1; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:X_rounded; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:X; 153, identifier:round; 154, argument_list; 154, 155; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:decimals; 157, identifier:precision; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:unique_xs; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:np; 164, identifier:unique; 165, argument_list; 165, 166; 165, 167; 166, identifier:X_rounded; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:axis; 169, integer:0; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:old_size; 173, call; 173, 174; 173, 175; 174, identifier:len; 175, argument_list; 175, 176; 176, identifier:X_rounded; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:new_size; 180, call; 180, 181; 180, 182; 181, identifier:len; 182, argument_list; 182, 183; 183, identifier:unique_xs; 184, if_statement; 184, 185; 184, 188; 185, comparison_operator:==; 185, 186; 185, 187; 186, identifier:old_size; 187, identifier:new_size; 188, block; 188, 189; 189, return_statement; 189, 190; 190, expression_list; 190, 191; 190, 192; 191, identifier:X; 192, identifier:Y; 193, if_statement; 193, 194; 193, 196; 194, not_operator; 194, 195; 195, identifier:is_y_multivariate; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:Y; 200, attribute; 200, 201; 200, 207; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:np; 204, identifier:atleast_2d; 205, argument_list; 205, 206; 206, identifier:Y; 207, identifier:T; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:reduced_y; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:np; 214, identifier:empty; 215, argument_list; 215, 216; 216, tuple; 216, 217; 216, 218; 217, identifier:new_size; 218, subscript; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:Y; 221, identifier:shape; 222, integer:1; 223, expression_statement; 223, 224; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:warnings; 227, identifier:warn; 228, argument_list; 228, 229; 229, binary_operator:+; 229, 230; 229, 231; 230, string:"Domain space duplicates caused a data reduction. "; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, string:"Original size: {} vs. New size: {}"; 234, identifier:format; 235, argument_list; 235, 236; 235, 237; 236, identifier:old_size; 237, identifier:new_size; 238, for_statement; 238, 239; 238, 240; 238, 248; 239, identifier:col; 240, call; 240, 241; 240, 242; 241, identifier:range; 242, argument_list; 242, 243; 243, subscript; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:Y; 246, identifier:shape; 247, integer:1; 248, block; 248, 249; 249, for_statement; 249, 250; 249, 253; 249, 257; 250, pattern_list; 250, 251; 250, 252; 251, identifier:i; 252, identifier:distinct_row; 253, call; 253, 254; 253, 255; 254, identifier:enumerate; 255, argument_list; 255, 256; 256, identifier:unique_xs; 257, block; 257, 258; 257, 272; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:filtered_rows; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:np; 264, identifier:all; 265, argument_list; 265, 266; 265, 269; 266, comparison_operator:==; 266, 267; 266, 268; 267, identifier:X_rounded; 268, identifier:distinct_row; 269, keyword_argument; 269, 270; 269, 271; 270, identifier:axis; 271, integer:1; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 278; 274, subscript; 274, 275; 274, 276; 274, 277; 275, identifier:reduced_y; 276, identifier:i; 277, identifier:col; 278, call; 278, 279; 278, 280; 279, identifier:aggregator; 280, argument_list; 280, 281; 281, subscript; 281, 282; 281, 283; 281, 284; 282, identifier:Y; 283, identifier:filtered_rows; 284, identifier:col; 285, if_statement; 285, 286; 285, 288; 286, not_operator; 286, 287; 287, identifier:is_y_multivariate; 288, block; 288, 289; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 292; 291, identifier:reduced_y; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:reduced_y; 295, identifier:flatten; 296, argument_list; 297, return_statement; 297, 298; 298, expression_list; 298, 299; 298, 300; 299, identifier:unique_xs; 300, identifier:reduced_y | def aggregate_duplicates(X, Y, aggregator="mean", precision=precision):
if callable(aggregator):
pass
elif "min" in aggregator.lower():
aggregator = np.min
elif "max" in aggregator.lower():
aggregator = np.max
elif "median" in aggregator.lower():
aggregator = np.median
elif aggregator.lower() in ["average", "mean"]:
aggregator = np.mean
elif "first" in aggregator.lower():
def aggregator(x):
return x[0]
elif "last" in aggregator.lower():
def aggregator(x):
return x[-1]
else:
warnings.warn(
'Aggregator "{}" not understood. Skipping sample '
"aggregation.".format(aggregator)
)
return X, Y
is_y_multivariate = Y.ndim > 1
X_rounded = X.round(decimals=precision)
unique_xs = np.unique(X_rounded, axis=0)
old_size = len(X_rounded)
new_size = len(unique_xs)
if old_size == new_size:
return X, Y
if not is_y_multivariate:
Y = np.atleast_2d(Y).T
reduced_y = np.empty((new_size, Y.shape[1]))
warnings.warn(
"Domain space duplicates caused a data reduction. "
+ "Original size: {} vs. New size: {}".format(old_size, new_size)
)
for col in range(Y.shape[1]):
for i, distinct_row in enumerate(unique_xs):
filtered_rows = np.all(X_rounded == distinct_row, axis=1)
reduced_y[i, col] = aggregator(Y[filtered_rows, col])
if not is_y_multivariate:
reduced_y = reduced_y.flatten()
return unique_xs, reduced_y |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:install; 3, parameters; 3, 4; 3, 5; 4, identifier:application; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 27; 7, 46; 7, 65; 7, 84; 7, 95; 8, if_statement; 8, 9; 8, 17; 9, comparison_operator:is; 9, 10; 9, 16; 10, call; 10, 11; 10, 12; 11, identifier:getattr; 12, argument_list; 12, 13; 12, 14; 12, 15; 13, identifier:application; 14, string:'statsd'; 15, None; 16, None; 17, block; 17, 18; 17, 25; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:LOGGER; 22, identifier:warning; 23, argument_list; 23, 24; 24, string:'Statsd collector is already installed'; 25, return_statement; 25, 26; 26, False; 27, if_statement; 27, 28; 27, 31; 28, comparison_operator:not; 28, 29; 28, 30; 29, string:'host'; 30, identifier:kwargs; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 37; 34, subscript; 34, 35; 34, 36; 35, identifier:kwargs; 36, string:'host'; 37, call; 37, 38; 37, 43; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:os; 41, identifier:environ; 42, identifier:get; 43, argument_list; 43, 44; 43, 45; 44, string:'STATSD_HOST'; 45, string:'127.0.0.1'; 46, if_statement; 46, 47; 46, 50; 47, comparison_operator:not; 47, 48; 47, 49; 48, string:'port'; 49, identifier:kwargs; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:kwargs; 55, string:'port'; 56, call; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:os; 60, identifier:environ; 61, identifier:get; 62, argument_list; 62, 63; 62, 64; 63, string:'STATSD_PORT'; 64, string:'8125'; 65, if_statement; 65, 66; 65, 69; 66, comparison_operator:not; 66, 67; 66, 68; 67, string:'protocol'; 68, identifier:kwargs; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 75; 72, subscript; 72, 73; 72, 74; 73, identifier:kwargs; 74, string:'protocol'; 75, call; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:os; 79, identifier:environ; 80, identifier:get; 81, argument_list; 81, 82; 81, 83; 82, string:'STATSD_PROTOCOL'; 83, string:'udp'; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 87; 86, identifier:setattr; 87, argument_list; 87, 88; 87, 89; 87, 90; 88, identifier:application; 89, string:'statsd'; 90, call; 90, 91; 90, 92; 91, identifier:StatsDCollector; 92, argument_list; 92, 93; 93, dictionary_splat; 93, 94; 94, identifier:kwargs; 95, return_statement; 95, 96; 96, True | def install(application, **kwargs):
if getattr(application, 'statsd', None) is not None:
LOGGER.warning('Statsd collector is already installed')
return False
if 'host' not in kwargs:
kwargs['host'] = os.environ.get('STATSD_HOST', '127.0.0.1')
if 'port' not in kwargs:
kwargs['port'] = os.environ.get('STATSD_PORT', '8125')
if 'protocol' not in kwargs:
kwargs['protocol'] = os.environ.get('STATSD_PROTOCOL', 'udp')
setattr(application, 'statsd', StatsDCollector(**kwargs))
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sign; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:user_id; 5, default_parameter; 5, 6; 5, 7; 6, identifier:user_type; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:today; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:session; 13, None; 14, block; 14, 15; 14, 32; 14, 51; 14, 74; 14, 220; 14, 227; 15, if_statement; 15, 16; 15, 19; 15, 26; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:session; 18, None; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:session; 23, call; 23, 24; 23, 25; 24, identifier:Session; 25, argument_list; 26, else_clause; 26, 27; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:session; 31, identifier:session; 32, if_statement; 32, 33; 32, 36; 32, 45; 33, comparison_operator:is; 33, 34; 33, 35; 34, identifier:today; 35, None; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:today; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:date; 43, identifier:today; 44, argument_list; 45, else_clause; 45, 46; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:today; 50, identifier:today; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:user; 54, parenthesized_expression; 54, 55; 55, call; 55, 56; 55, 73; 56, attribute; 56, 57; 56, 72; 57, call; 57, 58; 57, 66; 58, attribute; 58, 59; 58, 65; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:session; 62, identifier:query; 63, argument_list; 63, 64; 64, identifier:User; 65, identifier:filter; 66, argument_list; 66, 67; 67, comparison_operator:==; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:User; 70, identifier:user_id; 71, identifier:user_id; 72, identifier:one_or_none; 73, argument_list; 74, if_statement; 74, 75; 74, 76; 74, 208; 75, identifier:user; 76, block; 76, 77; 76, 109; 76, 202; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:signed_in_entries; 80, parenthesized_expression; 80, 81; 81, call; 81, 82; 81, 108; 82, attribute; 82, 83; 82, 107; 83, call; 83, 84; 83, 98; 84, attribute; 84, 85; 84, 97; 85, call; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:user; 89, identifier:entries; 90, identifier:filter; 91, argument_list; 91, 92; 92, comparison_operator:==; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:Entry; 95, identifier:date; 96, identifier:today; 97, identifier:filter; 98, argument_list; 98, 99; 99, call; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:Entry; 103, identifier:time_out; 104, identifier:is_; 105, argument_list; 105, 106; 106, None; 107, identifier:all; 108, argument_list; 109, if_statement; 109, 110; 109, 112; 109, 156; 110, not_operator; 110, 111; 111, identifier:signed_in_entries; 112, block; 112, 113; 112, 123; 112, 130; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:new_entry; 116, call; 116, 117; 116, 118; 117, identifier:sign_in; 118, argument_list; 118, 119; 118, 120; 119, identifier:user; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:user_type; 122, identifier:user_type; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:session; 127, identifier:add; 128, argument_list; 128, 129; 129, identifier:new_entry; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:status; 133, call; 133, 134; 133, 135; 134, identifier:Status; 135, argument_list; 135, 136; 135, 139; 135, 142; 135, 148; 135, 153; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:valid; 138, True; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:in_or_out; 141, string:'in'; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:user_name; 144, call; 144, 145; 144, 146; 145, identifier:get_user_name; 146, argument_list; 146, 147; 147, identifier:user; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:user_type; 150, attribute; 150, 151; 150, 152; 151, identifier:new_entry; 152, identifier:user_type; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:entry; 155, identifier:new_entry; 156, else_clause; 156, 157; 157, block; 157, 158; 158, for_statement; 158, 159; 158, 160; 158, 161; 159, identifier:entry; 160, identifier:signed_in_entries; 161, block; 161, 162; 161, 169; 161, 176; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:signed_out_entry; 165, call; 165, 166; 165, 167; 166, identifier:sign_out; 167, argument_list; 167, 168; 168, identifier:entry; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:session; 173, identifier:add; 174, argument_list; 174, 175; 175, identifier:signed_out_entry; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:status; 179, call; 179, 180; 179, 181; 180, identifier:Status; 181, argument_list; 181, 182; 181, 185; 181, 188; 181, 194; 181, 199; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:valid; 184, True; 185, keyword_argument; 185, 186; 185, 187; 186, identifier:in_or_out; 187, string:'out'; 188, keyword_argument; 188, 189; 188, 190; 189, identifier:user_name; 190, call; 190, 191; 190, 192; 191, identifier:get_user_name; 192, argument_list; 192, 193; 193, identifier:user; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:user_type; 196, attribute; 196, 197; 196, 198; 197, identifier:signed_out_entry; 198, identifier:user_type; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:entry; 201, identifier:signed_out_entry; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:session; 206, identifier:commit; 207, argument_list; 208, else_clause; 208, 209; 209, block; 209, 210; 210, raise_statement; 210, 211; 211, call; 211, 212; 211, 213; 212, identifier:UnregisteredUser; 213, argument_list; 213, 214; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, string:'{} not registered. Please register at the front desk.'; 217, identifier:format; 218, argument_list; 218, 219; 219, identifier:user_id; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:logger; 224, identifier:debug; 225, argument_list; 225, 226; 226, identifier:status; 227, return_statement; 227, 228; 228, identifier:status | def sign(user_id, user_type=None, today=None, session=None):
if session is None:
session = Session()
else:
session = session
if today is None:
today = date.today()
else:
today = today
user = (
session
.query(User)
.filter(User.user_id == user_id)
.one_or_none()
)
if user:
signed_in_entries = (
user
.entries
.filter(Entry.date == today)
.filter(Entry.time_out.is_(None))
.all()
)
if not signed_in_entries:
new_entry = sign_in(user, user_type=user_type)
session.add(new_entry)
status = Status(
valid=True,
in_or_out='in',
user_name=get_user_name(user),
user_type=new_entry.user_type,
entry=new_entry
)
else:
for entry in signed_in_entries:
signed_out_entry = sign_out(entry)
session.add(signed_out_entry)
status = Status(
valid=True,
in_or_out='out',
user_name=get_user_name(user),
user_type=signed_out_entry.user_type,
entry=signed_out_entry
)
session.commit()
else:
raise UnregisteredUser(
'{} not registered. Please register at the front desk.'.format(
user_id
)
)
logger.debug(status)
return status |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:display; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:obj; 5, default_parameter; 5, 6; 5, 7; 6, identifier:skiphidden; 7, True; 8, dictionary_splat_pattern; 8, 9; 9, identifier:printargs; 10, block; 10, 11; 10, 18; 10, 37; 10, 87; 10, 122; 10, 210; 10, 241; 10, 254; 10, 273; 10, 283; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:top; 14, call; 14, 15; 14, 16; 15, identifier:findnode; 16, argument_list; 16, 17; 17, identifier:obj; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:maxhex; 21, binary_operator:-; 21, 22; 21, 36; 22, call; 22, 23; 22, 24; 23, identifier:len; 24, argument_list; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:hex; 27, argument_list; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:ctypes; 31, identifier:sizeof; 32, argument_list; 32, 33; 33, attribute; 33, 34; 33, 35; 34, identifier:top; 35, identifier:type; 36, integer:2; 37, function_definition; 37, 38; 37, 39; 37, 41; 38, function_name:addrformat; 39, parameters; 39, 40; 40, identifier:addr; 41, block; 41, 42; 42, if_statement; 42, 43; 42, 48; 42, 57; 43, call; 43, 44; 43, 45; 44, identifier:isinstance; 45, argument_list; 45, 46; 45, 47; 46, identifier:addr; 47, identifier:int; 48, block; 48, 49; 49, return_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, string:"0x{0:0{1}X}"; 53, identifier:format; 54, argument_list; 54, 55; 54, 56; 55, identifier:addr; 56, identifier:maxhex; 57, else_clause; 57, 58; 58, block; 58, 59; 58, 66; 58, 78; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:intpart; 62, call; 62, 63; 62, 64; 63, identifier:int; 64, argument_list; 64, 65; 65, identifier:addr; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:fracbits; 69, call; 69, 70; 69, 71; 70, identifier:int; 71, argument_list; 71, 72; 72, binary_operator:*; 72, 73; 72, 77; 73, parenthesized_expression; 73, 74; 74, binary_operator:-; 74, 75; 74, 76; 75, identifier:addr; 76, identifier:intpart; 77, integer:8; 78, return_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, string:"0x{0:0{1}X}'{2}"; 82, identifier:format; 83, argument_list; 83, 84; 83, 85; 83, 86; 84, identifier:intpart; 85, identifier:maxhex; 86, identifier:fracbits; 87, function_definition; 87, 88; 87, 89; 87, 91; 88, function_name:formatval; 89, parameters; 89, 90; 90, identifier:here; 91, block; 91, 92; 92, if_statement; 92, 93; 92, 98; 92, 113; 93, call; 93, 94; 93, 95; 94, identifier:isinstance; 95, argument_list; 95, 96; 95, 97; 96, identifier:here; 97, identifier:BoundSimpleNode; 98, block; 98, 99; 99, return_statement; 99, 100; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, string:"{0}({1})"; 103, identifier:format; 104, argument_list; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:here; 108, identifier:type; 109, identifier:__name__; 110, attribute; 110, 111; 110, 112; 111, identifier:here; 112, identifier:value; 113, else_clause; 113, 114; 114, block; 114, 115; 115, return_statement; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:str; 118, argument_list; 118, 119; 119, attribute; 119, 120; 119, 121; 120, identifier:here; 121, identifier:value; 122, if_statement; 122, 123; 122, 128; 122, 169; 123, call; 123, 124; 123, 125; 124, identifier:isinstance; 125, argument_list; 125, 126; 125, 127; 126, identifier:top; 127, identifier:UnboundNode; 128, block; 128, 129; 128, 136; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:headers; 132, list:['Path', 'Addr', 'Type']; 132, 133; 132, 134; 132, 135; 133, string:'Path'; 134, string:'Addr'; 135, string:'Type'; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:results; 139, list_comprehension; 139, 140; 139, 162; 140, tuple; 140, 141; 140, 151; 140, 157; 141, binary_operator:+; 141, 142; 141, 148; 142, parenthesized_expression; 142, 143; 143, binary_operator:*; 143, 144; 143, 145; 144, string:' '; 145, attribute; 145, 146; 145, 147; 146, identifier:n; 147, identifier:depth; 148, attribute; 148, 149; 148, 150; 149, identifier:n; 150, identifier:name; 151, call; 151, 152; 151, 153; 152, identifier:addrformat; 153, argument_list; 153, 154; 154, attribute; 154, 155; 154, 156; 155, identifier:n; 156, identifier:baseoffset; 157, attribute; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:n; 160, identifier:type; 161, identifier:__name__; 162, for_in_clause; 162, 163; 162, 164; 163, identifier:n; 164, call; 164, 165; 164, 166; 165, identifier:walknode; 166, argument_list; 166, 167; 166, 168; 167, identifier:top; 168, identifier:skiphidden; 169, else_clause; 169, 170; 170, block; 170, 171; 170, 178; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:headers; 174, list:['Path', 'Addr', 'Value']; 174, 175; 174, 176; 174, 177; 175, string:'Path'; 176, string:'Addr'; 177, string:'Value'; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:results; 181, list_comprehension; 181, 182; 181, 203; 182, tuple; 182, 183; 182, 193; 182, 199; 183, binary_operator:+; 183, 184; 183, 190; 184, parenthesized_expression; 184, 185; 185, binary_operator:*; 185, 186; 185, 187; 186, string:' '; 187, attribute; 187, 188; 187, 189; 188, identifier:n; 189, identifier:depth; 190, attribute; 190, 191; 190, 192; 191, identifier:n; 192, identifier:name; 193, call; 193, 194; 193, 195; 194, identifier:addrformat; 195, argument_list; 195, 196; 196, attribute; 196, 197; 196, 198; 197, identifier:n; 198, identifier:baseoffset; 199, call; 199, 200; 199, 201; 200, identifier:formatval; 201, argument_list; 201, 202; 202, identifier:n; 203, for_in_clause; 203, 204; 203, 205; 204, identifier:n; 205, call; 205, 206; 205, 207; 206, identifier:walknode; 207, argument_list; 207, 208; 207, 209; 208, identifier:top; 209, identifier:skiphidden; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:widths; 213, list_comprehension; 213, 214; 213, 233; 214, call; 214, 215; 214, 216; 215, identifier:max; 216, argument_list; 216, 217; 216, 229; 217, call; 217, 218; 217, 219; 218, identifier:max; 219, generator_expression; 219, 220; 219, 226; 220, call; 220, 221; 220, 222; 221, identifier:len; 222, argument_list; 222, 223; 223, subscript; 223, 224; 223, 225; 224, identifier:d; 225, identifier:col; 226, for_in_clause; 226, 227; 226, 228; 227, identifier:d; 228, identifier:results; 229, call; 229, 230; 229, 231; 230, identifier:len; 231, argument_list; 231, 232; 232, identifier:h; 233, for_in_clause; 233, 234; 233, 237; 234, pattern_list; 234, 235; 234, 236; 235, identifier:col; 236, identifier:h; 237, call; 237, 238; 237, 239; 238, identifier:enumerate; 239, argument_list; 239, 240; 240, identifier:headers; 241, function_definition; 241, 242; 241, 243; 241, 245; 242, function_name:lp; 243, parameters; 243, 244; 244, identifier:args; 245, block; 245, 246; 246, expression_statement; 246, 247; 247, call; 247, 248; 247, 249; 248, identifier:print; 249, argument_list; 249, 250; 249, 252; 250, list_splat; 250, 251; 251, identifier:args; 252, dictionary_splat; 252, 253; 253, identifier:printargs; 254, expression_statement; 254, 255; 255, call; 255, 256; 255, 257; 256, identifier:lp; 257, generator_expression; 257, 258; 257, 264; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:d; 261, identifier:center; 262, argument_list; 262, 263; 263, identifier:w; 264, for_in_clause; 264, 265; 264, 268; 265, pattern_list; 265, 266; 265, 267; 266, identifier:d; 267, identifier:w; 268, call; 268, 269; 268, 270; 269, identifier:zip; 270, argument_list; 270, 271; 270, 272; 271, identifier:headers; 272, identifier:widths; 273, expression_statement; 273, 274; 274, call; 274, 275; 274, 276; 275, identifier:lp; 276, generator_expression; 276, 277; 276, 280; 277, binary_operator:*; 277, 278; 277, 279; 278, string:'-'; 279, identifier:w; 280, for_in_clause; 280, 281; 280, 282; 281, identifier:w; 282, identifier:widths; 283, for_statement; 283, 284; 283, 285; 283, 286; 284, identifier:r; 285, identifier:results; 286, block; 286, 287; 287, expression_statement; 287, 288; 288, call; 288, 289; 288, 290; 289, identifier:lp; 290, generator_expression; 290, 291; 290, 297; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:d; 294, identifier:ljust; 295, argument_list; 295, 296; 296, identifier:w; 297, for_in_clause; 297, 298; 297, 301; 298, pattern_list; 298, 299; 298, 300; 299, identifier:d; 300, identifier:w; 301, call; 301, 302; 301, 303; 302, identifier:zip; 303, argument_list; 303, 304; 303, 305; 304, identifier:r; 305, identifier:widths | def display(obj, skiphidden=True, **printargs):
top = findnode(obj)
maxhex = len(hex(ctypes.sizeof(top.type))) - 2
def addrformat(addr):
if isinstance(addr, int):
return "0x{0:0{1}X}".format(addr, maxhex)
else:
intpart = int(addr)
fracbits = int((addr - intpart) * 8)
return "0x{0:0{1}X}'{2}".format(intpart, maxhex, fracbits)
def formatval(here):
if isinstance(here, BoundSimpleNode):
return "{0}({1})".format(here.type.__name__, here.value)
else:
return str(here.value)
if isinstance(top, UnboundNode):
headers = ['Path', 'Addr', 'Type']
results = [
((' ' * n.depth) + n.name, addrformat(n.baseoffset), n.type.__name__)
for n in walknode(top, skiphidden)
]
else:
headers = ['Path', 'Addr', 'Value']
results = [
((' ' * n.depth) + n.name, addrformat(n.baseoffset), formatval(n))
for n in walknode(top, skiphidden)
]
widths = [
max(max(len(d[col]) for d in results), len(h))
for col, h in enumerate(headers)
]
def lp(args):
print(*args, **printargs)
lp(d.center(w) for d, w in zip(headers, widths))
lp('-' * w for w in widths)
for r in results:
lp(d.ljust(w) for d, w in zip(r, widths)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:assemble; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 8; 4, identifier:self; 5, identifier:module; 6, list_splat_pattern; 6, 7; 7, identifier:modules; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 47; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:mgr; 14, call; 14, 15; 14, 16; 15, identifier:AssemblyManager; 16, argument_list; 16, 17; 16, 20; 16, 29; 16, 38; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:vector; 19, identifier:self; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:modules; 22, binary_operator:+; 22, 23; 22, 25; 23, list:[module]; 23, 24; 24, identifier:module; 25, call; 25, 26; 25, 27; 26, identifier:list; 27, argument_list; 27, 28; 28, identifier:modules; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:name; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:kwargs; 34, identifier:get; 35, argument_list; 35, 36; 35, 37; 36, string:"name"; 37, string:"assembly"; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:id_; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:kwargs; 43, identifier:get; 44, argument_list; 44, 45; 44, 46; 45, string:"id"; 46, string:"assembly"; 47, return_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:mgr; 51, identifier:assemble; 52, argument_list | def assemble(self, module, *modules, **kwargs):
mgr = AssemblyManager(
vector=self,
modules=[module] + list(modules),
name=kwargs.get("name", "assembly"),
id_=kwargs.get("id", "assembly"),
)
return mgr.assemble() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:getback; 3, parameters; 3, 4; 3, 5; 4, identifier:config; 5, default_parameter; 5, 6; 5, 7; 6, identifier:force; 7, False; 8, block; 8, 9; 8, 15; 8, 21; 8, 33; 8, 71; 8, 77; 8, 86; 8, 96; 8, 100; 8, 104; 8, 122; 8, 136; 8, 146; 8, 157; 8, 198; 8, 204; 8, 210; 8, 237; 8, 243; 8, 268; 8, 272; 8, 295; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:repo; 12, attribute; 12, 13; 12, 14; 13, identifier:config; 14, identifier:repo; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:active_branch; 18, attribute; 18, 19; 18, 20; 19, identifier:repo; 20, identifier:active_branch; 21, if_statement; 21, 22; 21, 27; 22, comparison_operator:==; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:active_branch; 25, identifier:name; 26, string:"master"; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:error_out; 31, argument_list; 31, 32; 32, string:"You're already on the master branch."; 33, if_statement; 33, 34; 33, 39; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:repo; 37, identifier:is_dirty; 38, argument_list; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:error_out; 43, argument_list; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, string:'Repo is "dirty". ({})'; 47, identifier:format; 48, argument_list; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, string:", "; 52, identifier:join; 53, argument_list; 53, 54; 54, list_comprehension; 54, 55; 54, 61; 55, call; 55, 56; 55, 57; 56, identifier:repr; 57, argument_list; 57, 58; 58, attribute; 58, 59; 58, 60; 59, identifier:x; 60, identifier:b_path; 61, for_in_clause; 61, 62; 61, 63; 62, identifier:x; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:repo; 67, identifier:index; 68, identifier:diff; 69, argument_list; 69, 70; 70, None; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:branch_name; 74, attribute; 74, 75; 74, 76; 75, identifier:active_branch; 76, identifier:name; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:state; 80, call; 80, 81; 80, 82; 81, identifier:read; 82, argument_list; 82, 83; 83, attribute; 83, 84; 83, 85; 84, identifier:config; 85, identifier:configfile; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:origin_name; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:state; 92, identifier:get; 93, argument_list; 93, 94; 93, 95; 94, string:"ORIGIN_NAME"; 95, string:"origin"; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:upstream_remote; 99, None; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:fork_remote; 103, None; 104, for_statement; 104, 105; 104, 106; 104, 109; 105, identifier:remote; 106, attribute; 106, 107; 106, 108; 107, identifier:repo; 108, identifier:remotes; 109, block; 109, 110; 110, if_statement; 110, 111; 110, 116; 111, comparison_operator:==; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:remote; 114, identifier:name; 115, identifier:origin_name; 116, block; 116, 117; 116, 121; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:upstream_remote; 120, identifier:remote; 121, break_statement; 122, if_statement; 122, 123; 122, 125; 123, not_operator; 123, 124; 124, identifier:upstream_remote; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:error_out; 129, argument_list; 129, 130; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, string:"No remote called {!r} found"; 133, identifier:format; 134, argument_list; 134, 135; 135, identifier:origin_name; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 145; 138, attribute; 138, 139; 138, 144; 139, attribute; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:repo; 142, identifier:heads; 143, identifier:master; 144, identifier:checkout; 145, argument_list; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:upstream_remote; 150, identifier:pull; 151, argument_list; 151, 152; 152, attribute; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:repo; 155, identifier:heads; 156, identifier:master; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:merged_branches; 160, list_comprehension; 160, 161; 160, 166; 160, 180; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:x; 164, identifier:strip; 165, argument_list; 166, for_in_clause; 166, 167; 166, 168; 167, identifier:x; 168, call; 168, 169; 168, 179; 169, attribute; 169, 170; 169, 178; 170, call; 170, 171; 170, 176; 171, attribute; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:repo; 174, identifier:git; 175, identifier:branch; 176, argument_list; 176, 177; 177, string:"--merged"; 178, identifier:splitlines; 179, argument_list; 180, if_clause; 180, 181; 181, boolean_operator:and; 181, 182; 181, 187; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:x; 185, identifier:strip; 186, argument_list; 187, not_operator; 187, 188; 188, call; 188, 189; 188, 196; 189, attribute; 189, 190; 189, 195; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:x; 193, identifier:strip; 194, argument_list; 195, identifier:startswith; 196, argument_list; 196, 197; 197, string:"*"; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:was_merged; 201, comparison_operator:in; 201, 202; 201, 203; 202, identifier:branch_name; 203, identifier:merged_branches; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:certain; 207, boolean_operator:or; 207, 208; 207, 209; 208, identifier:was_merged; 209, identifier:force; 210, if_statement; 210, 211; 210, 213; 211, not_operator; 211, 212; 212, identifier:certain; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:certain; 217, parenthesized_expression; 217, 218; 218, comparison_operator:!=; 218, 219; 218, 236; 219, call; 219, 220; 219, 235; 220, attribute; 220, 221; 220, 234; 221, call; 221, 222; 221, 233; 222, attribute; 222, 223; 222, 232; 223, call; 223, 224; 223, 225; 224, identifier:input; 225, argument_list; 225, 226; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, string:"Are you certain {} is actually merged? [Y/n] "; 229, identifier:format; 230, argument_list; 230, 231; 231, identifier:branch_name; 232, identifier:lower; 233, argument_list; 234, identifier:strip; 235, argument_list; 236, string:"n"; 237, if_statement; 237, 238; 237, 240; 238, not_operator; 238, 239; 239, identifier:certain; 240, block; 240, 241; 241, return_statement; 241, 242; 242, integer:1; 243, if_statement; 243, 244; 243, 245; 243, 256; 244, identifier:was_merged; 245, block; 245, 246; 246, expression_statement; 246, 247; 247, call; 247, 248; 247, 253; 248, attribute; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:repo; 251, identifier:git; 252, identifier:branch; 253, argument_list; 253, 254; 253, 255; 254, string:"-d"; 255, identifier:branch_name; 256, else_clause; 256, 257; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 265; 260, attribute; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:repo; 263, identifier:git; 264, identifier:branch; 265, argument_list; 265, 266; 265, 267; 266, string:"-D"; 267, identifier:branch_name; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:fork_remote; 271, None; 272, for_statement; 272, 273; 272, 274; 272, 277; 273, identifier:remote; 274, attribute; 274, 275; 274, 276; 275, identifier:repo; 276, identifier:remotes; 277, block; 277, 278; 278, if_statement; 278, 279; 278, 289; 279, comparison_operator:==; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:remote; 282, identifier:name; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:state; 286, identifier:get; 287, argument_list; 287, 288; 288, string:"FORK_NAME"; 289, block; 289, 290; 289, 294; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:fork_remote; 293, identifier:remote; 294, break_statement; 295, if_statement; 295, 296; 295, 297; 296, identifier:fork_remote; 297, block; 297, 298; 297, 307; 298, expression_statement; 298, 299; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:fork_remote; 302, identifier:push; 303, argument_list; 303, 304; 304, binary_operator:+; 304, 305; 304, 306; 305, string:":"; 306, identifier:branch_name; 307, expression_statement; 307, 308; 308, call; 308, 309; 308, 310; 309, identifier:info_out; 310, argument_list; 310, 311; 311, string:"Remote branch on fork deleted too." | def getback(config, force=False):
repo = config.repo
active_branch = repo.active_branch
if active_branch.name == "master":
error_out("You're already on the master branch.")
if repo.is_dirty():
error_out(
'Repo is "dirty". ({})'.format(
", ".join([repr(x.b_path) for x in repo.index.diff(None)])
)
)
branch_name = active_branch.name
state = read(config.configfile)
origin_name = state.get("ORIGIN_NAME", "origin")
upstream_remote = None
fork_remote = None
for remote in repo.remotes:
if remote.name == origin_name:
upstream_remote = remote
break
if not upstream_remote:
error_out("No remote called {!r} found".format(origin_name))
repo.heads.master.checkout()
upstream_remote.pull(repo.heads.master)
merged_branches = [
x.strip()
for x in repo.git.branch("--merged").splitlines()
if x.strip() and not x.strip().startswith("*")
]
was_merged = branch_name in merged_branches
certain = was_merged or force
if not certain:
certain = (
input("Are you certain {} is actually merged? [Y/n] ".format(branch_name))
.lower()
.strip()
!= "n"
)
if not certain:
return 1
if was_merged:
repo.git.branch("-d", branch_name)
else:
repo.git.branch("-D", branch_name)
fork_remote = None
for remote in repo.remotes:
if remote.name == state.get("FORK_NAME"):
fork_remote = remote
break
if fork_remote:
fork_remote.push(":" + branch_name)
info_out("Remote branch on fork deleted too.") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:untldict_normalizer; 3, parameters; 3, 4; 3, 5; 4, identifier:untl_dict; 5, identifier:normalizations; 6, block; 6, 7; 6, 99; 7, for_statement; 7, 8; 7, 11; 7, 16; 8, pattern_list; 8, 9; 8, 10; 9, identifier:element_type; 10, identifier:element_list; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:untl_dict; 14, identifier:items; 15, argument_list; 16, block; 16, 17; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:in; 18, 19; 18, 20; 19, identifier:element_type; 20, identifier:normalizations; 21, block; 21, 22; 21, 31; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:norm_qualifier_list; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:normalizations; 28, identifier:get; 29, argument_list; 29, 30; 30, identifier:element_type; 31, for_statement; 31, 32; 31, 33; 31, 34; 32, identifier:element; 33, identifier:element_list; 34, block; 34, 35; 34, 45; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:qualifier; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:element; 41, identifier:get; 42, argument_list; 42, 43; 42, 44; 43, string:'qualifier'; 44, None; 45, if_statement; 45, 46; 45, 49; 46, comparison_operator:in; 46, 47; 46, 48; 47, identifier:qualifier; 48, identifier:norm_qualifier_list; 49, block; 49, 50; 49, 60; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:content; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:element; 56, identifier:get; 57, argument_list; 57, 58; 57, 59; 58, string:'content'; 59, None; 60, if_statement; 60, 61; 60, 64; 61, comparison_operator:in; 61, 62; 61, 63; 62, identifier:element_type; 63, identifier:ELEMENT_NORMALIZERS; 64, block; 64, 65; 64, 75; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:elem_norms; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:ELEMENT_NORMALIZERS; 71, identifier:get; 72, argument_list; 72, 73; 72, 74; 73, identifier:element_type; 74, None; 75, if_statement; 75, 76; 75, 79; 76, comparison_operator:in; 76, 77; 76, 78; 77, identifier:qualifier; 78, identifier:elem_norms; 79, block; 79, 80; 80, if_statement; 80, 81; 80, 86; 81, boolean_operator:and; 81, 82; 81, 83; 82, identifier:content; 83, comparison_operator:!=; 83, 84; 83, 85; 84, identifier:content; 85, string:''; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 88, 93; 89, subscript; 89, 90; 89, 91; 90, identifier:element; 91, string:'content'; 92, line_continuation:\; 93, call; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:elem_norms; 96, identifier:qualifier; 97, argument_list; 97, 98; 98, identifier:content; 99, return_statement; 99, 100; 100, identifier:untl_dict | def untldict_normalizer(untl_dict, normalizations):
for element_type, element_list in untl_dict.items():
if element_type in normalizations:
norm_qualifier_list = normalizations.get(element_type)
for element in element_list:
qualifier = element.get('qualifier', None)
if qualifier in norm_qualifier_list:
content = element.get('content', None)
if element_type in ELEMENT_NORMALIZERS:
elem_norms = ELEMENT_NORMALIZERS.get(element_type,
None)
if qualifier in elem_norms:
if content and content != '':
element['content'] = \
elem_norms[qualifier](content)
return untl_dict |
0, module; 0, 1; 1, ERROR; 1, 2; 1, 207; 1, 214; 1, 223; 1, 237; 1, 254; 1, 263; 1, 269; 1, 286; 2, function_definition; 2, 3; 2, 4; 2, 9; 3, function_name:start; 4, parameters; 4, 5; 4, 6; 5, identifier:config; 6, default_parameter; 6, 7; 6, 8; 7, identifier:bugnumber; 8, string:""; 9, block; 9, 10; 9, 16; 9, 40; 9, 74; 9, 78; 9, 113; 9, 177; 9, 188; 9, 197; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:repo; 13, attribute; 13, 14; 13, 15; 14, identifier:config; 15, identifier:repo; 16, if_statement; 16, 17; 16, 18; 16, 30; 17, identifier:bugnumber; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 25; 21, pattern_list; 21, 22; 21, 23; 21, 24; 22, identifier:summary; 23, identifier:bugnumber; 24, identifier:url; 25, call; 25, 26; 25, 27; 26, identifier:get_summary; 27, argument_list; 27, 28; 27, 29; 28, identifier:config; 29, identifier:bugnumber; 30, else_clause; 30, 31; 31, block; 31, 32; 31, 36; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:url; 35, None; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:summary; 39, None; 40, if_statement; 40, 41; 40, 42; 40, 61; 41, identifier:summary; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:summary; 46, boolean_operator:or; 46, 47; 46, 60; 47, call; 47, 48; 47, 59; 48, attribute; 48, 49; 48, 58; 49, call; 49, 50; 49, 51; 50, identifier:input; 51, argument_list; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, string:'Summary ["{}"]: '; 55, identifier:format; 56, argument_list; 56, 57; 57, identifier:summary; 58, identifier:strip; 59, argument_list; 60, identifier:summary; 61, else_clause; 61, 62; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:summary; 66, call; 66, 67; 66, 73; 67, attribute; 67, 68; 67, 72; 68, call; 68, 69; 68, 70; 69, identifier:input; 70, argument_list; 70, 71; 71, string:"Summary: "; 72, identifier:strip; 73, argument_list; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:branch_name; 77, string:""; 78, if_statement; 78, 79; 78, 80; 79, identifier:bugnumber; 80, block; 80, 81; 81, if_statement; 81, 82; 81, 92; 81, 102; 82, call; 82, 83; 82, 84; 83, identifier:is_github; 84, argument_list; 84, 85; 85, dictionary; 85, 86; 85, 89; 86, pair; 86, 87; 86, 88; 87, string:"bugnumber"; 88, identifier:bugnumber; 89, pair; 89, 90; 89, 91; 90, string:"url"; 91, identifier:url; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:branch_name; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, string:"{}-"; 99, identifier:format; 100, argument_list; 100, 101; 101, identifier:bugnumber; 102, else_clause; 102, 103; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:branch_name; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, string:"{}-"; 110, identifier:format; 111, argument_list; 111, 112; 112, identifier:bugnumber; 113, function_definition; 113, 114; 113, 115; 113, 117; 113, 166; 114, function_name:clean_branch_name; 115, parameters; 115, 116; 116, identifier:string; 117, ERROR; 117, 118; 117, 129; 117, 139; 117, 155; 117, 156; 117, 159; 117, 165; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:string; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:re; 124, identifier:sub; 125, argument_list; 125, 126; 125, 127; 125, 128; 126, string:r"\s+"; 127, string:" "; 128, identifier:string; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:string; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:string; 135, identifier:replace; 136, argument_list; 136, 137; 136, 138; 137, string:" "; 138, string:"-"; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:string; 142, call; 142, 143; 142, 152; 143, attribute; 143, 144; 143, 151; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:string; 147, identifier:replace; 148, argument_list; 148, 149; 148, 150; 149, string:"->"; 150, string:"-"; 151, identifier:replace; 152, argument_list; 152, 153; 152, 154; 153, string:"=>"; 154, string:"-"; 155, identifier:each; 156, binary_operator:/; 156, 157; 156, 158; 157, string:"@%^&:'\"; 158, tuple; 159, ERROR; 159, 160; 159, 161; 159, 162; 159, 164; 160, list:[]; 161, dictionary; 162, ERROR; 162, 163; 163, ERROR:!; 164, ERROR:?; 165, ERROR:$; 166, block; 166, 167; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:string; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:string; 173, identifier:replace; 174, argument_list; 174, 175; 174, 176; 175, identifier:each; 176, string:""; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:string; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:re; 183, identifier:sub; 184, argument_list; 184, 185; 184, 186; 184, 187; 185, string:"-+"; 186, string:"-"; 187, identifier:string; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:string; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:string; 194, identifier:strip; 195, argument_list; 195, 196; 196, string:"-"; 197, return_statement; 197, 198; 198, call; 198, 199; 198, 206; 199, attribute; 199, 200; 199, 205; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:string; 203, identifier:lower; 204, argument_list; 205, identifier:strip; 206, argument_list; 207, expression_statement; 207, 208; 208, augmented_assignment:+=; 208, 209; 208, 210; 209, identifier:branch_name; 210, call; 210, 211; 210, 212; 211, identifier:clean_branch_name; 212, argument_list; 212, 213; 213, identifier:summary; 214, if_statement; 214, 215; 214, 217; 215, not_operator; 215, 216; 216, identifier:branch_name; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 221; 220, identifier:error_out; 221, argument_list; 221, 222; 222, string:"Must provide a branch name"; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:found; 226, call; 226, 227; 226, 228; 227, identifier:list; 228, argument_list; 228, 229; 229, call; 229, 230; 229, 231; 230, identifier:find; 231, argument_list; 231, 232; 231, 233; 231, 234; 232, identifier:repo; 233, identifier:branch_name; 234, keyword_argument; 234, 235; 234, 236; 235, identifier:exact; 236, True; 237, if_statement; 237, 238; 237, 239; 238, identifier:found; 239, block; 239, 240; 240, expression_statement; 240, 241; 241, call; 241, 242; 241, 243; 242, identifier:error_out; 243, argument_list; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, string:"There is already a branch called {!r}"; 247, identifier:format; 248, argument_list; 248, 249; 249, attribute; 249, 250; 249, 253; 250, subscript; 250, 251; 250, 252; 251, identifier:found; 252, integer:0; 253, identifier:name; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:new_branch; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:repo; 260, identifier:create_head; 261, argument_list; 261, 262; 262, identifier:branch_name; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:new_branch; 267, identifier:checkout; 268, argument_list; 269, if_statement; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:config; 272, identifier:verbose; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:click; 278, identifier:echo; 279, argument_list; 279, 280; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, string:"Checkout out new branch: {}"; 283, identifier:format; 284, argument_list; 284, 285; 285, identifier:branch_name; 286, expression_statement; 286, 287; 287, call; 287, 288; 287, 289; 288, identifier:save; 289, argument_list; 289, 290; 289, 293; 289, 294; 289, 295; 289, 298; 290, attribute; 290, 291; 290, 292; 291, identifier:config; 292, identifier:configfile; 293, identifier:summary; 294, identifier:branch_name; 295, keyword_argument; 295, 296; 295, 297; 296, identifier:bugnumber; 297, identifier:bugnumber; 298, keyword_argument; 298, 299; 298, 300; 299, identifier:url; 300, identifier:url | def start(config, bugnumber=""):
repo = config.repo
if bugnumber:
summary, bugnumber, url = get_summary(config, bugnumber)
else:
url = None
summary = None
if summary:
summary = input('Summary ["{}"]: '.format(summary)).strip() or summary
else:
summary = input("Summary: ").strip()
branch_name = ""
if bugnumber:
if is_github({"bugnumber": bugnumber, "url": url}):
branch_name = "{}-".format(bugnumber)
else:
branch_name = "{}-".format(bugnumber)
def clean_branch_name(string):
string = re.sub(r"\s+", " ", string)
string = string.replace(" ", "-")
string = string.replace("->", "-").replace("=>", "-")
for each in "@%^&:'\"/(),[]{}!.?`$<>
string = string.replace(each, "")
string = re.sub("-+", "-", string)
string = string.strip("-")
return string.lower().strip()
branch_name += clean_branch_name(summary)
if not branch_name:
error_out("Must provide a branch name")
found = list(find(repo, branch_name, exact=True))
if found:
error_out("There is already a branch called {!r}".format(found[0].name))
new_branch = repo.create_head(branch_name)
new_branch.checkout()
if config.verbose:
click.echo("Checkout out new branch: {}".format(branch_name))
save(config.configfile, summary, branch_name, bugnumber=bugnumber, url=url) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 1, 12; 2, function_name:getPortSideView; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:side; 6, type; 6, 7; 7, generic_type; 7, 8; 7, 9; 8, identifier:List; 9, type_parameter; 9, 10; 10, type; 10, 11; 11, string:"LPort"; 12, block; 12, 13; 13, if_statement; 13, 14; 13, 19; 13, 24; 13, 35; 13, 46; 13, 57; 14, comparison_operator:==; 14, 15; 14, 16; 15, identifier:side; 16, attribute; 16, 17; 16, 18; 17, identifier:PortSide; 18, identifier:WEST; 19, block; 19, 20; 20, return_statement; 20, 21; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:west; 24, elif_clause; 24, 25; 24, 30; 25, comparison_operator:==; 25, 26; 25, 27; 26, identifier:side; 27, attribute; 27, 28; 27, 29; 28, identifier:PortSide; 29, identifier:EAST; 30, block; 30, 31; 31, return_statement; 31, 32; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:east; 35, elif_clause; 35, 36; 35, 41; 36, comparison_operator:==; 36, 37; 36, 38; 37, identifier:side; 38, attribute; 38, 39; 38, 40; 39, identifier:PortSide; 40, identifier:NORTH; 41, block; 41, 42; 42, return_statement; 42, 43; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:north; 46, elif_clause; 46, 47; 46, 52; 47, comparison_operator:==; 47, 48; 47, 49; 48, identifier:side; 49, attribute; 49, 50; 49, 51; 50, identifier:PortSide; 51, identifier:SOUTH; 52, block; 52, 53; 53, return_statement; 53, 54; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:south; 57, else_clause; 57, 58; 58, block; 58, 59; 59, raise_statement; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:ValueError; 62, argument_list; 62, 63; 63, identifier:side | def getPortSideView(self, side) -> List["LPort"]:
if side == PortSide.WEST:
return self.west
elif side == PortSide.EAST:
return self.east
elif side == PortSide.NORTH:
return self.north
elif side == PortSide.SOUTH:
return self.south
else:
raise ValueError(side) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:command_line_config; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 16; 5, 20; 5, 24; 5, 28; 5, 108; 5, 208; 5, 241; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:args; 9, subscript; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:sys; 12, identifier:argv; 13, slice; 13, 14; 13, 15; 14, integer:1; 15, colon; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:args_dict; 19, dictionary; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:existed_keys; 23, list:[]; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:new_keys; 27, list:[]; 28, for_statement; 28, 29; 28, 30; 28, 31; 29, identifier:t; 30, identifier:args; 31, block; 31, 32; 31, 50; 31, 81; 31, 87; 32, if_statement; 32, 33; 32, 40; 33, not_operator; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:t; 37, identifier:startswith; 38, argument_list; 38, 39; 39, string:'--'; 40, block; 40, 41; 41, raise_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:errors; 45, identifier:ArgsParseError; 46, argument_list; 46, 47; 47, binary_operator:%; 47, 48; 47, 49; 48, string:'Bad arg: %s'; 49, identifier:t; 50, try_statement; 50, 51; 50, 70; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 57; 54, pattern_list; 54, 55; 54, 56; 55, identifier:key; 56, identifier:value; 57, call; 57, 58; 57, 59; 58, identifier:tuple; 59, argument_list; 59, 60; 60, call; 60, 61; 60, 68; 61, attribute; 61, 62; 61, 67; 62, subscript; 62, 63; 62, 64; 63, identifier:t; 64, slice; 64, 65; 64, 66; 65, integer:2; 66, colon; 67, identifier:split; 68, argument_list; 68, 69; 69, string:'='; 70, except_clause; 70, 71; 71, block; 71, 72; 72, raise_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:errors; 76, identifier:ArgsParseError; 77, argument_list; 77, 78; 78, binary_operator:%; 78, 79; 78, 80; 79, string:'Bad arg: %s'; 80, identifier:t; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:args_dict; 85, identifier:key; 86, identifier:value; 87, if_statement; 87, 88; 87, 91; 87, 99; 88, comparison_operator:in; 88, 89; 88, 90; 89, identifier:key; 90, identifier:settings; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:existed_keys; 96, identifier:append; 97, argument_list; 97, 98; 98, identifier:key; 99, else_clause; 99, 100; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:new_keys; 105, identifier:append; 106, argument_list; 106, 107; 107, identifier:key; 108, if_statement; 108, 109; 108, 110; 109, identifier:existed_keys; 110, block; 110, 111; 110, 118; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:app_log; 115, identifier:debug; 116, argument_list; 116, 117; 117, string:'Changed settings:'; 118, for_statement; 118, 119; 118, 120; 118, 121; 119, identifier:i; 120, identifier:existed_keys; 121, block; 121, 122; 121, 128; 121, 135; 121, 184; 121, 190; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:before; 125, subscript; 125, 126; 125, 127; 126, identifier:settings; 127, identifier:i; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:type_; 131, call; 131, 132; 131, 133; 132, identifier:type; 133, argument_list; 133, 134; 134, identifier:before; 135, if_statement; 135, 136; 135, 139; 135, 173; 136, comparison_operator:is; 136, 137; 136, 138; 137, identifier:type_; 138, identifier:bool; 139, block; 139, 140; 140, if_statement; 140, 141; 140, 146; 140, 151; 140, 162; 141, comparison_operator:==; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:args_dict; 144, identifier:i; 145, string:'True'; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:_value; 150, True; 151, elif_clause; 151, 152; 151, 157; 152, comparison_operator:==; 152, 153; 152, 156; 153, subscript; 153, 154; 153, 155; 154, identifier:args_dict; 155, identifier:i; 156, string:'False'; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:_value; 161, False; 162, else_clause; 162, 163; 163, block; 163, 164; 164, raise_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:errors; 168, identifier:ArgsParseError; 169, argument_list; 169, 170; 170, binary_operator:%; 170, 171; 170, 172; 171, string:'%s should only be True or False'; 172, identifier:i; 173, else_clause; 173, 174; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:_value; 178, call; 178, 179; 178, 180; 179, identifier:type_; 180, argument_list; 180, 181; 181, subscript; 181, 182; 181, 183; 182, identifier:args_dict; 183, identifier:i; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:settings; 188, identifier:i; 189, identifier:_value; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:app_log; 194, identifier:debug; 195, argument_list; 195, 196; 195, 197; 195, 198; 195, 204; 195, 207; 196, string:' %s [%s]%s (%s)'; 197, identifier:i; 198, call; 198, 199; 198, 200; 199, identifier:type; 200, argument_list; 200, 201; 201, subscript; 201, 202; 201, 203; 202, identifier:settings; 203, identifier:i; 204, subscript; 204, 205; 204, 206; 205, identifier:settings; 206, identifier:i; 207, identifier:before; 208, if_statement; 208, 209; 208, 210; 209, identifier:new_keys; 210, block; 210, 211; 210, 218; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:app_log; 215, identifier:debug; 216, argument_list; 216, 217; 217, string:'New settings:'; 218, for_statement; 218, 219; 218, 220; 218, 221; 219, identifier:i; 220, identifier:new_keys; 221, block; 221, 222; 221, 230; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 227; 224, subscript; 224, 225; 224, 226; 225, identifier:settings; 226, identifier:i; 227, subscript; 227, 228; 227, 229; 228, identifier:args_dict; 229, identifier:i; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:app_log; 234, identifier:debug; 235, argument_list; 235, 236; 235, 237; 235, 238; 236, string:' %s %s'; 237, identifier:i; 238, subscript; 238, 239; 238, 240; 239, identifier:args_dict; 240, identifier:i; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:update_settings; 246, argument_list; 246, 247; 247, dictionary | def command_line_config(self):
args = sys.argv[1:]
args_dict = {}
existed_keys = []
new_keys = []
for t in args:
if not t.startswith('--'):
raise errors.ArgsParseError('Bad arg: %s' % t)
try:
key, value = tuple(t[2:].split('='))
except:
raise errors.ArgsParseError('Bad arg: %s' % t)
args_dict[key] = value
if key in settings:
existed_keys.append(key)
else:
new_keys.append(key)
if existed_keys:
app_log.debug('Changed settings:')
for i in existed_keys:
before = settings[i]
type_ = type(before)
if type_ is bool:
if args_dict[i] == 'True':
_value = True
elif args_dict[i] == 'False':
_value = False
else:
raise errors.ArgsParseError('%s should only be True or False' % i)
else:
_value = type_(args_dict[i])
settings[i] = _value
app_log.debug(' %s [%s]%s (%s)', i, type(settings[i]), settings[i], before)
if new_keys:
app_log.debug('New settings:')
for i in new_keys:
settings[i] = args_dict[i]
app_log.debug(' %s %s', i, args_dict[i])
self.update_settings({}) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:create_form_data; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 18; 7, 28; 7, 38; 7, 48; 7, 56; 7, 197; 7, 201; 7, 261; 7, 309; 7, 321; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:children; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:kwargs; 14, identifier:get; 15, argument_list; 15, 16; 15, 17; 16, string:'children'; 17, list:[]; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:sort_order; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:kwargs; 24, identifier:get; 25, argument_list; 25, 26; 25, 27; 26, string:'sort_order'; 27, None; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:solr_response; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:kwargs; 34, identifier:get; 35, argument_list; 35, 36; 35, 37; 36, string:'solr_response'; 37, None; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:superuser; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:kwargs; 44, identifier:get; 45, argument_list; 45, 46; 45, 47; 46, string:'superuser'; 47, False; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:vocabularies; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:get_vocabularies; 55, argument_list; 56, for_statement; 56, 57; 56, 58; 56, 59; 57, identifier:element; 58, identifier:children; 59, block; 59, 60; 59, 74; 59, 96; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:element; 64, identifier:children; 65, call; 65, 66; 65, 67; 66, identifier:add_missing_children; 67, argument_list; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:element; 70, identifier:contained_children; 71, attribute; 71, 72; 71, 73; 72, identifier:element; 73, identifier:children; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:element; 78, identifier:add_form; 79, argument_list; 79, 80; 79, 83; 79, 88; 79, 93; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:vocabularies; 82, identifier:vocabularies; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:qualifier; 85, attribute; 85, 86; 85, 87; 86, identifier:element; 87, identifier:qualifier; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:content; 90, attribute; 90, 91; 90, 92; 91, identifier:element; 92, identifier:content; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:superuser; 95, identifier:superuser; 96, if_statement; 96, 97; 96, 102; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:element; 100, identifier:form; 101, identifier:has_children; 102, block; 102, 103; 102, 139; 102, 164; 103, if_statement; 103, 104; 103, 112; 104, call; 104, 105; 104, 106; 105, identifier:getattr; 106, argument_list; 106, 107; 106, 110; 106, 111; 107, attribute; 107, 108; 107, 109; 108, identifier:element; 109, identifier:form; 110, string:'qualifier_name'; 111, False; 112, block; 112, 113; 112, 130; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:add_parent; 116, call; 116, 117; 116, 124; 117, subscript; 117, 118; 117, 119; 118, identifier:PARENT_FORM; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:element; 122, identifier:form; 123, identifier:qualifier_name; 124, argument_list; 124, 125; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:content; 127, attribute; 127, 128; 127, 129; 128, identifier:element; 129, identifier:qualifier; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:element; 135, identifier:children; 136, identifier:append; 137, argument_list; 137, 138; 138, identifier:add_parent; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 146; 141, attribute; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:element; 144, identifier:children; 145, identifier:sort; 146, argument_list; 146, 147; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:key; 149, lambda; 149, 150; 149, 152; 150, lambda_parameters; 150, 151; 151, identifier:obj; 152, call; 152, 153; 152, 160; 153, attribute; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:element; 157, identifier:form; 158, identifier:child_sort; 159, identifier:index; 160, argument_list; 160, 161; 161, attribute; 161, 162; 161, 163; 162, identifier:obj; 163, identifier:tag; 164, for_statement; 164, 165; 164, 166; 164, 169; 165, identifier:child; 166, attribute; 166, 167; 166, 168; 167, identifier:element; 168, identifier:children; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:child; 174, identifier:add_form; 175, argument_list; 175, 176; 175, 179; 175, 184; 175, 189; 175, 194; 176, keyword_argument; 176, 177; 176, 178; 177, identifier:vocabularies; 178, identifier:vocabularies; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:qualifier; 181, attribute; 181, 182; 181, 183; 182, identifier:child; 183, identifier:qualifier; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:content; 186, attribute; 186, 187; 186, 188; 187, identifier:child; 188, identifier:content; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:parent_tag; 191, attribute; 191, 192; 191, 193; 192, identifier:element; 193, identifier:tag; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:superuser; 196, identifier:superuser; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:element_group_dict; 200, dictionary; 201, for_statement; 201, 202; 201, 203; 201, 204; 202, identifier:element; 203, identifier:children; 204, block; 204, 205; 205, if_statement; 205, 206; 205, 219; 205, 227; 206, boolean_operator:and; 206, 207; 206, 214; 207, comparison_operator:==; 207, 208; 207, 213; 208, attribute; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:element; 211, identifier:form; 212, identifier:name; 213, string:'meta'; 214, comparison_operator:==; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:element; 217, identifier:qualifier; 218, string:'hidden'; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:element_group_dict; 224, string:'hidden'; 225, list:[element]; 225, 226; 226, identifier:element; 227, else_clause; 227, 228; 228, block; 228, 229; 228, 248; 229, if_statement; 229, 230; 229, 237; 230, comparison_operator:not; 230, 231; 230, 236; 231, attribute; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:element; 234, identifier:form; 235, identifier:name; 236, identifier:element_group_dict; 237, block; 237, 238; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 247; 240, subscript; 240, 241; 240, 242; 241, identifier:element_group_dict; 242, attribute; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:element; 245, identifier:form; 246, identifier:name; 247, list:[]; 248, expression_statement; 248, 249; 249, call; 249, 250; 249, 259; 250, attribute; 250, 251; 250, 258; 251, subscript; 251, 252; 251, 253; 252, identifier:element_group_dict; 253, attribute; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:element; 256, identifier:form; 257, identifier:name; 258, identifier:append; 259, argument_list; 259, 260; 260, identifier:element; 261, if_statement; 261, 262; 261, 265; 262, comparison_operator:not; 262, 263; 262, 264; 263, string:'hidden'; 264, identifier:element_group_dict; 265, block; 265, 266; 265, 280; 265, 302; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:hidden_element; 269, call; 269, 270; 269, 273; 270, subscript; 270, 271; 270, 272; 271, identifier:PYUNTL_DISPATCH; 272, string:'meta'; 273, argument_list; 273, 274; 273, 277; 274, keyword_argument; 274, 275; 274, 276; 275, identifier:qualifier; 276, string:'hidden'; 277, keyword_argument; 277, 278; 277, 279; 278, identifier:content; 279, string:'False'; 280, expression_statement; 280, 281; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:hidden_element; 284, identifier:add_form; 285, argument_list; 285, 286; 285, 289; 285, 294; 285, 299; 286, keyword_argument; 286, 287; 286, 288; 287, identifier:vocabularies; 288, identifier:vocabularies; 289, keyword_argument; 289, 290; 289, 291; 290, identifier:qualifier; 291, attribute; 291, 292; 291, 293; 292, identifier:hidden_element; 293, identifier:qualifier; 294, keyword_argument; 294, 295; 294, 296; 295, identifier:content; 296, attribute; 296, 297; 296, 298; 297, identifier:hidden_element; 298, identifier:content; 299, keyword_argument; 299, 300; 299, 301; 300, identifier:superuser; 301, identifier:superuser; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 307; 304, subscript; 304, 305; 304, 306; 305, identifier:element_group_dict; 306, string:'hidden'; 307, list:[hidden_element]; 307, 308; 308, identifier:hidden_element; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 312; 311, identifier:element_list; 312, call; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:self; 315, identifier:create_form_groupings; 316, argument_list; 316, 317; 316, 318; 316, 319; 316, 320; 317, identifier:vocabularies; 318, identifier:solr_response; 319, identifier:element_group_dict; 320, identifier:sort_order; 321, return_statement; 321, 322; 322, identifier:element_list | def create_form_data(self, **kwargs):
children = kwargs.get('children', [])
sort_order = kwargs.get('sort_order', None)
solr_response = kwargs.get('solr_response', None)
superuser = kwargs.get('superuser', False)
vocabularies = self.get_vocabularies()
for element in children:
element.children = add_missing_children(
element.contained_children,
element.children,
)
element.add_form(
vocabularies=vocabularies,
qualifier=element.qualifier,
content=element.content,
superuser=superuser,
)
if element.form.has_children:
if getattr(element.form, 'qualifier_name', False):
add_parent = PARENT_FORM[element.form.qualifier_name](
content=element.qualifier,
)
element.children.append(add_parent)
element.children.sort(
key=lambda obj: element.form.child_sort.index(obj.tag)
)
for child in element.children:
child.add_form(
vocabularies=vocabularies,
qualifier=child.qualifier,
content=child.content,
parent_tag=element.tag,
superuser=superuser,
)
element_group_dict = {}
for element in children:
if element.form.name == 'meta' and element.qualifier == 'hidden':
element_group_dict['hidden'] = [element]
else:
if element.form.name not in element_group_dict:
element_group_dict[element.form.name] = []
element_group_dict[element.form.name].append(element)
if 'hidden' not in element_group_dict:
hidden_element = PYUNTL_DISPATCH['meta'](
qualifier='hidden',
content='False')
hidden_element.add_form(
vocabularies=vocabularies,
qualifier=hidden_element.qualifier,
content=hidden_element.content,
superuser=superuser,
)
element_group_dict['hidden'] = [hidden_element]
element_list = self.create_form_groupings(
vocabularies,
solr_response,
element_group_dict,
sort_order,
)
return element_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_untl; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:sort_structure; 6, block; 6, 7; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 14; 9, attribute; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:children; 13, identifier:sort; 14, argument_list; 14, 15; 15, keyword_argument; 15, 16; 15, 17; 16, identifier:key; 17, lambda; 17, 18; 17, 20; 18, lambda_parameters; 18, 19; 19, identifier:obj; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:sort_structure; 23, identifier:index; 24, argument_list; 24, 25; 25, attribute; 25, 26; 25, 27; 26, identifier:obj; 27, identifier:tag | def sort_untl(self, sort_structure):
self.children.sort(key=lambda obj: sort_structure.index(obj.tag)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:top; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:sort_by; 6, block; 6, 7; 6, 19; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:sort; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, argument_list; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:results; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:key; 18, identifier:sort_by; 19, return_statement; 19, 20; 20, identifier:sort | def top(self, sort_by):
sort = sorted(self.results, key=sort_by)
return sort |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:portTryReduce; 3, parameters; 3, 4; 3, 8; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:root; 6, type; 6, 7; 7, identifier:LNode; 8, typed_parameter; 8, 9; 8, 10; 9, identifier:port; 10, type; 10, 11; 11, identifier:LPort; 12, block; 12, 13; 12, 20; 12, 32; 12, 36; 12, 44; 12, 49; 12, 73; 12, 80; 12, 96; 12, 102; 12, 108; 12, 294; 12, 310; 12, 326; 13, if_statement; 13, 14; 13, 18; 14, not_operator; 14, 15; 15, attribute; 15, 16; 15, 17; 16, identifier:port; 17, identifier:children; 18, block; 18, 19; 19, return_statement; 20, for_statement; 20, 21; 20, 22; 20, 25; 21, identifier:p; 22, attribute; 22, 23; 22, 24; 23, identifier:port; 24, identifier:children; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:portTryReduce; 29, argument_list; 29, 30; 29, 31; 30, identifier:root; 31, identifier:p; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:target_nodes; 35, dictionary; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:ch_cnt; 39, call; 39, 40; 39, 41; 40, identifier:countDirectlyConnected; 41, argument_list; 41, 42; 41, 43; 42, identifier:port; 43, identifier:target_nodes; 44, if_statement; 44, 45; 44, 47; 45, not_operator; 45, 46; 46, identifier:target_nodes; 47, block; 47, 48; 48, return_statement; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 54; 51, pattern_list; 51, 52; 51, 53; 52, identifier:new_target; 53, identifier:children_edge_to_destroy; 54, call; 54, 55; 54, 56; 55, identifier:max; 56, argument_list; 56, 57; 56, 62; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:target_nodes; 60, identifier:items; 61, argument_list; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:key; 64, lambda; 64, 65; 64, 67; 65, lambda_parameters; 65, 66; 66, identifier:x; 67, call; 67, 68; 67, 69; 68, identifier:len; 69, argument_list; 69, 70; 70, subscript; 70, 71; 70, 72; 71, identifier:x; 72, integer:1; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:cnt; 76, call; 76, 77; 76, 78; 77, identifier:len; 78, argument_list; 78, 79; 79, identifier:children_edge_to_destroy; 80, if_statement; 80, 81; 80, 94; 81, boolean_operator:or; 81, 82; 81, 87; 82, comparison_operator:<; 82, 83; 82, 84; 83, identifier:cnt; 84, binary_operator:/; 84, 85; 84, 86; 85, identifier:ch_cnt; 86, integer:2; 87, boolean_operator:and; 87, 88; 87, 91; 88, comparison_operator:==; 88, 89; 88, 90; 89, identifier:cnt; 90, integer:1; 91, comparison_operator:==; 91, 92; 91, 93; 92, identifier:ch_cnt; 93, integer:2; 94, block; 94, 95; 95, return_statement; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:children_to_destroy; 99, call; 99, 100; 99, 101; 100, identifier:set; 101, argument_list; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:on_target_children_to_destroy; 105, call; 105, 106; 105, 107; 106, identifier:set; 107, argument_list; 108, for_statement; 108, 109; 108, 112; 108, 113; 109, pattern_list; 109, 110; 109, 111; 110, identifier:child; 111, identifier:edge; 112, identifier:children_edge_to_destroy; 113, block; 113, 114; 113, 153; 113, 167; 113, 173; 113, 209; 113, 241; 113, 258; 113, 276; 114, if_statement; 114, 115; 114, 122; 114, 129; 114, 144; 115, comparison_operator:==; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:child; 118, identifier:direction; 119, attribute; 119, 120; 119, 121; 120, identifier:PortType; 121, identifier:OUTPUT; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:target_ch; 126, attribute; 126, 127; 126, 128; 127, identifier:edge; 128, identifier:dsts; 129, elif_clause; 129, 130; 129, 137; 130, comparison_operator:==; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:child; 133, identifier:direction; 134, attribute; 134, 135; 134, 136; 135, identifier:PortType; 136, identifier:INPUT; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:target_ch; 141, attribute; 141, 142; 141, 143; 142, identifier:edge; 143, identifier:srcs; 144, else_clause; 144, 145; 145, block; 145, 146; 146, raise_statement; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:ValueError; 149, argument_list; 149, 150; 150, attribute; 150, 151; 150, 152; 151, identifier:child; 152, identifier:direction; 153, if_statement; 153, 154; 153, 160; 154, comparison_operator:!=; 154, 155; 154, 159; 155, call; 155, 156; 155, 157; 156, identifier:len; 157, argument_list; 157, 158; 158, identifier:target_ch; 159, integer:1; 160, block; 160, 161; 161, raise_statement; 161, 162; 162, call; 162, 163; 162, 164; 163, identifier:NotImplementedError; 164, argument_list; 164, 165; 164, 166; 165, string:"multiple connected nodes"; 166, identifier:target_ch; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:target_ch; 170, subscript; 170, 171; 170, 172; 171, identifier:target_ch; 172, integer:0; 173, try_statement; 173, 174; 173, 187; 174, block; 174, 175; 175, assert_statement; 175, 176; 175, 181; 176, comparison_operator:is; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:target_ch; 179, identifier:parent; 180, identifier:new_target; 181, tuple; 181, 182; 181, 183; 181, 186; 182, identifier:target_ch; 183, attribute; 183, 184; 183, 185; 184, identifier:target_ch; 185, identifier:parent; 186, identifier:new_target; 187, except_clause; 187, 188; 187, 189; 188, identifier:AssertionError; 189, block; 189, 190; 189, 208; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 193; 192, identifier:print; 193, argument_list; 193, 194; 193, 195; 193, 198; 193, 199; 193, 202; 193, 203; 193, 206; 193, 207; 194, string:'Wrong target:\n'; 195, attribute; 195, 196; 195, 197; 196, identifier:edge; 197, identifier:src; 198, string:"\n"; 199, attribute; 199, 200; 199, 201; 200, identifier:edge; 201, identifier:dst; 202, string:"\n"; 203, attribute; 203, 204; 203, 205; 204, identifier:target_ch; 205, identifier:parent; 206, string:"\n"; 207, identifier:new_target; 208, raise_statement; 209, if_statement; 209, 210; 209, 217; 209, 225; 210, comparison_operator:==; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:child; 213, identifier:direction; 214, attribute; 214, 215; 214, 216; 215, identifier:PortType; 216, identifier:OUTPUT; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:edge; 222, identifier:removeTarget; 223, argument_list; 223, 224; 224, identifier:target_ch; 225, elif_clause; 225, 226; 225, 233; 226, comparison_operator:==; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:child; 229, identifier:direction; 230, attribute; 230, 231; 230, 232; 231, identifier:PortType; 232, identifier:INPUT; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:edge; 238, identifier:removeTarget; 239, argument_list; 239, 240; 240, identifier:child; 241, if_statement; 241, 242; 241, 251; 242, boolean_operator:or; 242, 243; 242, 247; 243, not_operator; 243, 244; 244, attribute; 244, 245; 244, 246; 245, identifier:edge; 246, identifier:srcs; 247, not_operator; 247, 248; 248, attribute; 248, 249; 248, 250; 249, identifier:edge; 250, identifier:dsts; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:edge; 256, identifier:remove; 257, argument_list; 258, if_statement; 258, 259; 258, 268; 259, boolean_operator:and; 259, 260; 259, 264; 260, not_operator; 260, 261; 261, attribute; 261, 262; 261, 263; 262, identifier:target_ch; 263, identifier:incomingEdges; 264, not_operator; 264, 265; 265, attribute; 265, 266; 265, 267; 266, identifier:target_ch; 267, identifier:outgoingEdges; 268, block; 268, 269; 269, expression_statement; 269, 270; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:on_target_children_to_destroy; 273, identifier:add; 274, argument_list; 274, 275; 275, identifier:target_ch; 276, if_statement; 276, 277; 276, 286; 277, boolean_operator:and; 277, 278; 277, 282; 278, not_operator; 278, 279; 279, attribute; 279, 280; 279, 281; 280, identifier:child; 281, identifier:incomingEdges; 282, not_operator; 282, 283; 283, attribute; 283, 284; 283, 285; 284, identifier:child; 285, identifier:outgoingEdges; 286, block; 286, 287; 287, expression_statement; 287, 288; 288, call; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:children_to_destroy; 291, identifier:add; 292, argument_list; 292, 293; 293, identifier:child; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:port; 298, identifier:children; 299, list_comprehension; 299, 300; 299, 301; 299, 306; 300, identifier:ch; 301, for_in_clause; 301, 302; 301, 303; 302, identifier:ch; 303, attribute; 303, 304; 303, 305; 304, identifier:port; 305, identifier:children; 306, if_clause; 306, 307; 307, comparison_operator:not; 307, 308; 307, 309; 308, identifier:ch; 309, identifier:children_to_destroy; 310, expression_statement; 310, 311; 311, assignment; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:new_target; 314, identifier:children; 315, list_comprehension; 315, 316; 315, 317; 315, 322; 316, identifier:ch; 317, for_in_clause; 317, 318; 317, 319; 318, identifier:ch; 319, attribute; 319, 320; 319, 321; 320, identifier:new_target; 321, identifier:children; 322, if_clause; 322, 323; 323, comparison_operator:not; 323, 324; 323, 325; 324, identifier:ch; 325, identifier:on_target_children_to_destroy; 326, if_statement; 326, 327; 326, 334; 326, 343; 326, 360; 327, comparison_operator:==; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:port; 330, identifier:direction; 331, attribute; 331, 332; 331, 333; 332, identifier:PortType; 333, identifier:OUTPUT; 334, block; 334, 335; 335, expression_statement; 335, 336; 336, call; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:root; 339, identifier:addEdge; 340, argument_list; 340, 341; 340, 342; 341, identifier:port; 342, identifier:new_target; 343, elif_clause; 343, 344; 343, 351; 344, comparison_operator:==; 344, 345; 344, 348; 345, attribute; 345, 346; 345, 347; 346, identifier:port; 347, identifier:direction; 348, attribute; 348, 349; 348, 350; 349, identifier:PortType; 350, identifier:INPUT; 351, block; 351, 352; 352, expression_statement; 352, 353; 353, call; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:root; 356, identifier:addEdge; 357, argument_list; 357, 358; 357, 359; 358, identifier:new_target; 359, identifier:port; 360, else_clause; 360, 361; 361, block; 361, 362; 362, raise_statement; 362, 363; 363, call; 363, 364; 363, 365; 364, identifier:NotImplementedError; 365, argument_list; 365, 366; 366, attribute; 366, 367; 366, 368; 367, identifier:port; 368, identifier:direction | def portTryReduce(root: LNode, port: LPort):
if not port.children:
return
for p in port.children:
portTryReduce(root, p)
target_nodes = {}
ch_cnt = countDirectlyConnected(port, target_nodes)
if not target_nodes:
return
new_target, children_edge_to_destroy = max(target_nodes.items(),
key=lambda x: len(x[1]))
cnt = len(children_edge_to_destroy)
if cnt < ch_cnt / 2 or cnt == 1 and ch_cnt == 2:
return
children_to_destroy = set()
on_target_children_to_destroy = set()
for child, edge in children_edge_to_destroy:
if child.direction == PortType.OUTPUT:
target_ch = edge.dsts
elif child.direction == PortType.INPUT:
target_ch = edge.srcs
else:
raise ValueError(child.direction)
if len(target_ch) != 1:
raise NotImplementedError("multiple connected nodes", target_ch)
target_ch = target_ch[0]
try:
assert target_ch.parent is new_target, (
target_ch,
target_ch.parent,
new_target)
except AssertionError:
print('Wrong target:\n', edge.src, "\n", edge.dst,
"\n", target_ch.parent, "\n", new_target)
raise
if child.direction == PortType.OUTPUT:
edge.removeTarget(target_ch)
elif child.direction == PortType.INPUT:
edge.removeTarget(child)
if not edge.srcs or not edge.dsts:
edge.remove()
if not target_ch.incomingEdges and not target_ch.outgoingEdges:
on_target_children_to_destroy.add(target_ch)
if not child.incomingEdges and not child.outgoingEdges:
children_to_destroy.add(child)
port.children = [
ch for ch in port.children if ch not in children_to_destroy]
new_target.children = [
ch for ch in new_target.children if ch not in on_target_children_to_destroy]
if port.direction == PortType.OUTPUT:
root.addEdge(port, new_target)
elif port.direction == PortType.INPUT:
root.addEdge(new_target, port)
else:
raise NotImplementedError(port.direction) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 1, 14; 2, function_name:countDirectlyConnected; 3, parameters; 3, 4; 3, 8; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:port; 6, type; 6, 7; 7, identifier:LPort; 8, typed_parameter; 8, 9; 8, 10; 9, identifier:result; 10, type; 10, 11; 11, identifier:dict; 12, type; 12, 13; 13, identifier:int; 14, block; 14, 15; 14, 21; 14, 27; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:inEdges; 18, attribute; 18, 19; 18, 20; 19, identifier:port; 20, identifier:incomingEdges; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:outEdges; 24, attribute; 24, 25; 24, 26; 25, identifier:port; 26, identifier:outgoingEdges; 27, if_statement; 27, 28; 27, 31; 27, 52; 27, 98; 28, attribute; 28, 29; 28, 30; 29, identifier:port; 30, identifier:children; 31, block; 31, 32; 31, 36; 31, 50; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:ch_cnt; 35, integer:0; 36, for_statement; 36, 37; 36, 38; 36, 41; 37, identifier:ch; 38, attribute; 38, 39; 38, 40; 39, identifier:port; 40, identifier:children; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, augmented_assignment:+=; 43, 44; 43, 45; 44, identifier:ch_cnt; 45, call; 45, 46; 45, 47; 46, identifier:countDirectlyConnected; 47, argument_list; 47, 48; 47, 49; 48, identifier:ch; 49, identifier:result; 50, return_statement; 50, 51; 51, identifier:ch_cnt; 52, elif_clause; 52, 53; 52, 58; 53, boolean_operator:and; 53, 54; 53, 56; 54, not_operator; 54, 55; 55, identifier:inEdges; 56, not_operator; 56, 57; 57, identifier:outEdges; 58, block; 58, 59; 58, 96; 59, if_statement; 59, 60; 59, 67; 60, comparison_operator:==; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:port; 63, identifier:direction; 64, attribute; 64, 65; 64, 66; 65, identifier:PortType; 66, identifier:INPUT; 67, block; 67, 68; 68, if_statement; 68, 69; 68, 74; 68, 87; 69, comparison_operator:is; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:port; 72, identifier:originObj; 73, None; 74, block; 74, 75; 75, assert_statement; 75, 76; 75, 84; 76, not_operator; 76, 77; 77, attribute; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:port; 81, identifier:originObj; 82, identifier:src; 83, identifier:drivers; 84, attribute; 84, 85; 84, 86; 85, identifier:port; 86, identifier:originObj; 87, else_clause; 87, 88; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 92; 91, identifier:print; 92, argument_list; 92, 93; 92, 94; 92, 95; 93, string:"Warning"; 94, identifier:port; 95, string:"not connected"; 96, return_statement; 96, 97; 97, integer:0; 98, else_clause; 98, 99; 99, block; 99, 100; 99, 104; 99, 124; 99, 144; 99, 151; 99, 168; 99, 187; 99, 218; 99, 251; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:connectedElemCnt; 103, integer:0; 104, for_statement; 104, 105; 104, 106; 104, 107; 105, identifier:e; 106, identifier:inEdges; 107, block; 107, 108; 107, 117; 108, expression_statement; 108, 109; 109, augmented_assignment:+=; 109, 110; 109, 111; 110, identifier:connectedElemCnt; 111, call; 111, 112; 111, 113; 112, identifier:len; 113, argument_list; 113, 114; 114, attribute; 114, 115; 114, 116; 115, identifier:e; 116, identifier:srcs; 117, if_statement; 117, 118; 117, 121; 118, comparison_operator:>; 118, 119; 118, 120; 119, identifier:connectedElemCnt; 120, integer:1; 121, block; 121, 122; 122, return_statement; 122, 123; 123, integer:0; 124, for_statement; 124, 125; 124, 126; 124, 127; 125, identifier:e; 126, identifier:outEdges; 127, block; 127, 128; 127, 137; 128, expression_statement; 128, 129; 129, augmented_assignment:+=; 129, 130; 129, 131; 130, identifier:connectedElemCnt; 131, call; 131, 132; 131, 133; 132, identifier:len; 133, argument_list; 133, 134; 134, attribute; 134, 135; 134, 136; 135, identifier:e; 136, identifier:dsts; 137, if_statement; 137, 138; 137, 141; 138, comparison_operator:>; 138, 139; 138, 140; 139, identifier:connectedElemCnt; 140, integer:1; 141, block; 141, 142; 142, return_statement; 142, 143; 143, integer:0; 144, if_statement; 144, 145; 144, 148; 145, comparison_operator:!=; 145, 146; 145, 147; 146, identifier:connectedElemCnt; 147, integer:1; 148, block; 148, 149; 149, return_statement; 149, 150; 150, integer:0; 151, if_statement; 151, 152; 151, 153; 151, 160; 152, identifier:inEdges; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:e; 157, subscript; 157, 158; 157, 159; 158, identifier:inEdges; 159, integer:0; 160, else_clause; 160, 161; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:e; 165, subscript; 165, 166; 165, 167; 166, identifier:outEdges; 167, integer:0; 168, if_statement; 168, 169; 168, 184; 169, comparison_operator:!=; 169, 170; 169, 177; 170, attribute; 170, 171; 170, 176; 171, subscript; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:e; 174, identifier:srcs; 175, integer:0; 176, identifier:name; 177, attribute; 177, 178; 177, 183; 178, subscript; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:e; 181, identifier:dsts; 182, integer:0; 183, identifier:name; 184, block; 184, 185; 185, return_statement; 185, 186; 186, integer:0; 187, if_statement; 187, 188; 187, 195; 187, 206; 188, comparison_operator:is; 188, 189; 188, 194; 189, subscript; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:e; 192, identifier:srcs; 193, integer:0; 194, identifier:port; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:p; 199, attribute; 199, 200; 199, 205; 200, subscript; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:e; 203, identifier:dsts; 204, integer:0; 205, identifier:parent; 206, else_clause; 206, 207; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:p; 211, attribute; 211, 212; 211, 217; 212, subscript; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:e; 215, identifier:srcs; 216, integer:0; 217, identifier:parent; 218, if_statement; 218, 219; 218, 225; 219, not_operator; 219, 220; 220, call; 220, 221; 220, 222; 221, identifier:isinstance; 222, argument_list; 222, 223; 222, 224; 223, identifier:p; 224, identifier:LNode; 225, block; 225, 226; 225, 236; 225, 245; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:connections; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:result; 232, identifier:get; 233, argument_list; 233, 234; 233, 235; 234, identifier:p; 235, list:[]; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:connections; 240, identifier:append; 241, argument_list; 241, 242; 242, tuple; 242, 243; 242, 244; 243, identifier:port; 244, identifier:e; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 250; 247, subscript; 247, 248; 247, 249; 248, identifier:result; 249, identifier:p; 250, identifier:connections; 251, return_statement; 251, 252; 252, integer:1 | def countDirectlyConnected(port: LPort, result: dict) -> int:
inEdges = port.incomingEdges
outEdges = port.outgoingEdges
if port.children:
ch_cnt = 0
for ch in port.children:
ch_cnt += countDirectlyConnected(ch, result)
return ch_cnt
elif not inEdges and not outEdges:
if port.direction == PortType.INPUT:
if port.originObj is not None:
assert not port.originObj.src.drivers, port.originObj
else:
print("Warning", port, "not connected")
return 0
else:
connectedElemCnt = 0
for e in inEdges:
connectedElemCnt += len(e.srcs)
if connectedElemCnt > 1:
return 0
for e in outEdges:
connectedElemCnt += len(e.dsts)
if connectedElemCnt > 1:
return 0
if connectedElemCnt != 1:
return 0
if inEdges:
e = inEdges[0]
else:
e = outEdges[0]
if e.srcs[0].name != e.dsts[0].name:
return 0
if e.srcs[0] is port:
p = e.dsts[0].parent
else:
p = e.srcs[0].parent
if not isinstance(p, LNode):
connections = result.get(p, [])
connections.append((port, e))
result[p] = connections
return 1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:untlxml2py; 3, parameters; 3, 4; 4, identifier:untl_filename; 5, block; 5, 6; 5, 10; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:parent_stack; 9, list:[]; 10, for_statement; 10, 11; 10, 14; 10, 23; 11, pattern_list; 11, 12; 11, 13; 12, identifier:event; 13, identifier:element; 14, call; 14, 15; 14, 16; 15, identifier:iterparse; 16, argument_list; 16, 17; 16, 18; 17, identifier:untl_filename; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:events; 20, tuple; 20, 21; 20, 22; 21, string:'start'; 22, string:'end'; 23, block; 23, 24; 23, 60; 24, if_statement; 24, 25; 24, 34; 24, 52; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:NAMESPACE_REGEX; 28, identifier:search; 29, argument_list; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:element; 32, identifier:tag; 33, integer:0; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:element_tag; 38, call; 38, 39; 38, 50; 39, attribute; 39, 40; 39, 49; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:NAMESPACE_REGEX; 43, identifier:search; 44, argument_list; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:element; 47, identifier:tag; 48, integer:0; 49, identifier:group; 50, argument_list; 50, 51; 51, integer:1; 52, else_clause; 52, 53; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:element_tag; 57, attribute; 57, 58; 57, 59; 58, identifier:element; 59, identifier:tag; 60, if_statement; 60, 61; 60, 64; 60, 168; 61, comparison_operator:in; 61, 62; 61, 63; 62, identifier:element_tag; 63, identifier:PYUNTL_DISPATCH; 64, block; 64, 65; 65, if_statement; 65, 66; 65, 69; 65, 81; 66, comparison_operator:==; 66, 67; 66, 68; 67, identifier:event; 68, string:'start'; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:parent_stack; 74, identifier:append; 75, argument_list; 75, 76; 76, call; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:PYUNTL_DISPATCH; 79, identifier:element_tag; 80, argument_list; 81, elif_clause; 81, 82; 81, 85; 82, comparison_operator:==; 82, 83; 82, 84; 83, identifier:event; 84, string:'end'; 85, block; 85, 86; 85, 94; 85, 125; 85, 146; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:child; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:parent_stack; 92, identifier:pop; 93, argument_list; 94, if_statement; 94, 95; 94, 100; 95, comparison_operator:is; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:element; 98, identifier:text; 99, None; 100, block; 100, 101; 100, 111; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:content; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:element; 108, identifier:text; 109, identifier:strip; 110, argument_list; 111, if_statement; 111, 112; 111, 115; 112, comparison_operator:!=; 112, 113; 112, 114; 113, identifier:content; 114, string:''; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:child; 120, identifier:set_content; 121, argument_list; 121, 122; 122, attribute; 122, 123; 122, 124; 123, identifier:element; 124, identifier:text; 125, if_statement; 125, 126; 125, 133; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:element; 129, identifier:get; 130, argument_list; 130, 131; 130, 132; 131, string:'qualifier'; 132, False; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:child; 138, identifier:set_qualifier; 139, argument_list; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:element; 143, identifier:get; 144, argument_list; 144, 145; 145, string:'qualifier'; 146, if_statement; 146, 147; 146, 153; 146, 164; 147, comparison_operator:>; 147, 148; 147, 152; 148, call; 148, 149; 148, 150; 149, identifier:len; 150, argument_list; 150, 151; 151, identifier:parent_stack; 152, integer:0; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, call; 155, 156; 155, 162; 156, attribute; 156, 157; 156, 161; 157, subscript; 157, 158; 157, 159; 158, identifier:parent_stack; 159, unary_operator:-; 159, 160; 160, integer:1; 161, identifier:add_child; 162, argument_list; 162, 163; 163, identifier:child; 164, else_clause; 164, 165; 165, block; 165, 166; 166, return_statement; 166, 167; 167, identifier:child; 168, else_clause; 168, 169; 169, block; 169, 170; 170, raise_statement; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:PyuntlException; 173, argument_list; 173, 174; 174, binary_operator:%; 174, 175; 174, 176; 175, string:'Element "%s" not in UNTL dispatch.'; 176, parenthesized_expression; 176, 177; 177, identifier:element_tag | def untlxml2py(untl_filename):
parent_stack = []
for event, element in iterparse(untl_filename, events=('start', 'end')):
if NAMESPACE_REGEX.search(element.tag, 0):
element_tag = NAMESPACE_REGEX.search(element.tag, 0).group(1)
else:
element_tag = element.tag
if element_tag in PYUNTL_DISPATCH:
if event == 'start':
parent_stack.append(PYUNTL_DISPATCH[element_tag]())
elif event == 'end':
child = parent_stack.pop()
if element.text is not None:
content = element.text.strip()
if content != '':
child.set_content(element.text)
if element.get('qualifier', False):
child.set_qualifier(element.get('qualifier'))
if len(parent_stack) > 0:
parent_stack[-1].add_child(child)
else:
return child
else:
raise PyuntlException(
'Element "%s" not in UNTL dispatch.' % (element_tag)
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:post2pydict; 3, parameters; 3, 4; 3, 5; 4, identifier:post; 5, identifier:ignore_list; 6, block; 6, 7; 6, 15; 6, 19; 6, 30; 6, 77; 6, 377; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:root_element; 10, call; 10, 11; 10, 14; 11, subscript; 11, 12; 11, 13; 12, identifier:PYUNTL_DISPATCH; 13, string:'metadata'; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:untl_form_dict; 18, dictionary; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:form_post; 22, call; 22, 23; 22, 24; 23, identifier:dict; 24, argument_list; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:post; 28, identifier:copy; 29, argument_list; 30, for_statement; 30, 31; 30, 34; 30, 39; 31, pattern_list; 31, 32; 31, 33; 32, identifier:key; 33, identifier:value_list; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:form_post; 37, identifier:items; 38, argument_list; 39, block; 39, 40; 40, if_statement; 40, 41; 40, 44; 41, comparison_operator:not; 41, 42; 41, 43; 42, identifier:key; 43, identifier:ignore_list; 44, block; 44, 45; 44, 57; 44, 68; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, tuple_pattern; 47, 48; 47, 49; 48, identifier:element_tag; 49, identifier:element_attribute; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:key; 53, identifier:split; 54, argument_list; 54, 55; 54, 56; 55, string:'-'; 56, integer:1; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:not; 58, 59; 58, 60; 59, identifier:element_tag; 60, identifier:untl_form_dict; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:untl_form_dict; 66, identifier:element_tag; 67, tuple; 68, expression_statement; 68, 69; 69, augmented_assignment:+=; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:untl_form_dict; 72, identifier:element_tag; 73, expression_list; 73, 74; 74, tuple; 74, 75; 74, 76; 75, identifier:element_attribute; 76, identifier:value_list; 77, for_statement; 77, 78; 77, 81; 77, 86; 78, pattern_list; 78, 79; 78, 80; 79, identifier:element_tag; 80, identifier:attribute_tuple; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:untl_form_dict; 84, identifier:items; 85, argument_list; 86, block; 86, 87; 86, 94; 86, 105; 86, 136; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:attribute_count; 90, call; 90, 91; 90, 92; 91, identifier:len; 92, argument_list; 92, 93; 93, identifier:attribute_tuple; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:value_count; 97, call; 97, 98; 97, 99; 98, identifier:len; 99, argument_list; 99, 100; 100, subscript; 100, 101; 100, 104; 101, subscript; 101, 102; 101, 103; 102, identifier:attribute_tuple; 103, integer:0; 104, integer:1; 105, for_statement; 105, 106; 105, 107; 105, 112; 106, identifier:i; 107, call; 107, 108; 107, 109; 108, identifier:range; 109, argument_list; 109, 110; 109, 111; 110, integer:0; 111, identifier:attribute_count; 112, block; 112, 113; 113, if_statement; 113, 114; 113, 125; 114, not_operator; 114, 115; 115, comparison_operator:==; 115, 116; 115, 124; 116, call; 116, 117; 116, 118; 117, identifier:len; 118, argument_list; 118, 119; 119, subscript; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:attribute_tuple; 122, identifier:i; 123, integer:1; 124, identifier:value_count; 125, block; 125, 126; 126, raise_statement; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:PyuntlException; 129, argument_list; 129, 130; 130, binary_operator:%; 130, 131; 130, 134; 131, concatenated_string; 131, 132; 131, 133; 132, string:'Field values did not match up '; 133, string:'numerically for %s'; 134, parenthesized_expression; 134, 135; 135, identifier:element_tag; 136, for_statement; 136, 137; 136, 138; 136, 143; 137, identifier:i; 138, call; 138, 139; 138, 140; 139, identifier:range; 140, argument_list; 140, 141; 140, 142; 141, integer:0; 142, identifier:value_count; 143, block; 143, 144; 143, 148; 143, 152; 143, 156; 143, 160; 143, 271; 143, 342; 143, 365; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:untl_element; 147, None; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:content; 151, string:''; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:qualifier; 155, string:''; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:child_list; 159, list:[]; 160, for_statement; 160, 161; 160, 162; 160, 167; 161, identifier:j; 162, call; 162, 163; 162, 164; 163, identifier:range; 164, argument_list; 164, 165; 164, 166; 165, integer:0; 166, identifier:attribute_count; 167, block; 167, 168; 168, if_statement; 168, 169; 168, 176; 168, 190; 168, 209; 169, comparison_operator:==; 169, 170; 169, 175; 170, subscript; 170, 171; 170, 174; 171, subscript; 171, 172; 171, 173; 172, identifier:attribute_tuple; 173, identifier:j; 174, integer:0; 175, string:'content'; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:content; 180, call; 180, 181; 180, 182; 181, identifier:unicode; 182, argument_list; 182, 183; 183, subscript; 183, 184; 183, 189; 184, subscript; 184, 185; 184, 188; 185, subscript; 185, 186; 185, 187; 186, identifier:attribute_tuple; 187, identifier:j; 188, integer:1; 189, identifier:i; 190, elif_clause; 190, 191; 190, 198; 191, comparison_operator:==; 191, 192; 191, 197; 192, subscript; 192, 193; 192, 196; 193, subscript; 193, 194; 193, 195; 194, identifier:attribute_tuple; 195, identifier:j; 196, integer:0; 197, string:'qualifier'; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:qualifier; 202, subscript; 202, 203; 202, 208; 203, subscript; 203, 204; 203, 207; 204, subscript; 204, 205; 204, 206; 205, identifier:attribute_tuple; 206, identifier:j; 207, integer:1; 208, identifier:i; 209, else_clause; 209, 210; 210, block; 210, 211; 211, if_statement; 211, 212; 211, 221; 212, comparison_operator:!=; 212, 213; 212, 220; 213, subscript; 213, 214; 213, 219; 214, subscript; 214, 215; 214, 218; 215, subscript; 215, 216; 215, 217; 216, identifier:attribute_tuple; 217, identifier:j; 218, integer:1; 219, identifier:i; 220, string:''; 221, block; 221, 222; 221, 230; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:child_tag; 225, subscript; 225, 226; 225, 229; 226, subscript; 226, 227; 226, 228; 227, identifier:attribute_tuple; 228, identifier:j; 229, integer:0; 230, if_statement; 230, 231; 230, 234; 230, 245; 231, comparison_operator:in; 231, 232; 231, 233; 232, identifier:child_tag; 233, identifier:PARENT_FORM; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:qualifier; 238, subscript; 238, 239; 238, 244; 239, subscript; 239, 240; 239, 243; 240, subscript; 240, 241; 240, 242; 241, identifier:attribute_tuple; 242, identifier:j; 243, integer:1; 244, identifier:i; 245, else_clause; 245, 246; 246, block; 246, 247; 247, expression_statement; 247, 248; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:child_list; 251, identifier:append; 252, argument_list; 252, 253; 253, call; 253, 254; 253, 261; 254, subscript; 254, 255; 254, 256; 255, identifier:PYUNTL_DISPATCH; 256, subscript; 256, 257; 256, 260; 257, subscript; 257, 258; 257, 259; 258, identifier:attribute_tuple; 259, identifier:j; 260, integer:0; 261, argument_list; 261, 262; 262, keyword_argument; 262, 263; 262, 264; 263, identifier:content; 264, subscript; 264, 265; 264, 270; 265, subscript; 265, 266; 265, 269; 266, subscript; 266, 267; 266, 268; 267, identifier:attribute_tuple; 268, identifier:j; 269, integer:1; 270, identifier:i; 271, if_statement; 271, 272; 271, 279; 271, 294; 271, 310; 271, 326; 272, boolean_operator:and; 272, 273; 272, 276; 273, comparison_operator:!=; 273, 274; 273, 275; 274, identifier:content; 275, string:''; 276, comparison_operator:!=; 276, 277; 276, 278; 277, identifier:qualifier; 278, string:''; 279, block; 279, 280; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 283; 282, identifier:untl_element; 283, call; 283, 284; 283, 287; 284, subscript; 284, 285; 284, 286; 285, identifier:PYUNTL_DISPATCH; 286, identifier:element_tag; 287, argument_list; 287, 288; 287, 291; 288, keyword_argument; 288, 289; 288, 290; 289, identifier:content; 290, identifier:content; 291, keyword_argument; 291, 292; 291, 293; 292, identifier:qualifier; 293, identifier:qualifier; 294, elif_clause; 294, 295; 294, 298; 295, comparison_operator:!=; 295, 296; 295, 297; 296, identifier:content; 297, string:''; 298, block; 298, 299; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:untl_element; 302, call; 302, 303; 302, 306; 303, subscript; 303, 304; 303, 305; 304, identifier:PYUNTL_DISPATCH; 305, identifier:element_tag; 306, argument_list; 306, 307; 307, keyword_argument; 307, 308; 307, 309; 308, identifier:content; 309, identifier:content; 310, elif_clause; 310, 311; 310, 314; 311, comparison_operator:!=; 311, 312; 311, 313; 312, identifier:qualifier; 313, string:''; 314, block; 314, 315; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 318; 317, identifier:untl_element; 318, call; 318, 319; 318, 322; 319, subscript; 319, 320; 319, 321; 320, identifier:PYUNTL_DISPATCH; 321, identifier:element_tag; 322, argument_list; 322, 323; 323, keyword_argument; 323, 324; 323, 325; 324, identifier:qualifier; 325, identifier:qualifier; 326, elif_clause; 326, 327; 326, 333; 327, comparison_operator:>; 327, 328; 327, 332; 328, call; 328, 329; 328, 330; 329, identifier:len; 330, argument_list; 330, 331; 331, identifier:child_list; 332, integer:0; 333, block; 333, 334; 334, expression_statement; 334, 335; 335, assignment; 335, 336; 335, 337; 336, identifier:untl_element; 337, call; 337, 338; 337, 341; 338, subscript; 338, 339; 338, 340; 339, identifier:PYUNTL_DISPATCH; 340, identifier:element_tag; 341, argument_list; 342, if_statement; 342, 343; 342, 353; 343, boolean_operator:and; 343, 344; 343, 350; 344, comparison_operator:>; 344, 345; 344, 349; 345, call; 345, 346; 345, 347; 346, identifier:len; 347, argument_list; 347, 348; 348, identifier:child_list; 349, integer:0; 350, comparison_operator:is; 350, 351; 350, 352; 351, identifier:untl_element; 352, None; 353, block; 353, 354; 354, for_statement; 354, 355; 354, 356; 354, 357; 355, identifier:child; 356, identifier:child_list; 357, block; 357, 358; 358, expression_statement; 358, 359; 359, call; 359, 360; 359, 363; 360, attribute; 360, 361; 360, 362; 361, identifier:untl_element; 362, identifier:add_child; 363, argument_list; 363, 364; 364, identifier:child; 365, if_statement; 365, 366; 365, 369; 366, comparison_operator:is; 366, 367; 366, 368; 367, identifier:untl_element; 368, None; 369, block; 369, 370; 370, expression_statement; 370, 371; 371, call; 371, 372; 371, 375; 372, attribute; 372, 373; 372, 374; 373, identifier:root_element; 374, identifier:add_child; 375, argument_list; 375, 376; 376, identifier:untl_element; 377, return_statement; 377, 378; 378, call; 378, 379; 378, 382; 379, attribute; 379, 380; 379, 381; 380, identifier:root_element; 381, identifier:create_element_dict; 382, argument_list | def post2pydict(post, ignore_list):
root_element = PYUNTL_DISPATCH['metadata']()
untl_form_dict = {}
form_post = dict(post.copy())
for key, value_list in form_post.items():
if key not in ignore_list:
(element_tag, element_attribute) = key.split('-', 1)
if element_tag not in untl_form_dict:
untl_form_dict[element_tag] = ()
untl_form_dict[element_tag] += (element_attribute, value_list),
for element_tag, attribute_tuple in untl_form_dict.items():
attribute_count = len(attribute_tuple)
value_count = len(attribute_tuple[0][1])
for i in range(0, attribute_count):
if not len(attribute_tuple[i][1]) == value_count:
raise PyuntlException('Field values did not match up '
'numerically for %s' % (element_tag))
for i in range(0, value_count):
untl_element = None
content = ''
qualifier = ''
child_list = []
for j in range(0, attribute_count):
if attribute_tuple[j][0] == 'content':
content = unicode(attribute_tuple[j][1][i])
elif attribute_tuple[j][0] == 'qualifier':
qualifier = attribute_tuple[j][1][i]
else:
if attribute_tuple[j][1][i] != '':
child_tag = attribute_tuple[j][0]
if child_tag in PARENT_FORM:
qualifier = attribute_tuple[j][1][i]
else:
child_list.append(
PYUNTL_DISPATCH[attribute_tuple[j][0]](
content=attribute_tuple[j][1][i]
)
)
if content != '' and qualifier != '':
untl_element = PYUNTL_DISPATCH[element_tag](content=content,
qualifier=qualifier)
elif content != '':
untl_element = PYUNTL_DISPATCH[element_tag](content=content)
elif qualifier != '':
untl_element = PYUNTL_DISPATCH[element_tag](qualifier=qualifier)
elif len(child_list) > 0:
untl_element = PYUNTL_DISPATCH[element_tag]()
if len(child_list) > 0 and untl_element is not None:
for child in child_list:
untl_element.add_child(child)
if untl_element is not None:
root_element.add_child(untl_element)
return root_element.create_element_dict() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:untlpy2dcpy; 3, parameters; 3, 4; 3, 5; 4, identifier:untl_elements; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 12; 7, 16; 7, 26; 7, 36; 7, 46; 7, 56; 7, 66; 7, 76; 7, 102; 7, 110; 7, 236; 7, 289; 7, 340; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:sDate; 11, None; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:eDate; 15, None; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:ark; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:kwargs; 22, identifier:get; 23, argument_list; 23, 24; 23, 25; 24, string:'ark'; 25, None; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:domain_name; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:kwargs; 32, identifier:get; 33, argument_list; 33, 34; 33, 35; 34, string:'domain_name'; 35, None; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:scheme; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:kwargs; 42, identifier:get; 43, argument_list; 43, 44; 43, 45; 44, string:'scheme'; 45, string:'http'; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:resolve_values; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:kwargs; 52, identifier:get; 53, argument_list; 53, 54; 53, 55; 54, string:'resolve_values'; 55, None; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:resolve_urls; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:kwargs; 62, identifier:get; 63, argument_list; 63, 64; 63, 65; 64, string:'resolve_urls'; 65, None; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:verbose_vocabularies; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:kwargs; 72, identifier:get; 73, argument_list; 73, 74; 73, 75; 74, string:'verbose_vocabularies'; 75, None; 76, if_statement; 76, 77; 76, 80; 76, 96; 77, boolean_operator:or; 77, 78; 77, 79; 78, identifier:resolve_values; 79, identifier:resolve_urls; 80, block; 80, 81; 81, if_statement; 81, 82; 81, 83; 81, 88; 82, identifier:verbose_vocabularies; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:vocab_data; 87, identifier:verbose_vocabularies; 88, else_clause; 88, 89; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:vocab_data; 93, call; 93, 94; 93, 95; 94, identifier:retrieve_vocab; 95, argument_list; 96, else_clause; 96, 97; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:vocab_data; 101, None; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:dc_root; 105, call; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:DC_CONVERSION_DISPATCH; 108, string:'dc'; 109, argument_list; 110, for_statement; 110, 111; 110, 112; 110, 115; 111, identifier:element; 112, attribute; 112, 113; 112, 114; 113, identifier:untl_elements; 114, identifier:children; 115, block; 115, 116; 116, if_statement; 116, 117; 116, 122; 117, comparison_operator:in; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:element; 120, identifier:tag; 121, identifier:DC_CONVERSION_DISPATCH; 122, block; 122, 123; 122, 188; 123, if_statement; 123, 124; 123, 127; 123, 157; 124, attribute; 124, 125; 124, 126; 125, identifier:element; 126, identifier:children; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:dc_element; 131, call; 131, 132; 131, 137; 132, subscript; 132, 133; 132, 134; 133, identifier:DC_CONVERSION_DISPATCH; 134, attribute; 134, 135; 134, 136; 135, identifier:element; 136, identifier:tag; 137, argument_list; 137, 138; 137, 143; 137, 148; 137, 151; 137, 154; 138, keyword_argument; 138, 139; 138, 140; 139, identifier:qualifier; 140, attribute; 140, 141; 140, 142; 141, identifier:element; 142, identifier:qualifier; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:children; 145, attribute; 145, 146; 145, 147; 146, identifier:element; 147, identifier:children; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:resolve_values; 150, identifier:resolve_values; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:resolve_urls; 153, identifier:resolve_urls; 154, keyword_argument; 154, 155; 154, 156; 155, identifier:vocab_data; 156, identifier:vocab_data; 157, else_clause; 157, 158; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:dc_element; 162, call; 162, 163; 162, 168; 163, subscript; 163, 164; 163, 165; 164, identifier:DC_CONVERSION_DISPATCH; 165, attribute; 165, 166; 165, 167; 166, identifier:element; 167, identifier:tag; 168, argument_list; 168, 169; 168, 174; 168, 179; 168, 182; 168, 185; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:qualifier; 171, attribute; 171, 172; 171, 173; 172, identifier:element; 173, identifier:qualifier; 174, keyword_argument; 174, 175; 174, 176; 175, identifier:content; 176, attribute; 176, 177; 176, 178; 177, identifier:element; 178, identifier:content; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:resolve_values; 181, identifier:resolve_values; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:resolve_urls; 184, identifier:resolve_urls; 185, keyword_argument; 185, 186; 185, 187; 186, identifier:vocab_data; 187, identifier:vocab_data; 188, if_statement; 188, 189; 188, 194; 188, 226; 189, comparison_operator:==; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:element; 192, identifier:tag; 193, string:'coverage'; 194, block; 194, 195; 195, if_statement; 195, 196; 195, 201; 195, 206; 195, 217; 196, comparison_operator:==; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:element; 199, identifier:qualifier; 200, string:'sDate'; 201, block; 201, 202; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:sDate; 205, identifier:dc_element; 206, elif_clause; 206, 207; 206, 212; 207, comparison_operator:==; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:element; 210, identifier:qualifier; 211, string:'eDate'; 212, block; 212, 213; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:eDate; 216, identifier:dc_element; 217, else_clause; 217, 218; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:dc_root; 223, identifier:add_child; 224, argument_list; 224, 225; 225, identifier:dc_element; 226, elif_clause; 226, 227; 226, 228; 227, identifier:dc_element; 228, block; 228, 229; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:dc_root; 233, identifier:add_child; 234, argument_list; 234, 235; 235, identifier:dc_element; 236, if_statement; 236, 237; 236, 240; 237, boolean_operator:and; 237, 238; 237, 239; 238, identifier:ark; 239, identifier:domain_name; 240, block; 240, 241; 240, 261; 240, 268; 240, 282; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:permalink_identifier; 244, call; 244, 245; 244, 248; 245, subscript; 245, 246; 245, 247; 246, identifier:DC_CONVERSION_DISPATCH; 247, string:'identifier'; 248, argument_list; 248, 249; 248, 252; 248, 255; 248, 258; 249, keyword_argument; 249, 250; 249, 251; 250, identifier:qualifier; 251, string:'permalink'; 252, keyword_argument; 252, 253; 252, 254; 253, identifier:domain_name; 254, identifier:domain_name; 255, keyword_argument; 255, 256; 255, 257; 256, identifier:ark; 257, identifier:ark; 258, keyword_argument; 258, 259; 258, 260; 259, identifier:scheme; 260, identifier:scheme; 261, expression_statement; 261, 262; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:dc_root; 265, identifier:add_child; 266, argument_list; 266, 267; 267, identifier:permalink_identifier; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:ark_identifier; 271, call; 271, 272; 271, 275; 272, subscript; 272, 273; 272, 274; 273, identifier:DC_CONVERSION_DISPATCH; 274, string:'identifier'; 275, argument_list; 275, 276; 275, 279; 276, keyword_argument; 276, 277; 276, 278; 277, identifier:qualifier; 278, string:'ark'; 279, keyword_argument; 279, 280; 279, 281; 280, identifier:content; 281, identifier:ark; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:dc_root; 286, identifier:add_child; 287, argument_list; 287, 288; 288, identifier:ark_identifier; 289, if_statement; 289, 290; 289, 293; 289, 320; 289, 330; 290, boolean_operator:and; 290, 291; 290, 292; 291, identifier:sDate; 292, identifier:eDate; 293, block; 293, 294; 293, 313; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:dc_element; 297, call; 297, 298; 297, 301; 298, subscript; 298, 299; 298, 300; 299, identifier:DC_CONVERSION_DISPATCH; 300, string:'coverage'; 301, argument_list; 301, 302; 302, keyword_argument; 302, 303; 302, 304; 303, identifier:content; 304, binary_operator:%; 304, 305; 304, 306; 305, string:'%s-%s'; 306, tuple; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:sDate; 309, identifier:content; 310, attribute; 310, 311; 310, 312; 311, identifier:eDate; 312, identifier:content; 313, expression_statement; 313, 314; 314, call; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, identifier:dc_root; 317, identifier:add_child; 318, argument_list; 318, 319; 319, identifier:dc_element; 320, elif_clause; 320, 321; 320, 322; 321, identifier:sDate; 322, block; 322, 323; 323, expression_statement; 323, 324; 324, call; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:dc_root; 327, identifier:add_child; 328, argument_list; 328, 329; 329, identifier:sDate; 330, elif_clause; 330, 331; 330, 332; 331, identifier:eDate; 332, block; 332, 333; 333, expression_statement; 333, 334; 334, call; 334, 335; 334, 338; 335, attribute; 335, 336; 335, 337; 336, identifier:dc_root; 337, identifier:add_child; 338, argument_list; 338, 339; 339, identifier:eDate; 340, return_statement; 340, 341; 341, identifier:dc_root | def untlpy2dcpy(untl_elements, **kwargs):
sDate = None
eDate = None
ark = kwargs.get('ark', None)
domain_name = kwargs.get('domain_name', None)
scheme = kwargs.get('scheme', 'http')
resolve_values = kwargs.get('resolve_values', None)
resolve_urls = kwargs.get('resolve_urls', None)
verbose_vocabularies = kwargs.get('verbose_vocabularies', None)
if resolve_values or resolve_urls:
if verbose_vocabularies:
vocab_data = verbose_vocabularies
else:
vocab_data = retrieve_vocab()
else:
vocab_data = None
dc_root = DC_CONVERSION_DISPATCH['dc']()
for element in untl_elements.children:
if element.tag in DC_CONVERSION_DISPATCH:
if element.children:
dc_element = DC_CONVERSION_DISPATCH[element.tag](
qualifier=element.qualifier,
children=element.children,
resolve_values=resolve_values,
resolve_urls=resolve_urls,
vocab_data=vocab_data,
)
else:
dc_element = DC_CONVERSION_DISPATCH[element.tag](
qualifier=element.qualifier,
content=element.content,
resolve_values=resolve_values,
resolve_urls=resolve_urls,
vocab_data=vocab_data,
)
if element.tag == 'coverage':
if element.qualifier == 'sDate':
sDate = dc_element
elif element.qualifier == 'eDate':
eDate = dc_element
else:
dc_root.add_child(dc_element)
elif dc_element:
dc_root.add_child(dc_element)
if ark and domain_name:
permalink_identifier = DC_CONVERSION_DISPATCH['identifier'](
qualifier='permalink',
domain_name=domain_name,
ark=ark,
scheme=scheme
)
dc_root.add_child(permalink_identifier)
ark_identifier = DC_CONVERSION_DISPATCH['identifier'](
qualifier='ark',
content=ark,
)
dc_root.add_child(ark_identifier)
if sDate and eDate:
dc_element = DC_CONVERSION_DISPATCH['coverage'](
content='%s-%s' % (sDate.content, eDate.content),
)
dc_root.add_child(dc_element)
elif sDate:
dc_root.add_child(sDate)
elif eDate:
dc_root.add_child(eDate)
return dc_root |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:untlpy2highwirepy; 3, parameters; 3, 4; 3, 5; 4, identifier:untl_elements; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 12; 7, 16; 7, 20; 7, 24; 7, 34; 7, 180; 7, 190; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:highwire_list; 11, list:[]; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:title; 15, None; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:publisher; 19, None; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:creation; 23, None; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:escape; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:kwargs; 30, identifier:get; 31, argument_list; 31, 32; 31, 33; 32, string:'escape'; 33, False; 34, for_statement; 34, 35; 34, 36; 34, 39; 35, identifier:element; 36, attribute; 36, 37; 36, 38; 37, identifier:untl_elements; 38, identifier:children; 39, block; 39, 40; 40, if_statement; 40, 41; 40, 46; 41, comparison_operator:in; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:element; 44, identifier:tag; 45, identifier:HIGHWIRE_CONVERSION_DISPATCH; 46, block; 46, 47; 46, 75; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:highwire_element; 50, call; 50, 51; 50, 56; 51, subscript; 51, 52; 51, 53; 52, identifier:HIGHWIRE_CONVERSION_DISPATCH; 53, attribute; 53, 54; 53, 55; 54, identifier:element; 55, identifier:tag; 56, argument_list; 56, 57; 56, 62; 56, 67; 56, 72; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:qualifier; 59, attribute; 59, 60; 59, 61; 60, identifier:element; 61, identifier:qualifier; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:content; 64, attribute; 64, 65; 64, 66; 65, identifier:element; 66, identifier:content; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:children; 69, attribute; 69, 70; 69, 71; 70, identifier:element; 71, identifier:children; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:escape; 74, identifier:escape; 75, if_statement; 75, 76; 75, 77; 76, identifier:highwire_element; 77, block; 77, 78; 78, if_statement; 78, 79; 78, 84; 78, 110; 78, 132; 78, 168; 79, comparison_operator:==; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:element; 82, identifier:tag; 83, string:'title'; 84, block; 84, 85; 85, if_statement; 85, 86; 85, 94; 85, 99; 86, boolean_operator:and; 86, 87; 86, 92; 87, comparison_operator:!=; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:element; 90, identifier:qualifier; 91, string:'officialtitle'; 92, not_operator; 92, 93; 93, identifier:title; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:title; 98, identifier:highwire_element; 99, elif_clause; 99, 100; 99, 105; 100, comparison_operator:==; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:element; 103, identifier:qualifier; 104, string:'officialtitle'; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:title; 109, identifier:highwire_element; 110, elif_clause; 110, 111; 110, 116; 111, comparison_operator:==; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:element; 114, identifier:tag; 115, string:'publisher'; 116, block; 116, 117; 117, if_statement; 117, 118; 117, 120; 118, not_operator; 118, 119; 119, identifier:publisher; 120, block; 120, 121; 120, 125; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:publisher; 124, identifier:highwire_element; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:highwire_list; 129, identifier:append; 130, argument_list; 130, 131; 131, identifier:publisher; 132, elif_clause; 132, 133; 132, 138; 133, comparison_operator:==; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:element; 136, identifier:tag; 137, string:'date'; 138, block; 138, 139; 139, if_statement; 139, 140; 139, 148; 140, boolean_operator:and; 140, 141; 140, 143; 141, not_operator; 141, 142; 142, identifier:creation; 143, comparison_operator:==; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:element; 146, identifier:qualifier; 147, string:'creation'; 148, block; 148, 149; 149, if_statement; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:highwire_element; 152, identifier:content; 153, block; 153, 154; 153, 158; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:creation; 157, identifier:highwire_element; 158, if_statement; 158, 159; 158, 160; 159, identifier:creation; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:highwire_list; 165, identifier:append; 166, argument_list; 166, 167; 167, identifier:creation; 168, elif_clause; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:highwire_element; 171, identifier:content; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:highwire_list; 177, identifier:append; 178, argument_list; 178, 179; 179, identifier:highwire_element; 180, if_statement; 180, 181; 180, 182; 181, identifier:title; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:highwire_list; 187, identifier:append; 188, argument_list; 188, 189; 189, identifier:title; 190, return_statement; 190, 191; 191, identifier:highwire_list | def untlpy2highwirepy(untl_elements, **kwargs):
highwire_list = []
title = None
publisher = None
creation = None
escape = kwargs.get('escape', False)
for element in untl_elements.children:
if element.tag in HIGHWIRE_CONVERSION_DISPATCH:
highwire_element = HIGHWIRE_CONVERSION_DISPATCH[element.tag](
qualifier=element.qualifier,
content=element.content,
children=element.children,
escape=escape,
)
if highwire_element:
if element.tag == 'title':
if element.qualifier != 'officialtitle' and not title:
title = highwire_element
elif element.qualifier == 'officialtitle':
title = highwire_element
elif element.tag == 'publisher':
if not publisher:
publisher = highwire_element
highwire_list.append(publisher)
elif element.tag == 'date':
if not creation and element.qualifier == 'creation':
if highwire_element.content:
creation = highwire_element
if creation:
highwire_list.append(creation)
elif highwire_element.content:
highwire_list.append(highwire_element)
if title:
highwire_list.append(title)
return highwire_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:untlpy2etd_ms; 3, parameters; 3, 4; 3, 5; 4, identifier:untl_elements; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 12; 7, 16; 7, 20; 7, 28; 7, 287; 7, 340; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:degree_children; 11, dictionary; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:date_exists; 15, False; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:seen_creation; 19, False; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:etd_ms_root; 23, call; 23, 24; 23, 27; 24, subscript; 24, 25; 24, 26; 25, identifier:ETD_MS_CONVERSION_DISPATCH; 26, string:'thesis'; 27, argument_list; 28, for_statement; 28, 29; 28, 30; 28, 33; 29, identifier:element; 30, attribute; 30, 31; 30, 32; 31, identifier:untl_elements; 32, identifier:children; 33, block; 33, 34; 33, 38; 33, 206; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:etd_ms_element; 37, None; 38, if_statement; 38, 39; 38, 44; 39, comparison_operator:in; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:element; 42, identifier:tag; 43, identifier:ETD_MS_CONVERSION_DISPATCH; 44, block; 44, 45; 44, 196; 45, if_statement; 45, 46; 45, 49; 45, 70; 45, 98; 45, 167; 46, attribute; 46, 47; 46, 48; 47, identifier:element; 48, identifier:children; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:etd_ms_element; 53, call; 53, 54; 53, 59; 54, subscript; 54, 55; 54, 56; 55, identifier:ETD_MS_CONVERSION_DISPATCH; 56, attribute; 56, 57; 56, 58; 57, identifier:element; 58, identifier:tag; 59, argument_list; 59, 60; 59, 65; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:qualifier; 62, attribute; 62, 63; 62, 64; 63, identifier:element; 64, identifier:qualifier; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:children; 67, attribute; 67, 68; 67, 69; 68, identifier:element; 69, identifier:children; 70, elif_clause; 70, 71; 70, 76; 71, comparison_operator:==; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:element; 74, identifier:tag; 75, string:'degree'; 76, block; 76, 77; 77, if_statement; 77, 78; 77, 87; 78, comparison_operator:in; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:element; 81, identifier:qualifier; 82, list:['name',
'level',
'discipline',
'grantor']; 82, 83; 82, 84; 82, 85; 82, 86; 83, string:'name'; 84, string:'level'; 85, string:'discipline'; 86, string:'grantor'; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 95; 90, subscript; 90, 91; 90, 92; 91, identifier:degree_children; 92, attribute; 92, 93; 92, 94; 93, identifier:element; 94, identifier:qualifier; 95, attribute; 95, 96; 95, 97; 96, identifier:element; 97, identifier:content; 98, elif_clause; 98, 99; 98, 104; 99, comparison_operator:==; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:element; 102, identifier:tag; 103, string:'date'; 104, block; 104, 105; 105, if_statement; 105, 106; 105, 111; 106, comparison_operator:==; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:element; 109, identifier:qualifier; 110, string:'creation'; 111, block; 111, 112; 111, 135; 111, 139; 112, for_statement; 112, 113; 112, 114; 112, 117; 113, identifier:child; 114, attribute; 114, 115; 114, 116; 115, identifier:etd_ms_root; 116, identifier:children; 117, block; 117, 118; 118, if_statement; 118, 119; 118, 124; 119, comparison_operator:==; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:child; 122, identifier:tag; 123, string:'date'; 124, block; 124, 125; 124, 127; 125, delete_statement; 125, 126; 126, identifier:child; 127, if_statement; 127, 128; 127, 130; 128, not_operator; 128, 129; 129, identifier:seen_creation; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:date_exists; 134, False; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:seen_creation; 138, True; 139, if_statement; 139, 140; 139, 142; 140, not_operator; 140, 141; 141, identifier:date_exists; 142, block; 142, 143; 142, 163; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:etd_ms_element; 146, call; 146, 147; 146, 152; 147, subscript; 147, 148; 147, 149; 148, identifier:ETD_MS_CONVERSION_DISPATCH; 149, attribute; 149, 150; 149, 151; 150, identifier:element; 151, identifier:tag; 152, argument_list; 152, 153; 152, 158; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:qualifier; 155, attribute; 155, 156; 155, 157; 156, identifier:element; 157, identifier:qualifier; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:content; 160, attribute; 160, 161; 160, 162; 161, identifier:element; 162, identifier:content; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:date_exists; 166, True; 167, elif_clause; 167, 168; 167, 175; 168, comparison_operator:not; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:element; 171, identifier:tag; 172, list:['date', 'degree']; 172, 173; 172, 174; 173, string:'date'; 174, string:'degree'; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:etd_ms_element; 179, call; 179, 180; 179, 185; 180, subscript; 180, 181; 180, 182; 181, identifier:ETD_MS_CONVERSION_DISPATCH; 182, attribute; 182, 183; 182, 184; 183, identifier:element; 184, identifier:tag; 185, argument_list; 185, 186; 185, 191; 186, keyword_argument; 186, 187; 186, 188; 187, identifier:qualifier; 188, attribute; 188, 189; 188, 190; 189, identifier:element; 190, identifier:qualifier; 191, keyword_argument; 191, 192; 191, 193; 192, identifier:content; 193, attribute; 193, 194; 193, 195; 194, identifier:element; 195, identifier:content; 196, if_statement; 196, 197; 196, 198; 197, identifier:etd_ms_element; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:etd_ms_root; 203, identifier:add_child; 204, argument_list; 204, 205; 205, identifier:etd_ms_element; 206, if_statement; 206, 207; 206, 212; 207, comparison_operator:==; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:element; 210, identifier:tag; 211, string:'meta'; 212, block; 212, 213; 212, 217; 212, 243; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:ark; 216, False; 217, for_statement; 217, 218; 217, 219; 217, 222; 218, identifier:i; 219, attribute; 219, 220; 219, 221; 220, identifier:etd_ms_root; 221, identifier:children; 222, block; 222, 223; 223, if_statement; 223, 224; 223, 238; 224, boolean_operator:and; 224, 225; 224, 230; 225, comparison_operator:==; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:i; 228, identifier:tag; 229, string:'identifier'; 230, call; 230, 231; 230, 236; 231, attribute; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:i; 234, identifier:content; 235, identifier:startswith; 236, argument_list; 236, 237; 237, string:'http://digital.library.unt.edu/'; 238, block; 238, 239; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:ark; 242, True; 243, if_statement; 243, 244; 243, 246; 244, not_operator; 244, 245; 245, identifier:ark; 246, block; 246, 247; 246, 251; 246, 264; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:ark; 250, False; 251, if_statement; 251, 252; 251, 257; 252, comparison_operator:==; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:element; 255, identifier:qualifier; 256, string:'ark'; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:ark; 261, attribute; 261, 262; 261, 263; 262, identifier:element; 263, identifier:content; 264, if_statement; 264, 265; 264, 268; 265, comparison_operator:is; 265, 266; 265, 267; 266, identifier:ark; 267, None; 268, block; 268, 269; 268, 280; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:ark_identifier; 272, call; 272, 273; 272, 276; 273, subscript; 273, 274; 273, 275; 274, identifier:ETD_MS_CONVERSION_DISPATCH; 275, string:'identifier'; 276, argument_list; 276, 277; 277, keyword_argument; 277, 278; 277, 279; 278, identifier:ark; 279, identifier:ark; 280, expression_statement; 280, 281; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:etd_ms_root; 284, identifier:add_child; 285, argument_list; 285, 286; 286, identifier:ark_identifier; 287, if_statement; 287, 288; 287, 289; 288, identifier:degree_children; 289, block; 289, 290; 289, 298; 289, 302; 289, 333; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:degree_element; 293, call; 293, 294; 293, 297; 294, subscript; 294, 295; 294, 296; 295, identifier:ETD_MS_CONVERSION_DISPATCH; 296, string:'degree'; 297, argument_list; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 301; 300, identifier:degree_child_element; 301, None; 302, for_statement; 302, 303; 302, 306; 302, 311; 303, pattern_list; 303, 304; 303, 305; 304, identifier:k; 305, identifier:v; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:degree_children; 309, identifier:iteritems; 310, argument_list; 311, block; 311, 312; 311, 323; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 315; 314, identifier:degree_child_element; 315, call; 315, 316; 315, 319; 316, subscript; 316, 317; 316, 318; 317, identifier:ETD_MS_DEGREE_DISPATCH; 318, identifier:k; 319, argument_list; 319, 320; 320, keyword_argument; 320, 321; 320, 322; 321, identifier:content; 322, identifier:v; 323, if_statement; 323, 324; 323, 325; 324, identifier:degree_child_element; 325, block; 325, 326; 326, expression_statement; 326, 327; 327, call; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:degree_element; 330, identifier:add_child; 331, argument_list; 331, 332; 332, identifier:degree_child_element; 333, expression_statement; 333, 334; 334, call; 334, 335; 334, 338; 335, attribute; 335, 336; 335, 337; 336, identifier:etd_ms_root; 337, identifier:add_child; 338, argument_list; 338, 339; 339, identifier:degree_element; 340, return_statement; 340, 341; 341, identifier:etd_ms_root | def untlpy2etd_ms(untl_elements, **kwargs):
degree_children = {}
date_exists = False
seen_creation = False
etd_ms_root = ETD_MS_CONVERSION_DISPATCH['thesis']()
for element in untl_elements.children:
etd_ms_element = None
if element.tag in ETD_MS_CONVERSION_DISPATCH:
if element.children:
etd_ms_element = ETD_MS_CONVERSION_DISPATCH[element.tag](
qualifier=element.qualifier,
children=element.children,
)
elif element.tag == 'degree':
if element.qualifier in ['name',
'level',
'discipline',
'grantor']:
degree_children[element.qualifier] = element.content
elif element.tag == 'date':
if element.qualifier == 'creation':
for child in etd_ms_root.children:
if child.tag == 'date':
del child
if not seen_creation:
date_exists = False
seen_creation = True
if not date_exists:
etd_ms_element = ETD_MS_CONVERSION_DISPATCH[element.tag](
qualifier=element.qualifier,
content=element.content,
)
date_exists = True
elif element.tag not in ['date', 'degree']:
etd_ms_element = ETD_MS_CONVERSION_DISPATCH[element.tag](
qualifier=element.qualifier,
content=element.content,
)
if etd_ms_element:
etd_ms_root.add_child(etd_ms_element)
if element.tag == 'meta':
ark = False
for i in etd_ms_root.children:
if i.tag == 'identifier' and i.content.startswith(
'http://digital.library.unt.edu/'
):
ark = True
if not ark:
ark = False
if element.qualifier == 'ark':
ark = element.content
if ark is not None:
ark_identifier = ETD_MS_CONVERSION_DISPATCH['identifier'](
ark=ark,
)
etd_ms_root.add_child(ark_identifier)
if degree_children:
degree_element = ETD_MS_CONVERSION_DISPATCH['degree']()
degree_child_element = None
for k, v in degree_children.iteritems():
degree_child_element = ETD_MS_DEGREE_DISPATCH[k](
content=v,
)
if degree_child_element:
degree_element.add_child(degree_child_element)
etd_ms_root.add_child(degree_element)
return etd_ms_root |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:global_request; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:kind; 6, default_parameter; 6, 7; 6, 8; 7, identifier:data; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:wait; 11, True; 12, block; 12, 13; 12, 26; 12, 32; 12, 39; 12, 46; 12, 53; 12, 66; 12, 76; 12, 83; 12, 89; 12, 119; 13, if_statement; 13, 14; 13, 15; 14, identifier:wait; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:completion_event; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:threading; 24, identifier:Event; 25, argument_list; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:m; 29, call; 29, 30; 29, 31; 30, identifier:Message; 31, argument_list; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:m; 36, identifier:add_byte; 37, argument_list; 37, 38; 38, identifier:cMSG_GLOBAL_REQUEST; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:m; 43, identifier:add_string; 44, argument_list; 44, 45; 45, identifier:kind; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:m; 50, identifier:add_boolean; 51, argument_list; 51, 52; 52, identifier:wait; 53, if_statement; 53, 54; 53, 57; 54, comparison_operator:is; 54, 55; 54, 56; 55, identifier:data; 56, None; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:m; 62, identifier:add; 63, argument_list; 63, 64; 64, list_splat; 64, 65; 65, identifier:data; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:_log; 71, argument_list; 71, 72; 71, 73; 72, identifier:DEBUG; 73, binary_operator:%; 73, 74; 73, 75; 74, string:'Sending global request "%s"'; 75, identifier:kind; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_send_user_message; 81, argument_list; 81, 82; 82, identifier:m; 83, if_statement; 83, 84; 83, 86; 84, not_operator; 84, 85; 85, identifier:wait; 86, block; 86, 87; 87, return_statement; 87, 88; 88, None; 89, while_statement; 89, 90; 89, 91; 90, True; 91, block; 91, 92; 91, 101; 91, 109; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:completion_event; 98, identifier:wait; 99, argument_list; 99, 100; 100, float:0.1; 101, if_statement; 101, 102; 101, 106; 102, not_operator; 102, 103; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:active; 106, block; 106, 107; 107, return_statement; 107, 108; 108, None; 109, if_statement; 109, 110; 109, 117; 110, call; 110, 111; 110, 116; 111, attribute; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:completion_event; 115, identifier:isSet; 116, argument_list; 117, block; 117, 118; 118, break_statement; 119, return_statement; 119, 120; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:global_response | def global_request(self, kind, data=None, wait=True):
if wait:
self.completion_event = threading.Event()
m = Message()
m.add_byte(cMSG_GLOBAL_REQUEST)
m.add_string(kind)
m.add_boolean(wait)
if data is not None:
m.add(*data)
self._log(DEBUG, 'Sending global request "%s"' % kind)
self._send_user_message(m)
if not wait:
return None
while True:
self.completion_event.wait(0.1)
if not self.active:
return None
if self.completion_event.isSet():
break
return self.global_response |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_by_range; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:model_cls; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 19; 9, 28; 9, 46; 9, 66; 9, 103; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:start_timestamp; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:kwargs; 16, identifier:get; 17, argument_list; 17, 18; 18, string:'start_timestamp'; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:end_timestamp; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:kwargs; 25, identifier:get; 26, argument_list; 26, 27; 27, string:'end_timestamp'; 28, if_statement; 28, 29; 28, 43; 29, boolean_operator:and; 29, 30; 29, 39; 30, boolean_operator:and; 30, 31; 30, 35; 31, parenthesized_expression; 31, 32; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:start_timestamp; 34, None; 35, parenthesized_expression; 35, 36; 36, comparison_operator:is; 36, 37; 36, 38; 37, identifier:end_timestamp; 38, None; 39, parenthesized_expression; 39, 40; 40, comparison_operator:>; 40, 41; 40, 42; 41, identifier:start_timestamp; 42, identifier:end_timestamp; 43, block; 43, 44; 44, raise_statement; 44, 45; 45, identifier:InvalidTimestampRange; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:models; 49, call; 49, 50; 49, 62; 50, attribute; 50, 51; 50, 61; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:model_cls; 54, identifier:read_time_range; 55, argument_list; 55, 56; 55, 58; 56, list_splat; 56, 57; 57, identifier:args; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:end_timestamp; 60, identifier:end_timestamp; 61, identifier:order_by; 62, argument_list; 62, 63; 63, attribute; 63, 64; 63, 65; 64, identifier:model_cls; 65, identifier:time_order; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:is; 67, 68; 67, 69; 68, identifier:start_timestamp; 69, None; 70, block; 70, 71; 70, 75; 70, 95; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:index; 74, integer:0; 75, for_statement; 75, 76; 75, 79; 75, 86; 76, pattern_list; 76, 77; 76, 78; 77, identifier:index; 78, identifier:model; 79, call; 79, 80; 79, 81; 80, identifier:enumerate; 81, argument_list; 81, 82; 81, 83; 82, identifier:models; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:start; 85, integer:1; 86, block; 86, 87; 87, if_statement; 87, 88; 87, 93; 88, comparison_operator:<=; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:model; 91, identifier:timestamp; 92, identifier:start_timestamp; 93, block; 93, 94; 94, break_statement; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:models; 98, subscript; 98, 99; 98, 100; 99, identifier:models; 100, slice; 100, 101; 100, 102; 101, colon; 102, identifier:index; 103, return_statement; 103, 104; 104, identifier:models | def get_by_range(model_cls, *args, **kwargs):
start_timestamp = kwargs.get('start_timestamp')
end_timestamp = kwargs.get('end_timestamp')
if (start_timestamp is not None) and (end_timestamp is not None) and (start_timestamp > end_timestamp):
raise InvalidTimestampRange
models = model_cls.read_time_range(*args, end_timestamp=end_timestamp).order_by(model_cls.time_order)
if start_timestamp is not None:
index = 0
for index, model in enumerate(models, start=1):
if model.timestamp <= start_timestamp:
break
models = models[:index]
return models |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:add_data; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:data; 6, default_parameter; 6, 7; 6, 8; 7, identifier:metadata; 8, None; 9, block; 9, 10; 9, 19; 9, 60; 9, 68; 9, 108; 9, 125; 9, 129; 9, 170; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:subdata; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:np; 16, identifier:atleast_2d; 17, argument_list; 17, 18; 18, identifier:data; 19, if_statement; 19, 20; 19, 31; 20, comparison_operator:!=; 20, 21; 20, 26; 21, subscript; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:subdata; 24, identifier:shape; 25, integer:1; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:grid; 30, identifier:nr_of_elements; 31, block; 31, 32; 32, if_statement; 32, 33; 32, 44; 32, 51; 33, comparison_operator:==; 33, 34; 33, 39; 34, subscript; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:subdata; 37, identifier:shape; 38, integer:0; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:grid; 43, identifier:nr_of_elements; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:subdata; 48, attribute; 48, 49; 48, 50; 49, identifier:subdata; 50, identifier:T; 51, else_clause; 51, 52; 52, block; 52, 53; 53, raise_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:Exception; 56, argument_list; 56, 57; 57, binary_operator:+; 57, 58; 57, 59; 58, string:'Number of values does not match the number of '; 59, string:'elements in the grid'; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:K; 63, subscript; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:subdata; 66, identifier:shape; 67, integer:0; 68, if_statement; 68, 69; 68, 72; 69, comparison_operator:is; 69, 70; 69, 71; 70, identifier:metadata; 71, None; 72, block; 72, 73; 73, if_statement; 73, 74; 73, 77; 73, 101; 74, comparison_operator:>; 74, 75; 74, 76; 75, identifier:K; 76, integer:1; 77, block; 77, 78; 78, if_statement; 78, 79; 78, 95; 79, parenthesized_expression; 79, 80; 80, boolean_operator:or; 80, 81; 80, 89; 81, not_operator; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:isinstance; 84, argument_list; 84, 85; 84, 86; 85, identifier:metadata; 86, tuple; 86, 87; 86, 88; 87, identifier:list; 88, identifier:tuple; 89, comparison_operator:!=; 89, 90; 89, 94; 90, call; 90, 91; 90, 92; 91, identifier:len; 92, argument_list; 92, 93; 93, identifier:metadata; 94, identifier:K; 95, block; 95, 96; 96, raise_statement; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:Exception; 99, argument_list; 99, 100; 100, string:'metadata does not fit the provided data'; 101, else_clause; 101, 102; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:metadata; 106, list:[metadata, ]; 106, 107; 107, identifier:metadata; 108, if_statement; 108, 109; 108, 112; 109, comparison_operator:is; 109, 110; 109, 111; 110, identifier:metadata; 111, None; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:metadata; 116, list_comprehension; 116, 117; 116, 118; 117, None; 118, for_in_clause; 118, 119; 118, 120; 119, identifier:i; 120, call; 120, 121; 120, 122; 121, identifier:range; 122, argument_list; 122, 123; 122, 124; 123, integer:0; 124, identifier:K; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:return_ids; 128, list:[]; 129, for_statement; 129, 130; 129, 133; 129, 138; 130, pattern_list; 130, 131; 130, 132; 131, identifier:dataset; 132, identifier:meta; 133, call; 133, 134; 133, 135; 134, identifier:zip; 135, argument_list; 135, 136; 135, 137; 136, identifier:subdata; 137, identifier:metadata; 138, block; 138, 139; 138, 147; 138, 155; 138, 163; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:cid; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:_get_next_index; 146, argument_list; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 154; 149, subscript; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:parsets; 153, identifier:cid; 154, identifier:dataset; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 162; 157, subscript; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:metadata; 161, identifier:cid; 162, identifier:meta; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:return_ids; 167, identifier:append; 168, argument_list; 168, 169; 169, identifier:cid; 170, if_statement; 170, 171; 170, 177; 170, 182; 171, comparison_operator:==; 171, 172; 171, 176; 172, call; 172, 173; 172, 174; 173, identifier:len; 174, argument_list; 174, 175; 175, identifier:return_ids; 176, integer:1; 177, block; 177, 178; 178, return_statement; 178, 179; 179, subscript; 179, 180; 179, 181; 180, identifier:return_ids; 181, integer:0; 182, else_clause; 182, 183; 183, block; 183, 184; 184, return_statement; 184, 185; 185, identifier:return_ids | def add_data(self, data, metadata=None):
subdata = np.atleast_2d(data)
if subdata.shape[1] != self.grid.nr_of_elements:
if subdata.shape[0] == self.grid.nr_of_elements:
subdata = subdata.T
else:
raise Exception(
'Number of values does not match the number of ' +
'elements in the grid'
)
K = subdata.shape[0]
if metadata is not None:
if K > 1:
if(not isinstance(metadata, (list, tuple)) or
len(metadata) != K):
raise Exception('metadata does not fit the provided data')
else:
metadata = [metadata, ]
if metadata is None:
metadata = [None for i in range(0, K)]
return_ids = []
for dataset, meta in zip(subdata, metadata):
cid = self._get_next_index()
self.parsets[cid] = dataset
self.metadata[cid] = meta
return_ids.append(cid)
if len(return_ids) == 1:
return return_ids[0]
else:
return return_ids |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:linked_model_for_class; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:cls; 6, default_parameter; 6, 7; 6, 8; 7, identifier:make_constants_variable; 8, False; 9, dictionary_splat_pattern; 9, 10; 10, identifier:kwargs; 11, block; 11, 12; 11, 23; 11, 29; 11, 36; 11, 117; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:constructor_args; 15, attribute; 15, 16; 15, 22; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:inspect; 19, identifier:getfullargspec; 20, argument_list; 20, 21; 21, identifier:cls; 22, identifier:args; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:attribute_tuples; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:attribute_tuples; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:new_model; 32, call; 32, 33; 32, 34; 33, identifier:PriorModel; 34, argument_list; 34, 35; 35, identifier:cls; 36, for_statement; 36, 37; 36, 38; 36, 39; 37, identifier:attribute_tuple; 38, identifier:attribute_tuples; 39, block; 39, 40; 39, 46; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:name; 43, attribute; 43, 44; 43, 45; 44, identifier:attribute_tuple; 45, identifier:name; 46, if_statement; 46, 47; 46, 63; 47, boolean_operator:or; 47, 48; 47, 51; 48, comparison_operator:in; 48, 49; 48, 50; 49, identifier:name; 50, identifier:constructor_args; 51, parenthesized_expression; 51, 52; 52, boolean_operator:and; 52, 53; 52, 57; 53, call; 53, 54; 53, 55; 54, identifier:is_tuple_like_attribute_name; 55, argument_list; 55, 56; 56, identifier:name; 57, comparison_operator:in; 57, 58; 57, 62; 58, call; 58, 59; 58, 60; 59, identifier:tuple_name; 60, argument_list; 60, 61; 61, identifier:name; 62, identifier:constructor_args; 63, block; 63, 64; 63, 77; 63, 110; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:attribute; 67, conditional_expression:if; 67, 68; 67, 71; 67, 74; 68, subscript; 68, 69; 68, 70; 69, identifier:kwargs; 70, identifier:name; 71, comparison_operator:in; 71, 72; 71, 73; 72, identifier:name; 73, identifier:kwargs; 74, attribute; 74, 75; 74, 76; 75, identifier:attribute_tuple; 76, identifier:value; 77, if_statement; 77, 78; 77, 85; 78, boolean_operator:and; 78, 79; 78, 80; 79, identifier:make_constants_variable; 80, call; 80, 81; 80, 82; 81, identifier:isinstance; 82, argument_list; 82, 83; 82, 84; 83, identifier:attribute; 84, identifier:Constant; 85, block; 85, 86; 85, 94; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:new_attribute; 89, call; 89, 90; 89, 91; 90, identifier:getattr; 91, argument_list; 91, 92; 91, 93; 92, identifier:new_model; 93, identifier:name; 94, if_statement; 94, 95; 94, 100; 95, call; 95, 96; 95, 97; 96, identifier:isinstance; 97, argument_list; 97, 98; 97, 99; 98, identifier:new_attribute; 99, identifier:Prior; 100, block; 100, 101; 100, 109; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:new_attribute; 105, identifier:mean; 106, attribute; 106, 107; 106, 108; 107, identifier:attribute; 108, identifier:value; 109, continue_statement; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:setattr; 113, argument_list; 113, 114; 113, 115; 113, 116; 114, identifier:new_model; 115, identifier:name; 116, identifier:attribute; 117, return_statement; 117, 118; 118, identifier:new_model | def linked_model_for_class(self, cls, make_constants_variable=False, **kwargs):
constructor_args = inspect.getfullargspec(cls).args
attribute_tuples = self.attribute_tuples
new_model = PriorModel(cls)
for attribute_tuple in attribute_tuples:
name = attribute_tuple.name
if name in constructor_args or (
is_tuple_like_attribute_name(name) and tuple_name(name) in constructor_args):
attribute = kwargs[name] if name in kwargs else attribute_tuple.value
if make_constants_variable and isinstance(attribute, Constant):
new_attribute = getattr(new_model, name)
if isinstance(new_attribute, Prior):
new_attribute.mean = attribute.value
continue
setattr(new_model, name, attribute)
return new_model |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:load_categories; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:max_pages; 7, integer:30; 8, block; 8, 9; 8, 16; 8, 38; 8, 49; 8, 56; 8, 60; 8, 70; 8, 89; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:logger; 13, identifier:info; 14, argument_list; 14, 15; 15, string:"loading categories"; 16, if_statement; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:purge_first; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 37; 23, attribute; 23, 24; 23, 36; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:Category; 28, identifier:objects; 29, identifier:filter; 30, argument_list; 30, 31; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:site_id; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:site_id; 36, identifier:delete; 37, argument_list; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:path; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, string:"sites/{}/categories"; 44, identifier:format; 45, argument_list; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:site_id; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:params; 52, dictionary; 52, 53; 53, pair; 53, 54; 53, 55; 54, string:"number"; 55, integer:100; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:page; 59, integer:1; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:response; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:get; 67, argument_list; 67, 68; 67, 69; 68, identifier:path; 69, identifier:params; 70, if_statement; 70, 71; 70, 75; 71, not_operator; 71, 72; 72, attribute; 72, 73; 72, 74; 73, identifier:response; 74, identifier:ok; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:logger; 80, identifier:warning; 81, argument_list; 81, 82; 81, 83; 81, 86; 82, string:"Response NOT OK! status_code=%s\n%s"; 83, attribute; 83, 84; 83, 85; 84, identifier:response; 85, identifier:status_code; 86, attribute; 86, 87; 86, 88; 87, identifier:response; 88, identifier:text; 89, while_statement; 89, 90; 89, 101; 90, boolean_operator:and; 90, 91; 90, 98; 91, boolean_operator:and; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:response; 94, identifier:ok; 95, attribute; 95, 96; 95, 97; 96, identifier:response; 97, identifier:text; 98, comparison_operator:<; 98, 99; 98, 100; 99, identifier:page; 100, identifier:max_pages; 101, block; 101, 102; 101, 110; 101, 123; 101, 128; 101, 132; 101, 185; 101, 204; 101, 208; 101, 214; 101, 224; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:logger; 106, identifier:info; 107, argument_list; 107, 108; 107, 109; 108, string:" - page: %d"; 109, identifier:page; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:api_categories; 113, call; 113, 114; 113, 121; 114, attribute; 114, 115; 114, 120; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:response; 118, identifier:json; 119, argument_list; 120, identifier:get; 121, argument_list; 121, 122; 122, string:"categories"; 123, if_statement; 123, 124; 123, 126; 124, not_operator; 124, 125; 125, identifier:api_categories; 126, block; 126, 127; 127, break_statement; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:categories; 131, list:[]; 132, for_statement; 132, 133; 132, 134; 132, 135; 133, identifier:api_category; 134, identifier:api_categories; 135, block; 135, 136; 135, 160; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:existing_category; 139, call; 139, 140; 139, 159; 140, attribute; 140, 141; 140, 158; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:Category; 145, identifier:objects; 146, identifier:filter; 147, argument_list; 147, 148; 147, 153; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:site_id; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:site_id; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:wp_id; 155, subscript; 155, 156; 155, 157; 156, identifier:api_category; 157, string:"ID"; 158, identifier:first; 159, argument_list; 160, if_statement; 160, 161; 160, 162; 160, 171; 161, identifier:existing_category; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:update_existing_category; 168, argument_list; 168, 169; 168, 170; 169, identifier:existing_category; 170, identifier:api_category; 171, else_clause; 171, 172; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:categories; 177, identifier:append; 178, argument_list; 178, 179; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:get_new_category; 183, argument_list; 183, 184; 184, identifier:api_category; 185, if_statement; 185, 186; 185, 187; 185, 197; 186, identifier:categories; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 195; 190, attribute; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:Category; 193, identifier:objects; 194, identifier:bulk_create; 195, argument_list; 195, 196; 196, identifier:categories; 197, elif_clause; 197, 198; 197, 202; 198, not_operator; 198, 199; 199, attribute; 199, 200; 199, 201; 200, identifier:self; 201, identifier:full; 202, block; 202, 203; 203, break_statement; 204, expression_statement; 204, 205; 205, augmented_assignment:+=; 205, 206; 205, 207; 206, identifier:page; 207, integer:1; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:params; 212, string:"page"; 213, identifier:page; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:response; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:get; 221, argument_list; 221, 222; 221, 223; 222, identifier:path; 223, identifier:params; 224, if_statement; 224, 225; 224, 229; 225, not_operator; 225, 226; 226, attribute; 226, 227; 226, 228; 227, identifier:response; 228, identifier:ok; 229, block; 229, 230; 229, 243; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:logger; 234, identifier:warning; 235, argument_list; 235, 236; 235, 237; 235, 240; 236, string:"Response NOT OK! status_code=%s\n%s"; 237, attribute; 237, 238; 237, 239; 238, identifier:response; 239, identifier:status_code; 240, attribute; 240, 241; 240, 242; 241, identifier:response; 242, identifier:text; 243, return_statement | def load_categories(self, max_pages=30):
logger.info("loading categories")
if self.purge_first:
Category.objects.filter(site_id=self.site_id).delete()
path = "sites/{}/categories".format(self.site_id)
params = {"number": 100}
page = 1
response = self.get(path, params)
if not response.ok:
logger.warning("Response NOT OK! status_code=%s\n%s", response.status_code, response.text)
while response.ok and response.text and page < max_pages:
logger.info(" - page: %d", page)
api_categories = response.json().get("categories")
if not api_categories:
break
categories = []
for api_category in api_categories:
existing_category = Category.objects.filter(site_id=self.site_id, wp_id=api_category["ID"]).first()
if existing_category:
self.update_existing_category(existing_category, api_category)
else:
categories.append(self.get_new_category(api_category))
if categories:
Category.objects.bulk_create(categories)
elif not self.full:
break
page += 1
params["page"] = page
response = self.get(path, params)
if not response.ok:
logger.warning("Response NOT OK! status_code=%s\n%s", response.status_code, response.text)
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:load_tags; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:max_pages; 7, integer:30; 8, block; 8, 9; 8, 16; 8, 38; 8, 49; 8, 56; 8, 60; 8, 70; 8, 89; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:logger; 13, identifier:info; 14, argument_list; 14, 15; 15, string:"loading tags"; 16, if_statement; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:purge_first; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 37; 23, attribute; 23, 24; 23, 36; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:Tag; 28, identifier:objects; 29, identifier:filter; 30, argument_list; 30, 31; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:site_id; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:site_id; 36, identifier:delete; 37, argument_list; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:path; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, string:"sites/{}/tags"; 44, identifier:format; 45, argument_list; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:site_id; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:params; 52, dictionary; 52, 53; 53, pair; 53, 54; 53, 55; 54, string:"number"; 55, integer:1000; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:page; 59, integer:1; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:response; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:get; 67, argument_list; 67, 68; 67, 69; 68, identifier:path; 69, identifier:params; 70, if_statement; 70, 71; 70, 75; 71, not_operator; 71, 72; 72, attribute; 72, 73; 72, 74; 73, identifier:response; 74, identifier:ok; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:logger; 80, identifier:warning; 81, argument_list; 81, 82; 81, 83; 81, 86; 82, string:"Response NOT OK! status_code=%s\n%s"; 83, attribute; 83, 84; 83, 85; 84, identifier:response; 85, identifier:status_code; 86, attribute; 86, 87; 86, 88; 87, identifier:response; 88, identifier:text; 89, while_statement; 89, 90; 89, 101; 90, boolean_operator:and; 90, 91; 90, 98; 91, boolean_operator:and; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:response; 94, identifier:ok; 95, attribute; 95, 96; 95, 97; 96, identifier:response; 97, identifier:text; 98, comparison_operator:<; 98, 99; 98, 100; 99, identifier:page; 100, identifier:max_pages; 101, block; 101, 102; 101, 110; 101, 123; 101, 128; 101, 132; 101, 185; 101, 204; 101, 208; 101, 214; 101, 224; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:logger; 106, identifier:info; 107, argument_list; 107, 108; 107, 109; 108, string:" - page: %d"; 109, identifier:page; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:api_tags; 113, call; 113, 114; 113, 121; 114, attribute; 114, 115; 114, 120; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:response; 118, identifier:json; 119, argument_list; 120, identifier:get; 121, argument_list; 121, 122; 122, string:"tags"; 123, if_statement; 123, 124; 123, 126; 124, not_operator; 124, 125; 125, identifier:api_tags; 126, block; 126, 127; 127, break_statement; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:tags; 131, list:[]; 132, for_statement; 132, 133; 132, 134; 132, 135; 133, identifier:api_tag; 134, identifier:api_tags; 135, block; 135, 136; 135, 160; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:existing_tag; 139, call; 139, 140; 139, 159; 140, attribute; 140, 141; 140, 158; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:Tag; 145, identifier:objects; 146, identifier:filter; 147, argument_list; 147, 148; 147, 153; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:site_id; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:site_id; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:wp_id; 155, subscript; 155, 156; 155, 157; 156, identifier:api_tag; 157, string:"ID"; 158, identifier:first; 159, argument_list; 160, if_statement; 160, 161; 160, 162; 160, 171; 161, identifier:existing_tag; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:update_existing_tag; 168, argument_list; 168, 169; 168, 170; 169, identifier:existing_tag; 170, identifier:api_tag; 171, else_clause; 171, 172; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:tags; 177, identifier:append; 178, argument_list; 178, 179; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:get_new_tag; 183, argument_list; 183, 184; 184, identifier:api_tag; 185, if_statement; 185, 186; 185, 187; 185, 197; 186, identifier:tags; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 195; 190, attribute; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:Tag; 193, identifier:objects; 194, identifier:bulk_create; 195, argument_list; 195, 196; 196, identifier:tags; 197, elif_clause; 197, 198; 197, 202; 198, not_operator; 198, 199; 199, attribute; 199, 200; 199, 201; 200, identifier:self; 201, identifier:full; 202, block; 202, 203; 203, break_statement; 204, expression_statement; 204, 205; 205, augmented_assignment:+=; 205, 206; 205, 207; 206, identifier:page; 207, integer:1; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:params; 212, string:"page"; 213, identifier:page; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:response; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:get; 221, argument_list; 221, 222; 221, 223; 222, identifier:path; 223, identifier:params; 224, if_statement; 224, 225; 224, 229; 225, not_operator; 225, 226; 226, attribute; 226, 227; 226, 228; 227, identifier:response; 228, identifier:ok; 229, block; 229, 230; 229, 243; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:logger; 234, identifier:warning; 235, argument_list; 235, 236; 235, 237; 235, 240; 236, string:"Response NOT OK! status_code=%s\n%s"; 237, attribute; 237, 238; 237, 239; 238, identifier:response; 239, identifier:status_code; 240, attribute; 240, 241; 240, 242; 241, identifier:response; 242, identifier:text; 243, return_statement | def load_tags(self, max_pages=30):
logger.info("loading tags")
if self.purge_first:
Tag.objects.filter(site_id=self.site_id).delete()
path = "sites/{}/tags".format(self.site_id)
params = {"number": 1000}
page = 1
response = self.get(path, params)
if not response.ok:
logger.warning("Response NOT OK! status_code=%s\n%s", response.status_code, response.text)
while response.ok and response.text and page < max_pages:
logger.info(" - page: %d", page)
api_tags = response.json().get("tags")
if not api_tags:
break
tags = []
for api_tag in api_tags:
existing_tag = Tag.objects.filter(site_id=self.site_id, wp_id=api_tag["ID"]).first()
if existing_tag:
self.update_existing_tag(existing_tag, api_tag)
else:
tags.append(self.get_new_tag(api_tag))
if tags:
Tag.objects.bulk_create(tags)
elif not self.full:
break
page += 1
params["page"] = page
response = self.get(path, params)
if not response.ok:
logger.warning("Response NOT OK! status_code=%s\n%s", response.status_code, response.text)
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:load_authors; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:max_pages; 7, integer:10; 8, block; 8, 9; 8, 16; 8, 38; 8, 49; 8, 56; 8, 60; 8, 70; 8, 89; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:logger; 13, identifier:info; 14, argument_list; 14, 15; 15, string:"loading authors"; 16, if_statement; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:purge_first; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 37; 23, attribute; 23, 24; 23, 36; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:Author; 28, identifier:objects; 29, identifier:filter; 30, argument_list; 30, 31; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:site_id; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:site_id; 36, identifier:delete; 37, argument_list; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:path; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, string:"sites/{}/users"; 44, identifier:format; 45, argument_list; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:site_id; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:params; 52, dictionary; 52, 53; 53, pair; 53, 54; 53, 55; 54, string:"number"; 55, integer:100; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:page; 59, integer:1; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:response; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:get; 67, argument_list; 67, 68; 67, 69; 68, identifier:path; 69, identifier:params; 70, if_statement; 70, 71; 70, 75; 71, not_operator; 71, 72; 72, attribute; 72, 73; 72, 74; 73, identifier:response; 74, identifier:ok; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:logger; 80, identifier:warning; 81, argument_list; 81, 82; 81, 83; 81, 86; 82, string:"Response NOT OK! status_code=%s\n%s"; 83, attribute; 83, 84; 83, 85; 84, identifier:response; 85, identifier:status_code; 86, attribute; 86, 87; 86, 88; 87, identifier:response; 88, identifier:text; 89, while_statement; 89, 90; 89, 101; 90, boolean_operator:and; 90, 91; 90, 98; 91, boolean_operator:and; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:response; 94, identifier:ok; 95, attribute; 95, 96; 95, 97; 96, identifier:response; 97, identifier:text; 98, comparison_operator:<; 98, 99; 98, 100; 99, identifier:page; 100, identifier:max_pages; 101, block; 101, 102; 101, 110; 101, 123; 101, 128; 101, 132; 101, 185; 101, 204; 101, 212; 101, 216; 101, 226; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:logger; 106, identifier:info; 107, argument_list; 107, 108; 107, 109; 108, string:" - page: %d"; 109, identifier:page; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:api_users; 113, call; 113, 114; 113, 121; 114, attribute; 114, 115; 114, 120; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:response; 118, identifier:json; 119, argument_list; 120, identifier:get; 121, argument_list; 121, 122; 122, string:"users"; 123, if_statement; 123, 124; 123, 126; 124, not_operator; 124, 125; 125, identifier:api_users; 126, block; 126, 127; 127, break_statement; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:authors; 131, list:[]; 132, for_statement; 132, 133; 132, 134; 132, 135; 133, identifier:api_author; 134, identifier:api_users; 135, block; 135, 136; 135, 160; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:existing_author; 139, call; 139, 140; 139, 159; 140, attribute; 140, 141; 140, 158; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:Author; 145, identifier:objects; 146, identifier:filter; 147, argument_list; 147, 148; 147, 153; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:site_id; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:site_id; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:wp_id; 155, subscript; 155, 156; 155, 157; 156, identifier:api_author; 157, string:"ID"; 158, identifier:first; 159, argument_list; 160, if_statement; 160, 161; 160, 162; 160, 171; 161, identifier:existing_author; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:update_existing_author; 168, argument_list; 168, 169; 168, 170; 169, identifier:existing_author; 170, identifier:api_author; 171, else_clause; 171, 172; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:authors; 177, identifier:append; 178, argument_list; 178, 179; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:get_new_author; 183, argument_list; 183, 184; 184, identifier:api_author; 185, if_statement; 185, 186; 185, 187; 185, 197; 186, identifier:authors; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 195; 190, attribute; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:Author; 193, identifier:objects; 194, identifier:bulk_create; 195, argument_list; 195, 196; 196, identifier:authors; 197, elif_clause; 197, 198; 197, 202; 198, not_operator; 198, 199; 199, attribute; 199, 200; 199, 201; 200, identifier:self; 201, identifier:full; 202, block; 202, 203; 203, break_statement; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 209; 206, subscript; 206, 207; 206, 208; 207, identifier:params; 208, string:"offset"; 209, binary_operator:*; 209, 210; 209, 211; 210, identifier:page; 211, integer:100; 212, expression_statement; 212, 213; 213, augmented_assignment:+=; 213, 214; 213, 215; 214, identifier:page; 215, integer:1; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:response; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:self; 222, identifier:get; 223, argument_list; 223, 224; 223, 225; 224, identifier:path; 225, identifier:params; 226, if_statement; 226, 227; 226, 231; 227, not_operator; 227, 228; 228, attribute; 228, 229; 228, 230; 229, identifier:response; 230, identifier:ok; 231, block; 231, 232; 231, 245; 232, expression_statement; 232, 233; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:logger; 236, identifier:warning; 237, argument_list; 237, 238; 237, 239; 237, 242; 238, string:"Response NOT OK! status_code=%s\n%s"; 239, attribute; 239, 240; 239, 241; 240, identifier:response; 241, identifier:status_code; 242, attribute; 242, 243; 242, 244; 243, identifier:response; 244, identifier:text; 245, return_statement | def load_authors(self, max_pages=10):
logger.info("loading authors")
if self.purge_first:
Author.objects.filter(site_id=self.site_id).delete()
path = "sites/{}/users".format(self.site_id)
params = {"number": 100}
page = 1
response = self.get(path, params)
if not response.ok:
logger.warning("Response NOT OK! status_code=%s\n%s", response.status_code, response.text)
while response.ok and response.text and page < max_pages:
logger.info(" - page: %d", page)
api_users = response.json().get("users")
if not api_users:
break
authors = []
for api_author in api_users:
existing_author = Author.objects.filter(site_id=self.site_id, wp_id=api_author["ID"]).first()
if existing_author:
self.update_existing_author(existing_author, api_author)
else:
authors.append(self.get_new_author(api_author))
if authors:
Author.objects.bulk_create(authors)
elif not self.full:
break
params["offset"] = page * 100
page += 1
response = self.get(path, params)
if not response.ok:
logger.warning("Response NOT OK! status_code=%s\n%s", response.status_code, response.text)
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:load_media; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:max_pages; 7, integer:150; 8, block; 8, 9; 8, 16; 8, 48; 8, 59; 8, 66; 8, 73; 8, 77; 8, 87; 8, 106; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:logger; 13, identifier:info; 14, argument_list; 14, 15; 15, string:"loading media"; 16, if_statement; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:purge_first; 20, block; 20, 21; 20, 31; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:logger; 25, identifier:warning; 26, argument_list; 26, 27; 26, 28; 27, string:"purging ALL media from site %s"; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:site_id; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 47; 33, attribute; 33, 34; 33, 46; 34, call; 34, 35; 34, 40; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:Media; 38, identifier:objects; 39, identifier:filter; 40, argument_list; 40, 41; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:site_id; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:site_id; 46, identifier:delete; 47, argument_list; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:path; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, string:"sites/{}/media"; 54, identifier:format; 55, argument_list; 55, 56; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:site_id; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:params; 62, dictionary; 62, 63; 63, pair; 63, 64; 63, 65; 64, string:"number"; 65, integer:100; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:set_media_params_after; 71, argument_list; 71, 72; 72, identifier:params; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:page; 76, integer:1; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:response; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:get; 84, argument_list; 84, 85; 84, 86; 85, identifier:path; 86, identifier:params; 87, if_statement; 87, 88; 87, 92; 88, not_operator; 88, 89; 89, attribute; 89, 90; 89, 91; 90, identifier:response; 91, identifier:ok; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:logger; 97, identifier:warning; 98, argument_list; 98, 99; 98, 100; 98, 103; 99, string:"Response NOT OK! status_code=%s\n%s"; 100, attribute; 100, 101; 100, 102; 101, identifier:response; 102, identifier:status_code; 103, attribute; 103, 104; 103, 105; 104, identifier:response; 105, identifier:text; 106, while_statement; 106, 107; 106, 118; 107, boolean_operator:and; 107, 108; 107, 115; 108, boolean_operator:and; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:response; 111, identifier:ok; 112, attribute; 112, 113; 112, 114; 113, identifier:response; 114, identifier:text; 115, comparison_operator:<; 115, 116; 115, 117; 116, identifier:page; 117, identifier:max_pages; 118, block; 118, 119; 118, 127; 118, 140; 118, 145; 118, 149; 118, 209; 118, 221; 118, 225; 118, 231; 118, 241; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:logger; 123, identifier:info; 124, argument_list; 124, 125; 124, 126; 125, string:" - page: %d"; 126, identifier:page; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:api_medias; 130, call; 130, 131; 130, 138; 131, attribute; 131, 132; 131, 137; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:response; 135, identifier:json; 136, argument_list; 137, identifier:get; 138, argument_list; 138, 139; 139, string:"media"; 140, if_statement; 140, 141; 140, 143; 141, not_operator; 141, 142; 142, identifier:api_medias; 143, block; 143, 144; 144, break_statement; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:medias; 148, list:[]; 149, for_statement; 149, 150; 149, 151; 149, 152; 150, identifier:api_media; 151, identifier:api_medias; 152, block; 152, 153; 153, if_statement; 153, 154; 153, 159; 154, comparison_operator:!=; 154, 155; 154, 158; 155, subscript; 155, 156; 155, 157; 156, identifier:api_media; 157, string:"post_ID"; 158, integer:0; 159, block; 159, 160; 159, 184; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:existing_media; 163, call; 163, 164; 163, 183; 164, attribute; 164, 165; 164, 182; 165, call; 165, 166; 165, 171; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:Media; 169, identifier:objects; 170, identifier:filter; 171, argument_list; 171, 172; 171, 177; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:site_id; 174, attribute; 174, 175; 174, 176; 175, identifier:self; 176, identifier:site_id; 177, keyword_argument; 177, 178; 177, 179; 178, identifier:wp_id; 179, subscript; 179, 180; 179, 181; 180, identifier:api_media; 181, string:"ID"; 182, identifier:first; 183, argument_list; 184, if_statement; 184, 185; 184, 186; 184, 195; 185, identifier:existing_media; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:update_existing_media; 192, argument_list; 192, 193; 192, 194; 193, identifier:existing_media; 194, identifier:api_media; 195, else_clause; 195, 196; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:medias; 201, identifier:append; 202, argument_list; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:self; 206, identifier:get_new_media; 207, argument_list; 207, 208; 208, identifier:api_media; 209, if_statement; 209, 210; 209, 211; 210, identifier:medias; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, call; 213, 214; 213, 219; 214, attribute; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:Media; 217, identifier:objects; 218, identifier:bulk_create; 219, argument_list; 219, 220; 220, identifier:medias; 221, expression_statement; 221, 222; 222, augmented_assignment:+=; 222, 223; 222, 224; 223, identifier:page; 224, integer:1; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 230; 227, subscript; 227, 228; 227, 229; 228, identifier:params; 229, string:"page"; 230, identifier:page; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:response; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:self; 237, identifier:get; 238, argument_list; 238, 239; 238, 240; 239, identifier:path; 240, identifier:params; 241, if_statement; 241, 242; 241, 246; 242, not_operator; 242, 243; 243, attribute; 243, 244; 243, 245; 244, identifier:response; 245, identifier:ok; 246, block; 246, 247; 246, 260; 247, expression_statement; 247, 248; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:logger; 251, identifier:warning; 252, argument_list; 252, 253; 252, 254; 252, 257; 253, string:"Response NOT OK! status_code=%s\n%s"; 254, attribute; 254, 255; 254, 256; 255, identifier:response; 256, identifier:status_code; 257, attribute; 257, 258; 257, 259; 258, identifier:response; 259, identifier:text; 260, return_statement | def load_media(self, max_pages=150):
logger.info("loading media")
if self.purge_first:
logger.warning("purging ALL media from site %s", self.site_id)
Media.objects.filter(site_id=self.site_id).delete()
path = "sites/{}/media".format(self.site_id)
params = {"number": 100}
self.set_media_params_after(params)
page = 1
response = self.get(path, params)
if not response.ok:
logger.warning("Response NOT OK! status_code=%s\n%s", response.status_code, response.text)
while response.ok and response.text and page < max_pages:
logger.info(" - page: %d", page)
api_medias = response.json().get("media")
if not api_medias:
break
medias = []
for api_media in api_medias:
if api_media["post_ID"] != 0:
existing_media = Media.objects.filter(site_id=self.site_id, wp_id=api_media["ID"]).first()
if existing_media:
self.update_existing_media(existing_media, api_media)
else:
medias.append(self.get_new_media(api_media))
if medias:
Media.objects.bulk_create(medias)
page += 1
params["page"] = page
response = self.get(path, params)
if not response.ok:
logger.warning("Response NOT OK! status_code=%s\n%s", response.status_code, response.text)
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:load_wp_post; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:self; 5, identifier:api_post; 6, default_parameter; 6, 7; 6, 8; 7, identifier:bulk_mode; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:post_categories; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:post_tags; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:post_media_attachments; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:posts; 20, None; 21, block; 21, 22; 21, 31; 21, 40; 21, 49; 21, 58; 21, 62; 21, 84; 21, 93; 21, 102; 21, 111; 21, 135; 21, 165; 22, if_statement; 22, 23; 22, 26; 23, comparison_operator:is; 23, 24; 23, 25; 24, identifier:post_categories; 25, None; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:post_categories; 30, dictionary; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:post_tags; 34, None; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:post_tags; 39, dictionary; 40, if_statement; 40, 41; 40, 44; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:post_media_attachments; 43, None; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:post_media_attachments; 48, dictionary; 49, if_statement; 49, 50; 49, 53; 50, comparison_operator:is; 50, 51; 50, 52; 51, identifier:posts; 52, None; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:posts; 57, list:[]; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:author; 61, None; 62, if_statement; 62, 63; 62, 71; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:api_post; 67, string:"author"; 68, identifier:get; 69, argument_list; 69, 70; 70, string:"ID"; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:author; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:process_post_author; 79, argument_list; 79, 80; 79, 81; 80, identifier:bulk_mode; 81, subscript; 81, 82; 81, 83; 82, identifier:api_post; 83, string:"author"; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:process_post_categories; 89, argument_list; 89, 90; 89, 91; 89, 92; 90, identifier:bulk_mode; 91, identifier:api_post; 92, identifier:post_categories; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:process_post_tags; 98, argument_list; 98, 99; 98, 100; 98, 101; 99, identifier:bulk_mode; 100, identifier:api_post; 101, identifier:post_tags; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:process_post_media_attachments; 107, argument_list; 107, 108; 107, 109; 107, 110; 108, identifier:bulk_mode; 109, identifier:api_post; 110, identifier:post_media_attachments; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:existing_post; 114, call; 114, 115; 114, 134; 115, attribute; 115, 116; 115, 133; 116, call; 116, 117; 116, 122; 117, attribute; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:Post; 120, identifier:objects; 121, identifier:filter; 122, argument_list; 122, 123; 122, 128; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:site_id; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:site_id; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:wp_id; 130, subscript; 130, 131; 130, 132; 131, identifier:api_post; 132, string:"ID"; 133, identifier:first; 134, argument_list; 135, if_statement; 135, 136; 135, 137; 135, 150; 136, identifier:existing_post; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:self; 142, identifier:process_existing_post; 143, argument_list; 143, 144; 143, 145; 143, 146; 143, 147; 143, 148; 143, 149; 144, identifier:existing_post; 145, identifier:api_post; 146, identifier:author; 147, identifier:post_categories; 148, identifier:post_tags; 149, identifier:post_media_attachments; 150, else_clause; 150, 151; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:process_new_post; 157, argument_list; 157, 158; 157, 159; 157, 160; 157, 161; 157, 162; 157, 163; 157, 164; 158, identifier:bulk_mode; 159, identifier:api_post; 160, identifier:posts; 161, identifier:author; 162, identifier:post_categories; 163, identifier:post_tags; 164, identifier:post_media_attachments; 165, if_statement; 165, 166; 165, 171; 166, comparison_operator:==; 166, 167; 166, 170; 167, subscript; 167, 168; 167, 169; 168, identifier:api_post; 169, string:"type"; 170, string:"post"; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:self; 176, identifier:sync_deleted_attachments; 177, argument_list; 177, 178; 178, identifier:api_post | def load_wp_post(self, api_post, bulk_mode=True, post_categories=None, post_tags=None, post_media_attachments=None, posts=None):
if post_categories is None:
post_categories = {}
if post_tags is None:
post_tags = {}
if post_media_attachments is None:
post_media_attachments = {}
if posts is None:
posts = []
author = None
if api_post["author"].get("ID"):
author = self.process_post_author(bulk_mode, api_post["author"])
self.process_post_categories(bulk_mode, api_post, post_categories)
self.process_post_tags(bulk_mode, api_post, post_tags)
self.process_post_media_attachments(bulk_mode, api_post, post_media_attachments)
existing_post = Post.objects.filter(site_id=self.site_id, wp_id=api_post["ID"]).first()
if existing_post:
self.process_existing_post(existing_post, api_post, author, post_categories, post_tags, post_media_attachments)
else:
self.process_new_post(bulk_mode, api_post, posts, author, post_categories, post_tags, post_media_attachments)
if api_post["type"] == "post":
self.sync_deleted_attachments(api_post) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sync_deleted_attachments; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:api_post; 6, block; 6, 7; 6, 46; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:existing_IDs; 10, call; 10, 11; 10, 12; 11, identifier:set; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 41; 14, attribute; 14, 15; 14, 40; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:Post; 19, identifier:objects; 20, identifier:filter; 21, argument_list; 21, 22; 21, 27; 21, 30; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:site_id; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:site_id; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:post_type; 29, string:"attachment"; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:parent__icontains; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, string:'"ID":{}'; 35, identifier:format; 36, argument_list; 36, 37; 37, subscript; 37, 38; 37, 39; 38, identifier:api_post; 39, string:"ID"; 40, identifier:values_list; 41, argument_list; 41, 42; 41, 43; 42, string:"wp_id"; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:flat; 45, True; 46, if_statement; 46, 47; 46, 48; 47, identifier:existing_IDs; 48, block; 48, 49; 48, 55; 48, 66; 48, 84; 48, 88; 48, 98; 48, 117; 48, 221; 48, 227; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:api_IDs; 52, call; 52, 53; 52, 54; 53, identifier:set; 54, argument_list; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:path; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, string:"sites/{}/posts/"; 61, identifier:format; 62, argument_list; 62, 63; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:site_id; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:params; 69, dictionary; 69, 70; 69, 73; 69, 78; 69, 81; 70, pair; 70, 71; 70, 72; 71, string:"type"; 72, string:"attachment"; 73, pair; 73, 74; 73, 75; 74, string:"parent_id"; 75, subscript; 75, 76; 75, 77; 76, identifier:api_post; 77, string:"ID"; 78, pair; 78, 79; 78, 80; 79, string:"fields"; 80, string:"ID"; 81, pair; 81, 82; 81, 83; 82, string:"number"; 83, integer:100; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:page; 87, integer:1; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:response; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:get; 95, argument_list; 95, 96; 95, 97; 96, identifier:path; 97, identifier:params; 98, if_statement; 98, 99; 98, 103; 99, not_operator; 99, 100; 100, attribute; 100, 101; 100, 102; 101, identifier:response; 102, identifier:ok; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:logger; 108, identifier:warning; 109, argument_list; 109, 110; 109, 111; 109, 114; 110, string:"Response NOT OK! status_code=%s\n%s"; 111, attribute; 111, 112; 111, 113; 112, identifier:response; 113, identifier:status_code; 114, attribute; 114, 115; 114, 116; 115, identifier:response; 116, identifier:text; 117, while_statement; 117, 118; 117, 129; 118, boolean_operator:and; 118, 119; 118, 126; 119, boolean_operator:and; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:response; 122, identifier:ok; 123, attribute; 123, 124; 123, 125; 124, identifier:response; 125, identifier:text; 126, comparison_operator:<; 126, 127; 126, 128; 127, identifier:page; 128, integer:10; 129, block; 129, 130; 129, 138; 129, 148; 129, 160; 129, 164; 129, 179; 129, 191; 129, 201; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:api_json; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:response; 136, identifier:json; 137, argument_list; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:api_attachments; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:api_json; 144, identifier:get; 145, argument_list; 145, 146; 145, 147; 146, string:"posts"; 147, list:[]; 148, expression_statement; 148, 149; 149, augmented_assignment:|=; 149, 150; 149, 151; 150, identifier:api_IDs; 151, call; 151, 152; 151, 153; 152, identifier:set; 153, generator_expression; 153, 154; 153, 157; 154, subscript; 154, 155; 154, 156; 155, identifier:a; 156, string:"ID"; 157, for_in_clause; 157, 158; 157, 159; 158, identifier:a; 159, identifier:api_attachments; 160, expression_statement; 160, 161; 161, augmented_assignment:+=; 161, 162; 161, 163; 162, identifier:page; 163, integer:1; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:next_page_handle; 167, call; 167, 168; 167, 177; 168, attribute; 168, 169; 168, 176; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:api_json; 172, identifier:get; 173, argument_list; 173, 174; 173, 175; 174, string:"meta"; 175, dictionary; 176, identifier:get; 177, argument_list; 177, 178; 178, string:"next_page"; 179, if_statement; 179, 180; 179, 181; 179, 188; 180, identifier:next_page_handle; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 187; 184, subscript; 184, 185; 184, 186; 185, identifier:params; 186, string:"page_handle"; 187, identifier:next_page_handle; 188, else_clause; 188, 189; 189, block; 189, 190; 190, break_statement; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:response; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:self; 197, identifier:get; 198, argument_list; 198, 199; 198, 200; 199, identifier:path; 200, identifier:params; 201, if_statement; 201, 202; 201, 206; 202, not_operator; 202, 203; 203, attribute; 203, 204; 203, 205; 204, identifier:response; 205, identifier:ok; 206, block; 206, 207; 206, 220; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:logger; 211, identifier:warning; 212, argument_list; 212, 213; 212, 214; 212, 217; 213, string:"Response NOT OK! status_code=%s\n%s"; 214, attribute; 214, 215; 214, 216; 215, identifier:response; 216, identifier:status_code; 217, attribute; 217, 218; 217, 219; 218, identifier:response; 219, identifier:text; 220, return_statement; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:to_remove; 224, binary_operator:-; 224, 225; 224, 226; 225, identifier:existing_IDs; 226, identifier:api_IDs; 227, if_statement; 227, 228; 227, 229; 228, identifier:to_remove; 229, block; 229, 230; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 265; 232, attribute; 232, 233; 232, 264; 233, call; 233, 234; 233, 239; 234, attribute; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:Post; 237, identifier:objects; 238, identifier:filter; 239, argument_list; 239, 240; 239, 245; 239, 248; 239, 258; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:site_id; 242, attribute; 242, 243; 242, 244; 243, identifier:self; 244, identifier:site_id; 245, keyword_argument; 245, 246; 245, 247; 246, identifier:post_type; 247, string:"attachment"; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:parent__icontains; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, string:'"ID":{}'; 253, identifier:format; 254, argument_list; 254, 255; 255, subscript; 255, 256; 255, 257; 256, identifier:api_post; 257, string:"ID"; 258, keyword_argument; 258, 259; 258, 260; 259, identifier:wp_id__in; 260, call; 260, 261; 260, 262; 261, identifier:list; 262, argument_list; 262, 263; 263, identifier:to_remove; 264, identifier:delete; 265, argument_list | def sync_deleted_attachments(self, api_post):
existing_IDs = set(Post.objects.filter(site_id=self.site_id,
post_type="attachment",
parent__icontains='"ID":{}'.format(api_post["ID"]))
.values_list("wp_id", flat=True))
if existing_IDs:
api_IDs = set()
path = "sites/{}/posts/".format(self.site_id)
params = {
"type": "attachment",
"parent_id": api_post["ID"],
"fields": "ID",
"number": 100
}
page = 1
response = self.get(path, params)
if not response.ok:
logger.warning("Response NOT OK! status_code=%s\n%s", response.status_code, response.text)
while response.ok and response.text and page < 10:
api_json = response.json()
api_attachments = api_json.get("posts", [])
api_IDs |= set(a["ID"] for a in api_attachments)
page += 1
next_page_handle = api_json.get("meta", {}).get("next_page")
if next_page_handle:
params["page_handle"] = next_page_handle
else:
break
response = self.get(path, params)
if not response.ok:
logger.warning("Response NOT OK! status_code=%s\n%s", response.status_code, response.text)
return
to_remove = existing_IDs - api_IDs
if to_remove:
Post.objects.filter(site_id=self.site_id,
post_type="attachment",
parent__icontains='"ID":{}'.format(api_post["ID"]),
wp_id__in=list(to_remove)).delete() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 25; 2, function_name:http_request; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 4, identifier:self; 5, identifier:verb; 6, identifier:uri; 7, default_parameter; 7, 8; 7, 9; 8, identifier:data; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:headers; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:files; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:response_format; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:is_rdf; 21, True; 22, default_parameter; 22, 23; 22, 24; 23, identifier:stream; 24, False; 25, block; 25, 26; 25, 28; 25, 76; 25, 96; 25, 109; 25, 117; 25, 149; 25, 158; 25, 170; 26, expression_statement; 26, 27; 27, string:'''
Primary route for all HTTP requests to repository. Ability to set most parameters for requests library,
with some additional convenience parameters as well.
Args:
verb (str): HTTP verb to use for request, e.g. PUT, POST, GET, HEAD, PATCH, etc.
uri (rdflib.term.URIRef,str): input URI
data (str,file): payload of data to send for request, may be overridden in preperation of request
headers (dict): optional dictionary of headers passed directly to requests.request
files (dict): optional dictionary of files passed directly to requests.request
response_format (str): desired response format for resource's payload, e.g. 'application/rdf+xml', 'text/turtle', etc.
is_rdf (bool): if True, set Accept header based on combination of response_format and headers
stream (bool): passed directly to requests.request for stream parameter
Returns:
requests.models.Response
'''; 28, if_statement; 28, 29; 28, 30; 29, identifier:is_rdf; 30, block; 30, 31; 30, 33; 31, expression_statement; 31, 32; 32, string:'''
Acceptable content negotiated response formats include:
application/ld+json (discouraged, if not prohibited, as it drops prefixes used in repository)
application/n-triples
application/rdf+xml
text/n3 (or text/rdf+n3)
text/plain
text/turtle (or application/x-turtle)
'''; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:==; 34, 35; 34, 36; 35, identifier:verb; 36, string:'GET'; 37, block; 37, 38; 37, 50; 38, if_statement; 38, 39; 38, 41; 39, not_operator; 39, 40; 40, identifier:response_format; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:response_format; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:repo; 49, identifier:default_serialization; 50, if_statement; 50, 51; 50, 60; 50, 67; 51, boolean_operator:and; 51, 52; 51, 53; 52, identifier:headers; 53, comparison_operator:not; 53, 54; 53, 55; 54, string:'Accept'; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:headers; 58, identifier:keys; 59, argument_list; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:headers; 65, string:'Accept'; 66, identifier:response_format; 67, else_clause; 67, 68; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:headers; 72, dictionary; 72, 73; 73, pair; 73, 74; 73, 75; 74, string:'Accept'; 75, identifier:response_format; 76, if_statement; 76, 77; 76, 87; 77, comparison_operator:==; 77, 78; 77, 82; 78, call; 78, 79; 78, 80; 79, identifier:type; 80, argument_list; 80, 81; 81, identifier:uri; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:rdflib; 85, identifier:term; 86, identifier:URIRef; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:uri; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:uri; 94, identifier:toPython; 95, argument_list; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:logger; 100, identifier:debug; 101, argument_list; 101, 102; 102, binary_operator:%; 102, 103; 102, 104; 103, string:"%s request for %s, format %s, headers %s"; 104, tuple; 104, 105; 104, 106; 104, 107; 104, 108; 105, identifier:verb; 106, identifier:uri; 107, identifier:response_format; 108, identifier:headers; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:session; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:requests; 115, identifier:Session; 116, argument_list; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:request; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:requests; 123, identifier:Request; 124, argument_list; 124, 125; 124, 126; 124, 127; 124, 140; 124, 143; 124, 146; 125, identifier:verb; 126, identifier:uri; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:auth; 129, tuple; 129, 130; 129, 135; 130, attribute; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:repo; 134, identifier:username; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:repo; 139, identifier:password; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:data; 142, identifier:data; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:headers; 145, identifier:headers; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:files; 148, identifier:files; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:prepped_request; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:session; 155, identifier:prepare_request; 156, argument_list; 156, 157; 157, identifier:request; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:response; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:session; 164, identifier:send; 165, argument_list; 165, 166; 165, 167; 166, identifier:prepped_request; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:stream; 169, identifier:stream; 170, return_statement; 170, 171; 171, identifier:response | def http_request(self,
verb,
uri,
data=None,
headers=None,
files=None,
response_format=None,
is_rdf = True,
stream = False
):
'''
Primary route for all HTTP requests to repository. Ability to set most parameters for requests library,
with some additional convenience parameters as well.
Args:
verb (str): HTTP verb to use for request, e.g. PUT, POST, GET, HEAD, PATCH, etc.
uri (rdflib.term.URIRef,str): input URI
data (str,file): payload of data to send for request, may be overridden in preperation of request
headers (dict): optional dictionary of headers passed directly to requests.request
files (dict): optional dictionary of files passed directly to requests.request
response_format (str): desired response format for resource's payload, e.g. 'application/rdf+xml', 'text/turtle', etc.
is_rdf (bool): if True, set Accept header based on combination of response_format and headers
stream (bool): passed directly to requests.request for stream parameter
Returns:
requests.models.Response
'''
if is_rdf:
'''
Acceptable content negotiated response formats include:
application/ld+json (discouraged, if not prohibited, as it drops prefixes used in repository)
application/n-triples
application/rdf+xml
text/n3 (or text/rdf+n3)
text/plain
text/turtle (or application/x-turtle)
'''
if verb == 'GET':
if not response_format:
response_format = self.repo.default_serialization
if headers and 'Accept' not in headers.keys():
headers['Accept'] = response_format
else:
headers = {'Accept':response_format}
if type(uri) == rdflib.term.URIRef:
uri = uri.toPython()
logger.debug("%s request for %s, format %s, headers %s" %
(verb, uri, response_format, headers))
session = requests.Session()
request = requests.Request(verb, uri, auth=(self.repo.username, self.repo.password), data=data, headers=headers, files=files)
prepped_request = session.prepare_request(request)
response = session.send(prepped_request,
stream=stream,
)
return response |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:create; 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:specify_uri; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ignore_tombstone; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:serialization_format; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:stream; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:auto_refresh; 19, None; 20, block; 20, 21; 20, 23; 21, expression_statement; 21, 22; 22, string:'''
Primary method to create resources.
Args:
specify_uri (bool): If True, uses PUT verb and sets the URI during creation. If False, uses POST and gets repository minted URI
ignore_tombstone (bool): If True, will attempt creation, if tombstone exists (409), will delete tombstone and retry
serialization_format(str): Content-Type header / mimetype that will be used to serialize self.rdf.graph, and set headers for PUT/POST requests
auto_refresh (bool): If True, refreshes resource after update. If left None, defaults to repo.default_auto_refresh
'''; 23, if_statement; 23, 24; 23, 27; 23, 33; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:exists; 27, block; 27, 28; 28, raise_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:Exception; 31, argument_list; 31, 32; 32, string:'resource exists attribute True, aborting'; 33, else_clause; 33, 34; 34, block; 34, 35; 34, 48; 34, 61; 34, 143; 34, 170; 35, if_statement; 35, 36; 35, 37; 35, 42; 36, identifier:specify_uri; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:verb; 41, string:'PUT'; 42, else_clause; 42, 43; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:verb; 47, string:'POST'; 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; 54, binary_operator:%; 54, 55; 54, 56; 55, string:'creating resource %s with verb %s'; 56, tuple; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:uri; 60, identifier:verb; 61, if_statement; 61, 62; 61, 70; 61, 87; 62, call; 62, 63; 62, 64; 63, identifier:issubclass; 64, argument_list; 64, 65; 64, 69; 65, call; 65, 66; 65, 67; 66, identifier:type; 67, argument_list; 67, 68; 68, identifier:self; 69, identifier:NonRDFSource; 70, block; 70, 71; 70, 79; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 78; 73, attribute; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:binary; 77, identifier:_prep_binary; 78, argument_list; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:data; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:binary; 86, identifier:data; 87, else_clause; 87, 88; 88, block; 88, 89; 88, 101; 88, 116; 88, 123; 88, 135; 89, if_statement; 89, 90; 89, 92; 90, not_operator; 90, 91; 91, identifier:serialization_format; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:serialization_format; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:repo; 100, identifier:default_serialization; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:data; 104, call; 104, 105; 104, 112; 105, attribute; 105, 106; 105, 111; 106, attribute; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:rdf; 110, identifier:graph; 111, identifier:serialize; 112, argument_list; 112, 113; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:format; 115, identifier:serialization_format; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:logger; 120, identifier:debug; 121, argument_list; 121, 122; 122, string:'Serialized graph used for resource creation:'; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:logger; 127, identifier:debug; 128, argument_list; 128, 129; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:data; 132, identifier:decode; 133, argument_list; 133, 134; 134, string:'utf-8'; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 142; 137, subscript; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:self; 140, identifier:headers; 141, string:'Content-Type'; 142, identifier:serialization_format; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:response; 146, call; 146, 147; 146, 154; 147, attribute; 147, 148; 147, 153; 148, attribute; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:repo; 152, identifier:api; 153, identifier:http_request; 154, argument_list; 154, 155; 154, 156; 154, 159; 154, 162; 154, 167; 155, identifier:verb; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:uri; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:data; 161, identifier:data; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:headers; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:headers; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:stream; 169, identifier:stream; 170, return_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:_handle_create; 175, argument_list; 175, 176; 175, 177; 175, 178; 176, identifier:response; 177, identifier:ignore_tombstone; 178, identifier:auto_refresh | def create(self, specify_uri=False, ignore_tombstone=False, serialization_format=None, stream=False, auto_refresh=None):
'''
Primary method to create resources.
Args:
specify_uri (bool): If True, uses PUT verb and sets the URI during creation. If False, uses POST and gets repository minted URI
ignore_tombstone (bool): If True, will attempt creation, if tombstone exists (409), will delete tombstone and retry
serialization_format(str): Content-Type header / mimetype that will be used to serialize self.rdf.graph, and set headers for PUT/POST requests
auto_refresh (bool): If True, refreshes resource after update. If left None, defaults to repo.default_auto_refresh
'''
if self.exists:
raise Exception('resource exists attribute True, aborting')
else:
if specify_uri:
verb = 'PUT'
else:
verb = 'POST'
logger.debug('creating resource %s with verb %s' % (self.uri, verb))
if issubclass(type(self),NonRDFSource):
self.binary._prep_binary()
data = self.binary.data
else:
if not serialization_format:
serialization_format = self.repo.default_serialization
data = self.rdf.graph.serialize(format=serialization_format)
logger.debug('Serialized graph used for resource creation:')
logger.debug(data.decode('utf-8'))
self.headers['Content-Type'] = serialization_format
response = self.repo.api.http_request(verb, self.uri, data=data, headers=self.headers, stream=stream)
return self._handle_create(response, ignore_tombstone, auto_refresh) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:refresh; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:refresh_binary; 7, True; 8, block; 8, 9; 8, 11; 8, 24; 8, 50; 9, expression_statement; 9, 10; 10, string:'''
Performs GET request and refreshes RDF information for resource.
Args:
None
Returns:
None
'''; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:updated_self; 14, call; 14, 15; 14, 20; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:repo; 19, identifier:get_resource; 20, argument_list; 20, 21; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:uri; 24, if_statement; 24, 25; 24, 34; 25, not_operator; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:isinstance; 28, argument_list; 28, 29; 28, 30; 29, identifier:self; 30, call; 30, 31; 30, 32; 31, identifier:type; 32, argument_list; 32, 33; 33, identifier:updated_self; 34, block; 34, 35; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:Exception; 38, argument_list; 38, 39; 39, binary_operator:%; 39, 40; 39, 41; 40, string:'Instantiated %s, but repository reports this resource is %s'; 41, tuple; 41, 42; 41, 46; 42, call; 42, 43; 42, 44; 43, identifier:type; 44, argument_list; 44, 45; 45, identifier:updated_self; 46, call; 46, 47; 46, 48; 47, identifier:type; 48, argument_list; 48, 49; 49, identifier:self; 50, if_statement; 50, 51; 50, 52; 50, 146; 51, identifier:updated_self; 52, block; 52, 53; 52, 61; 52, 73; 52, 81; 52, 89; 52, 103; 52, 111; 52, 130; 52, 143; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:status_code; 58, attribute; 58, 59; 58, 60; 59, identifier:updated_self; 60, identifier:status_code; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 68; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:rdf; 67, identifier:data; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:updated_self; 71, identifier:rdf; 72, identifier:data; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:headers; 78, attribute; 78, 79; 78, 80; 79, identifier:updated_self; 80, identifier:headers; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:exists; 86, attribute; 86, 87; 86, 88; 87, identifier:updated_self; 88, identifier:exists; 89, if_statement; 89, 90; 89, 96; 90, comparison_operator:!=; 90, 91; 90, 95; 91, call; 91, 92; 91, 93; 92, identifier:type; 93, argument_list; 93, 94; 94, identifier:self; 95, identifier:NonRDFSource; 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:_parse_graph; 102, argument_list; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:versions; 108, call; 108, 109; 108, 110; 109, identifier:SimpleNamespace; 110, argument_list; 111, if_statement; 111, 112; 111, 120; 112, boolean_operator:and; 112, 113; 112, 119; 113, comparison_operator:==; 113, 114; 113, 118; 114, call; 114, 115; 114, 116; 115, identifier:type; 116, argument_list; 116, 117; 117, identifier:updated_self; 118, identifier:NonRDFSource; 119, identifier:refresh_binary; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:binary; 127, identifier:refresh; 128, argument_list; 128, 129; 129, identifier:updated_self; 130, if_statement; 130, 131; 130, 136; 131, call; 131, 132; 131, 133; 132, identifier:hasattr; 133, argument_list; 133, 134; 133, 135; 134, identifier:self; 135, string:'_post_refresh'; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:_post_refresh; 142, argument_list; 143, delete_statement; 143, 144; 144, parenthesized_expression; 144, 145; 145, identifier:updated_self; 146, else_clause; 146, 147; 147, block; 147, 148; 147, 155; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:logger; 152, identifier:debug; 153, argument_list; 153, 154; 154, string:'resource %s not found, dumping values'; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:_empty_resource_attributes; 160, argument_list | def refresh(self, refresh_binary=True):
'''
Performs GET request and refreshes RDF information for resource.
Args:
None
Returns:
None
'''
updated_self = self.repo.get_resource(self.uri)
if not isinstance(self, type(updated_self)):
raise Exception('Instantiated %s, but repository reports this resource is %s' % (type(updated_self), type(self)) )
if updated_self:
self.status_code = updated_self.status_code
self.rdf.data = updated_self.rdf.data
self.headers = updated_self.headers
self.exists = updated_self.exists
if type(self) != NonRDFSource:
self._parse_graph()
self.versions = SimpleNamespace()
if type(updated_self) == NonRDFSource and refresh_binary:
self.binary.refresh(updated_self)
if hasattr(self,'_post_refresh'):
self._post_refresh()
del(updated_self)
else:
logger.debug('resource %s not found, dumping values')
self._empty_resource_attributes() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:update; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sparql_query_only; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:auto_refresh; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:update_binary; 13, True; 14, block; 14, 15; 14, 17; 14, 23; 14, 39; 14, 48; 14, 79; 14, 104; 14, 214; 14, 227; 14, 229; 14, 262; 15, expression_statement; 15, 16; 16, string:'''
Method to update resources in repository. Firing this method computes the difference in the local modified graph and the original one,
creates an instance of SparqlUpdate and builds a sparql query that represents these differences, and sends this as a PATCH request.
Note: send PATCH request, regardless of RDF or NonRDF, to [uri]/fcr:metadata
If the resource is NonRDF (Binary), this also method also updates the binary data.
Args:
sparql_query_only (bool): If True, returns only the sparql query string and does not perform any actual updates
auto_refresh (bool): If True, refreshes resource after update. If left None, defaults to repo.default_auto_refresh
update_binary (bool): If True, and resource is NonRDF, updates binary data as well
Returns:
(bool)
'''; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:_diff_graph; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:sq; 26, call; 26, 27; 26, 28; 27, identifier:SparqlUpdate; 28, argument_list; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:rdf; 33, identifier:prefixes; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:rdf; 38, identifier:diffs; 39, if_statement; 39, 40; 39, 41; 40, identifier:sparql_query_only; 41, block; 41, 42; 42, return_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:sq; 46, identifier:build_query; 47, argument_list; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:response; 51, call; 51, 52; 51, 59; 52, attribute; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:repo; 57, identifier:api; 58, identifier:http_request; 59, argument_list; 59, 60; 59, 61; 59, 66; 59, 73; 60, string:'PATCH'; 61, binary_operator:%; 61, 62; 61, 63; 62, string:'%s/fcr:metadata'; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:uri; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:data; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:sq; 71, identifier:build_query; 72, argument_list; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:headers; 75, dictionary; 75, 76; 76, pair; 76, 77; 76, 78; 77, string:'Content-Type'; 78, string:'application/sparql-update'; 79, if_statement; 79, 80; 79, 85; 80, comparison_operator:!=; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:response; 83, identifier:status_code; 84, integer:204; 85, block; 85, 86; 85, 95; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:logger; 90, identifier:debug; 91, argument_list; 91, 92; 92, attribute; 92, 93; 92, 94; 93, identifier:response; 94, identifier:content; 95, raise_statement; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:Exception; 98, argument_list; 98, 99; 99, binary_operator:%; 99, 100; 99, 101; 100, string:'HTTP %s, expecting 204'; 101, attribute; 101, 102; 101, 103; 102, identifier:response; 103, identifier:status_code; 104, if_statement; 104, 105; 104, 128; 105, boolean_operator:and; 105, 106; 105, 114; 106, boolean_operator:and; 106, 107; 106, 113; 107, comparison_operator:==; 107, 108; 107, 112; 108, call; 108, 109; 108, 110; 109, identifier:type; 110, argument_list; 110, 111; 111, identifier:self; 112, identifier:NonRDFSource; 113, identifier:update_binary; 114, comparison_operator:!=; 114, 115; 114, 123; 115, call; 115, 116; 115, 117; 116, identifier:type; 117, argument_list; 117, 118; 118, attribute; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:binary; 122, identifier:data; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:requests; 126, identifier:models; 127, identifier:Response; 128, block; 128, 129; 128, 137; 128, 145; 128, 174; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 136; 131, attribute; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:binary; 135, identifier:_prep_binary; 136, argument_list; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:binary_data; 140, attribute; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:binary; 144, identifier:data; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:binary_response; 148, call; 148, 149; 148, 156; 149, attribute; 149, 150; 149, 155; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:repo; 154, identifier:api; 155, identifier:http_request; 156, argument_list; 156, 157; 156, 158; 156, 161; 156, 164; 157, string:'PUT'; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:uri; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:data; 163, identifier:binary_data; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:headers; 166, dictionary; 166, 167; 167, pair; 167, 168; 167, 169; 168, string:'Content-Type'; 169, attribute; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:self; 172, identifier:binary; 173, identifier:mimetype; 174, if_statement; 174, 175; 174, 184; 175, boolean_operator:and; 175, 176; 175, 178; 176, not_operator; 176, 177; 177, identifier:auto_refresh; 178, not_operator; 178, 179; 179, attribute; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:repo; 183, identifier:default_auto_refresh; 184, block; 184, 185; 184, 192; 184, 205; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:logger; 189, identifier:debug; 190, argument_list; 190, 191; 191, string:"not refreshing resource RDF, but updated binary, so must refresh binary data"; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:updated_self; 195, call; 195, 196; 195, 201; 196, attribute; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:self; 199, identifier:repo; 200, identifier:get_resource; 201, argument_list; 201, 202; 202, attribute; 202, 203; 202, 204; 203, identifier:self; 204, identifier:uri; 205, expression_statement; 205, 206; 206, call; 206, 207; 206, 212; 207, attribute; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:self; 210, identifier:binary; 211, identifier:refresh; 212, argument_list; 212, 213; 213, identifier:updated_self; 214, if_statement; 214, 215; 214, 220; 215, call; 215, 216; 215, 217; 216, identifier:hasattr; 217, argument_list; 217, 218; 217, 219; 218, identifier:self; 219, string:'_post_update'; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:_post_update; 226, argument_list; 227, expression_statement; 227, 228; 228, string:'''
If not updating binary, pass that bool to refresh as refresh_binary flag to avoid touching binary data
'''; 229, if_statement; 229, 230; 229, 231; 229, 241; 230, identifier:auto_refresh; 231, block; 231, 232; 232, expression_statement; 232, 233; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:self; 236, identifier:refresh; 237, argument_list; 237, 238; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:refresh_binary; 240, identifier:update_binary; 241, elif_clause; 241, 242; 241, 245; 242, comparison_operator:==; 242, 243; 242, 244; 243, identifier:auto_refresh; 244, None; 245, block; 245, 246; 246, if_statement; 246, 247; 246, 252; 247, attribute; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:self; 250, identifier:repo; 251, identifier:default_auto_refresh; 252, block; 252, 253; 253, expression_statement; 253, 254; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:self; 257, identifier:refresh; 258, argument_list; 258, 259; 259, keyword_argument; 259, 260; 259, 261; 260, identifier:refresh_binary; 261, identifier:update_binary; 262, return_statement; 262, 263; 263, True | def update(self, sparql_query_only=False, auto_refresh=None, update_binary=True):
'''
Method to update resources in repository. Firing this method computes the difference in the local modified graph and the original one,
creates an instance of SparqlUpdate and builds a sparql query that represents these differences, and sends this as a PATCH request.
Note: send PATCH request, regardless of RDF or NonRDF, to [uri]/fcr:metadata
If the resource is NonRDF (Binary), this also method also updates the binary data.
Args:
sparql_query_only (bool): If True, returns only the sparql query string and does not perform any actual updates
auto_refresh (bool): If True, refreshes resource after update. If left None, defaults to repo.default_auto_refresh
update_binary (bool): If True, and resource is NonRDF, updates binary data as well
Returns:
(bool)
'''
self._diff_graph()
sq = SparqlUpdate(self.rdf.prefixes, self.rdf.diffs)
if sparql_query_only:
return sq.build_query()
response = self.repo.api.http_request(
'PATCH',
'%s/fcr:metadata' % self.uri,
data=sq.build_query(),
headers={'Content-Type':'application/sparql-update'})
if response.status_code != 204:
logger.debug(response.content)
raise Exception('HTTP %s, expecting 204' % response.status_code)
if type(self) == NonRDFSource and update_binary and type(self.binary.data) != requests.models.Response:
self.binary._prep_binary()
binary_data = self.binary.data
binary_response = self.repo.api.http_request(
'PUT',
self.uri,
data=binary_data,
headers={'Content-Type':self.binary.mimetype})
if not auto_refresh and not self.repo.default_auto_refresh:
logger.debug("not refreshing resource RDF, but updated binary, so must refresh binary data")
updated_self = self.repo.get_resource(self.uri)
self.binary.refresh(updated_self)
if hasattr(self,'_post_update'):
self._post_update()
'''
If not updating binary, pass that bool to refresh as refresh_binary flag to avoid touching binary data
'''
if auto_refresh:
self.refresh(refresh_binary=update_binary)
elif auto_refresh == None:
if self.repo.default_auto_refresh:
self.refresh(refresh_binary=update_binary)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:update_gunicorns; 3, parameters; 4, block; 4, 5; 4, 7; 4, 11; 4, 22; 4, 26; 4, 45; 4, 66; 4, 79; 4, 88; 4, 97; 4, 241; 4, 265; 4, 284; 5, global_statement; 5, 6; 6, identifier:tick; 7, expression_statement; 7, 8; 8, augmented_assignment:+=; 8, 9; 8, 10; 9, identifier:tick; 10, integer:1; 11, if_statement; 11, 12; 11, 20; 12, comparison_operator:!=; 12, 13; 12, 19; 13, binary_operator:%; 13, 14; 13, 18; 14, parenthesized_expression; 14, 15; 15, binary_operator:*; 15, 16; 15, 17; 16, identifier:tick; 17, identifier:screen_delay; 18, identifier:ps_delay; 19, integer:0; 20, block; 20, 21; 21, return_statement; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:tick; 25, integer:0; 26, for_statement; 26, 27; 26, 28; 26, 29; 27, identifier:pid; 28, identifier:gunicorns; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, subscript; 33, 34; 33, 35; 34, identifier:gunicorns; 35, identifier:pid; 36, identifier:update; 37, argument_list; 37, 38; 38, dictionary; 38, 39; 38, 42; 39, pair; 39, 40; 39, 41; 40, string:"workers"; 41, integer:0; 42, pair; 42, 43; 42, 44; 43, string:"mem"; 44, integer:0; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:ps; 48, call; 48, 49; 48, 64; 49, attribute; 49, 50; 49, 63; 50, subscript; 50, 51; 50, 62; 51, call; 51, 52; 51, 61; 52, attribute; 52, 53; 52, 60; 53, call; 53, 54; 53, 55; 54, identifier:Popen; 55, argument_list; 55, 56; 55, 57; 56, identifier:PS_ARGS; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:stdout; 59, identifier:PIPE; 60, identifier:communicate; 61, argument_list; 62, integer:0; 63, identifier:split; 64, argument_list; 64, 65; 65, string:"\n"; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:headings; 69, call; 69, 70; 69, 78; 70, attribute; 70, 71; 70, 77; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:ps; 74, identifier:pop; 75, argument_list; 75, 76; 76, integer:0; 77, identifier:split; 78, argument_list; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:name_col; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:headings; 85, identifier:index; 86, argument_list; 86, 87; 87, identifier:cmd_heading; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:num_cols; 91, binary_operator:-; 91, 92; 91, 96; 92, call; 92, 93; 92, 94; 93, identifier:len; 94, argument_list; 94, 95; 95, identifier:headings; 96, integer:1; 97, for_statement; 97, 98; 97, 99; 97, 100; 98, identifier:row; 99, identifier:ps; 100, block; 100, 101; 100, 111; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:cols; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:row; 107, identifier:split; 108, argument_list; 108, 109; 108, 110; 109, None; 110, identifier:num_cols; 111, if_statement; 111, 112; 111, 119; 112, boolean_operator:and; 112, 113; 112, 114; 113, identifier:cols; 114, comparison_operator:in; 114, 115; 114, 116; 115, string:"gunicorn: "; 116, subscript; 116, 117; 116, 118; 117, identifier:cols; 118, identifier:name_col; 119, block; 119, 120; 119, 137; 119, 164; 119, 212; 119, 230; 120, if_statement; 120, 121; 120, 126; 120, 131; 121, comparison_operator:in; 121, 122; 121, 123; 122, string:"gunicorn: worker"; 123, subscript; 123, 124; 123, 125; 124, identifier:cols; 125, identifier:name_col; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:is_worker; 130, True; 131, else_clause; 131, 132; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:is_worker; 136, False; 137, if_statement; 137, 138; 137, 139; 137, 151; 138, identifier:is_worker; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:pid; 143, subscript; 143, 144; 143, 145; 144, identifier:cols; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:headings; 148, identifier:index; 149, argument_list; 149, 150; 150, string:"PPID"; 151, else_clause; 151, 152; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:pid; 156, subscript; 156, 157; 156, 158; 157, identifier:cols; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:headings; 161, identifier:index; 162, argument_list; 162, 163; 163, string:"PID"; 164, if_statement; 164, 165; 164, 168; 165, comparison_operator:not; 165, 166; 165, 167; 166, identifier:pid; 167, identifier:gunicorns; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 174; 171, subscript; 171, 172; 171, 173; 172, identifier:gunicorns; 173, identifier:pid; 174, dictionary; 174, 175; 174, 178; 174, 181; 174, 184; 175, pair; 175, 176; 175, 177; 176, string:"workers"; 177, integer:0; 178, pair; 178, 179; 178, 180; 179, string:"mem"; 180, integer:0; 181, pair; 181, 182; 181, 183; 182, string:"port"; 183, None; 184, pair; 184, 185; 184, 186; 185, string:"name"; 186, subscript; 186, 187; 186, 208; 187, call; 187, 188; 187, 205; 188, attribute; 188, 189; 188, 204; 189, subscript; 189, 190; 189, 203; 190, call; 190, 191; 190, 200; 191, attribute; 191, 192; 191, 199; 192, call; 192, 193; 192, 198; 193, attribute; 193, 194; 193, 197; 194, subscript; 194, 195; 194, 196; 195, identifier:cols; 196, identifier:name_col; 197, identifier:strip; 198, argument_list; 199, identifier:split; 200, argument_list; 200, 201; 200, 202; 201, string:"["; 202, integer:1; 203, integer:1; 204, identifier:split; 205, argument_list; 205, 206; 205, 207; 206, string:"]"; 207, integer:1; 208, slice; 208, 209; 208, 210; 209, colon; 210, unary_operator:-; 210, 211; 211, integer:1; 212, expression_statement; 212, 213; 213, augmented_assignment:+=; 213, 214; 213, 219; 214, subscript; 214, 215; 214, 218; 215, subscript; 215, 216; 215, 217; 216, identifier:gunicorns; 217, identifier:pid; 218, string:"mem"; 219, call; 219, 220; 219, 221; 220, identifier:int; 221, argument_list; 221, 222; 222, subscript; 222, 223; 222, 224; 223, identifier:cols; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:headings; 227, identifier:index; 228, argument_list; 228, 229; 229, string:"RSS"; 230, if_statement; 230, 231; 230, 232; 231, identifier:is_worker; 232, block; 232, 233; 233, expression_statement; 233, 234; 234, augmented_assignment:+=; 234, 235; 234, 240; 235, subscript; 235, 236; 235, 239; 236, subscript; 236, 237; 236, 238; 237, identifier:gunicorns; 238, identifier:pid; 239, string:"workers"; 240, integer:1; 241, for_statement; 241, 242; 241, 243; 241, 251; 242, identifier:pid; 243, subscript; 243, 244; 243, 249; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:gunicorns; 247, identifier:keys; 248, argument_list; 249, slice; 249, 250; 250, colon; 251, block; 251, 252; 252, if_statement; 252, 253; 252, 260; 253, comparison_operator:==; 253, 254; 253, 259; 254, subscript; 254, 255; 254, 258; 255, subscript; 255, 256; 255, 257; 256, identifier:gunicorns; 257, identifier:pid; 258, string:"workers"; 259, integer:0; 260, block; 260, 261; 261, delete_statement; 261, 262; 262, subscript; 262, 263; 262, 264; 263, identifier:gunicorns; 264, identifier:pid; 265, if_statement; 265, 266; 265, 282; 266, not_operator; 266, 267; 267, list_comprehension; 267, 268; 267, 269; 267, 276; 268, identifier:g; 269, for_in_clause; 269, 270; 269, 271; 270, identifier:g; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:gunicorns; 274, identifier:values; 275, argument_list; 276, if_clause; 276, 277; 277, comparison_operator:is; 277, 278; 277, 281; 278, subscript; 278, 279; 278, 280; 279, identifier:g; 280, string:"port"; 281, None; 282, block; 282, 283; 283, return_statement; 284, for_statement; 284, 285; 284, 288; 284, 296; 285, tuple_pattern; 285, 286; 285, 287; 286, identifier:pid; 287, identifier:port; 288, call; 288, 289; 288, 290; 289, identifier:ports_for_pids; 290, argument_list; 290, 291; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:gunicorns; 294, identifier:keys; 295, argument_list; 296, block; 296, 297; 297, if_statement; 297, 298; 297, 301; 298, comparison_operator:in; 298, 299; 298, 300; 299, identifier:pid; 300, identifier:gunicorns; 301, block; 301, 302; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 309; 304, subscript; 304, 305; 304, 308; 305, subscript; 305, 306; 305, 307; 306, identifier:gunicorns; 307, identifier:pid; 308, string:"port"; 309, identifier:port | def update_gunicorns():
global tick
tick += 1
if (tick * screen_delay) % ps_delay != 0:
return
tick = 0
for pid in gunicorns:
gunicorns[pid].update({"workers": 0, "mem": 0})
ps = Popen(PS_ARGS, stdout=PIPE).communicate()[0].split("\n")
headings = ps.pop(0).split()
name_col = headings.index(cmd_heading)
num_cols = len(headings) - 1
for row in ps:
cols = row.split(None, num_cols)
if cols and "gunicorn: " in cols[name_col]:
if "gunicorn: worker" in cols[name_col]:
is_worker = True
else:
is_worker = False
if is_worker:
pid = cols[headings.index("PPID")]
else:
pid = cols[headings.index("PID")]
if pid not in gunicorns:
gunicorns[pid] = {"workers": 0, "mem": 0, "port": None, "name":
cols[name_col].strip().split("[",1)[1].split("]",1)[:-1]}
gunicorns[pid]["mem"] += int(cols[headings.index("RSS")])
if is_worker:
gunicorns[pid]["workers"] += 1
for pid in gunicorns.keys()[:]:
if gunicorns[pid]["workers"] == 0:
del gunicorns[pid]
if not [g for g in gunicorns.values() if g["port"] is None]:
return
for (pid, port) in ports_for_pids(gunicorns.keys()):
if pid in gunicorns:
gunicorns[pid]["port"] = port |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:handle_keypress; 3, parameters; 3, 4; 4, identifier:screen; 5, block; 5, 6; 5, 8; 5, 25; 6, global_statement; 6, 7; 7, identifier:selected_pid; 8, try_statement; 8, 9; 8, 22; 9, block; 9, 10; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:key; 13, call; 13, 14; 13, 21; 14, attribute; 14, 15; 14, 20; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:screen; 18, identifier:getkey; 19, argument_list; 20, identifier:upper; 21, argument_list; 22, except_clause; 22, 23; 23, block; 23, 24; 24, return_statement; 25, if_statement; 25, 26; 25, 31; 25, 36; 25, 50; 25, 75; 25, 109; 25, 133; 25, 168; 25, 193; 26, comparison_operator:in; 26, 27; 26, 28; 27, identifier:key; 28, tuple; 28, 29; 28, 30; 29, string:"KEY_DOWN"; 30, string:"J"; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:move_selection; 35, argument_list; 36, elif_clause; 36, 37; 36, 42; 37, comparison_operator:in; 37, 38; 37, 39; 38, identifier:key; 39, tuple; 39, 40; 39, 41; 40, string:"KEY_UP"; 41, string:"K"; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:move_selection; 46, argument_list; 46, 47; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:reverse; 49, True; 50, elif_clause; 50, 51; 50, 56; 51, comparison_operator:in; 51, 52; 51, 53; 52, identifier:key; 53, tuple; 53, 54; 53, 55; 54, string:"A"; 55, string:"+"; 56, block; 56, 57; 56, 62; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:send_signal; 60, argument_list; 60, 61; 61, string:"TTIN"; 62, if_statement; 62, 63; 62, 66; 63, comparison_operator:in; 63, 64; 63, 65; 64, identifier:selected_pid; 65, identifier:gunicorns; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 74; 69, subscript; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:gunicorns; 72, identifier:selected_pid; 73, string:"workers"; 74, integer:0; 75, elif_clause; 75, 76; 75, 81; 76, comparison_operator:in; 76, 77; 76, 78; 77, identifier:key; 78, tuple; 78, 79; 78, 80; 79, string:"W"; 80, string:"-"; 81, block; 81, 82; 82, if_statement; 82, 83; 82, 86; 83, comparison_operator:in; 83, 84; 83, 85; 84, identifier:selected_pid; 85, identifier:gunicorns; 86, block; 86, 87; 87, if_statement; 87, 88; 87, 95; 88, comparison_operator:!=; 88, 89; 88, 94; 89, subscript; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:gunicorns; 92, identifier:selected_pid; 93, string:"workers"; 94, integer:1; 95, block; 95, 96; 95, 101; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:send_signal; 99, argument_list; 99, 100; 100, string:"TTOU"; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 108; 103, subscript; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:gunicorns; 106, identifier:selected_pid; 107, string:"workers"; 108, integer:0; 109, elif_clause; 109, 110; 109, 114; 110, comparison_operator:in; 110, 111; 110, 112; 111, identifier:key; 112, tuple; 112, 113; 113, string:"R"; 114, block; 114, 115; 115, if_statement; 115, 116; 115, 119; 116, comparison_operator:in; 116, 117; 116, 118; 117, identifier:selected_pid; 118, identifier:gunicorns; 119, block; 119, 120; 119, 125; 119, 129; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:send_signal; 123, argument_list; 123, 124; 124, string:"HUP"; 125, delete_statement; 125, 126; 126, subscript; 126, 127; 126, 128; 127, identifier:gunicorns; 128, identifier:selected_pid; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:selected_pid; 132, None; 133, elif_clause; 133, 134; 133, 138; 134, comparison_operator:in; 134, 135; 134, 136; 135, identifier:key; 136, tuple; 136, 137; 137, string:"T"; 138, block; 138, 139; 139, for_statement; 139, 140; 139, 141; 139, 150; 140, identifier:pid; 141, call; 141, 142; 141, 149; 142, attribute; 142, 143; 142, 148; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:gunicorns; 146, identifier:copy; 147, argument_list; 148, identifier:iterkeys; 149, argument_list; 150, block; 150, 151; 150, 155; 150, 160; 150, 164; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:selected_pid; 154, identifier:pid; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 158; 157, identifier:send_signal; 158, argument_list; 158, 159; 159, string:"HUP"; 160, delete_statement; 160, 161; 161, subscript; 161, 162; 161, 163; 162, identifier:gunicorns; 163, identifier:selected_pid; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:selected_pid; 167, None; 168, elif_clause; 168, 169; 168, 174; 169, comparison_operator:in; 169, 170; 169, 171; 170, identifier:key; 171, tuple; 171, 172; 171, 173; 172, string:"M"; 173, string:"-"; 174, block; 174, 175; 175, if_statement; 175, 176; 175, 179; 176, comparison_operator:in; 176, 177; 176, 178; 177, identifier:selected_pid; 178, identifier:gunicorns; 179, block; 179, 180; 179, 185; 179, 189; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 183; 182, identifier:send_signal; 183, argument_list; 183, 184; 184, string:"QUIT"; 185, delete_statement; 185, 186; 186, subscript; 186, 187; 186, 188; 187, identifier:gunicorns; 188, identifier:selected_pid; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:selected_pid; 192, None; 193, elif_clause; 193, 194; 193, 198; 194, comparison_operator:in; 194, 195; 194, 196; 195, identifier:key; 196, tuple; 196, 197; 197, string:"Q"; 198, block; 198, 199; 199, raise_statement; 199, 200; 200, identifier:KeyboardInterrupt | def handle_keypress(screen):
global selected_pid
try:
key = screen.getkey().upper()
except:
return
if key in ("KEY_DOWN", "J"):
move_selection()
elif key in ("KEY_UP", "K"):
move_selection(reverse=True)
elif key in ("A", "+"):
send_signal("TTIN")
if selected_pid in gunicorns:
gunicorns[selected_pid]["workers"] = 0
elif key in ("W", "-"):
if selected_pid in gunicorns:
if gunicorns[selected_pid]["workers"] != 1:
send_signal("TTOU")
gunicorns[selected_pid]["workers"] = 0
elif key in ("R",):
if selected_pid in gunicorns:
send_signal("HUP")
del gunicorns[selected_pid]
selected_pid = None
elif key in ("T",):
for pid in gunicorns.copy().iterkeys():
selected_pid = pid
send_signal("HUP")
del gunicorns[selected_pid]
selected_pid = None
elif key in ("M", "-"):
if selected_pid in gunicorns:
send_signal("QUIT")
del gunicorns[selected_pid]
selected_pid = None
elif key in ("Q",):
raise KeyboardInterrupt |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:renderContent; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 18; 5, 40; 5, 71; 5, 77; 5, 147; 5, 167; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:stm; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:stm; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:portCtx; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:portCtx; 18, for_statement; 18, 19; 18, 20; 18, 23; 19, identifier:o; 20, attribute; 20, 21; 20, 22; 21, identifier:stm; 22, identifier:_outputs; 23, block; 23, 24; 24, if_statement; 24, 25; 24, 29; 25, not_operator; 25, 26; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:isVirtual; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:portCtx; 34, identifier:register; 35, argument_list; 35, 36; 35, 37; 36, identifier:o; 37, attribute; 37, 38; 37, 39; 38, identifier:PortType; 39, identifier:OUTPUT; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:canHaveRamPorts; 43, boolean_operator:and; 43, 44; 43, 49; 44, call; 44, 45; 44, 46; 45, identifier:isinstance; 46, argument_list; 46, 47; 46, 48; 47, identifier:stm; 48, identifier:IfContainer; 49, call; 49, 50; 49, 51; 50, identifier:arr_any; 51, argument_list; 51, 52; 51, 61; 52, call; 52, 53; 52, 54; 53, identifier:chain; 54, argument_list; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:stm; 57, identifier:_inputs; 58, attribute; 58, 59; 58, 60; 59, identifier:stm; 60, identifier:_outputs; 61, lambda; 61, 62; 61, 64; 62, lambda_parameters; 62, 63; 63, identifier:s; 64, call; 64, 65; 64, 66; 65, identifier:isinstance; 66, argument_list; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:s; 69, identifier:_dtype; 70, identifier:HArray; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:consumedOutputs; 74, call; 74, 75; 74, 76; 75, identifier:set; 76, argument_list; 77, if_statement; 77, 78; 77, 79; 78, identifier:canHaveRamPorts; 79, block; 79, 80; 80, for_statement; 80, 81; 80, 87; 80, 94; 81, pattern_list; 81, 82; 81, 83; 81, 84; 81, 85; 81, 86; 82, identifier:pType; 83, identifier:memSig; 84, identifier:addrSig; 85, identifier:enSig; 86, identifier:io; 87, call; 87, 88; 87, 89; 88, identifier:detectRamPorts; 89, argument_list; 89, 90; 89, 91; 90, identifier:stm; 91, attribute; 91, 92; 91, 93; 92, identifier:stm; 93, identifier:cond; 94, block; 94, 95; 95, if_statement; 95, 96; 95, 99; 95, 118; 95, 141; 96, comparison_operator:==; 96, 97; 96, 98; 97, identifier:pType; 98, identifier:RAM_READ; 99, block; 99, 100; 99, 111; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:createRamReadNode; 105, argument_list; 105, 106; 105, 107; 105, 108; 105, 109; 105, 110; 106, identifier:memSig; 107, identifier:enSig; 108, identifier:addrSig; 109, identifier:io; 110, True; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:consumedOutputs; 115, identifier:add; 116, argument_list; 116, 117; 117, identifier:io; 118, elif_clause; 118, 119; 118, 122; 119, comparison_operator:==; 119, 120; 119, 121; 120, identifier:pType; 121, identifier:RAM_WRITE; 122, block; 122, 123; 122, 134; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:createRamWriteNode; 128, argument_list; 128, 129; 128, 130; 128, 131; 128, 132; 128, 133; 129, identifier:memSig; 130, identifier:enSig; 131, identifier:addrSig; 132, identifier:io; 133, True; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:consumedOutputs; 138, identifier:add; 139, argument_list; 139, 140; 140, identifier:memSig; 141, else_clause; 141, 142; 142, block; 142, 143; 143, raise_statement; 143, 144; 144, call; 144, 145; 144, 146; 145, identifier:TypeError; 146, argument_list; 147, for_statement; 147, 148; 147, 149; 147, 152; 148, identifier:o; 149, attribute; 149, 150; 149, 151; 150, identifier:stm; 151, identifier:_outputs; 152, block; 152, 153; 153, if_statement; 153, 154; 153, 157; 154, comparison_operator:not; 154, 155; 154, 156; 155, identifier:o; 156, identifier:consumedOutputs; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:renderForSignal; 163, argument_list; 163, 164; 163, 165; 163, 166; 164, identifier:stm; 165, identifier:o; 166, True; 167, if_statement; 167, 168; 167, 172; 168, not_operator; 168, 169; 169, attribute; 169, 170; 169, 171; 170, identifier:self; 171, identifier:isVirtual; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 180; 175, attribute; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:netCtxs; 179, identifier:applyConnections; 180, argument_list; 180, 181; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:node | def renderContent(self):
stm = self.stm
portCtx = self.portCtx
for o in stm._outputs:
if not self.isVirtual:
portCtx.register(o, PortType.OUTPUT)
canHaveRamPorts = isinstance(stm, IfContainer) and arr_any(
chain(stm._inputs, stm._outputs),
lambda s: isinstance(s._dtype, HArray))
consumedOutputs = set()
if canHaveRamPorts:
for pType, memSig, addrSig, enSig, io in detectRamPorts(stm, stm.cond):
if pType == RAM_READ:
self.createRamReadNode(memSig, enSig, addrSig,
io, True)
consumedOutputs.add(io)
elif pType == RAM_WRITE:
self.createRamWriteNode(memSig, enSig, addrSig,
io, True)
consumedOutputs.add(memSig)
else:
raise TypeError()
for o in stm._outputs:
if o not in consumedOutputs:
self.renderForSignal(stm, o, True)
if not self.isVirtual:
self.netCtxs.applyConnections(self.node) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:generate; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:project; 6, block; 6, 7; 6, 30; 6, 34; 6, 53; 6, 94; 6, 113; 6, 132; 6, 151; 6, 170; 6, 189; 6, 208; 6, 218; 6, 226; 7, for_statement; 7, 8; 7, 9; 7, 12; 8, identifier:assignment; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:s2n_mapping; 12, block; 12, 13; 13, if_statement; 13, 14; 13, 19; 14, comparison_operator:==; 14, 15; 14, 18; 15, subscript; 15, 16; 15, 17; 16, identifier:assignment; 17, string:"ipprefix"; 18, identifier:project; 19, block; 19, 20; 19, 28; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_name; 25, subscript; 25, 26; 25, 27; 26, identifier:assignment; 27, string:"package"; 28, return_statement; 28, 29; 29, identifier:self; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:name; 33, identifier:project; 34, if_statement; 34, 35; 34, 41; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:name; 38, identifier:startswith; 39, argument_list; 39, 40; 40, string:"github.com"; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:name; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:re; 48, identifier:sub; 49, argument_list; 49, 50; 49, 51; 49, 52; 50, string:r"^github\.com"; 51, string:"github"; 52, identifier:name; 53, if_statement; 53, 54; 53, 60; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:name; 57, identifier:startswith; 58, argument_list; 58, 59; 59, string:"gopkg.in"; 60, block; 60, 61; 60, 72; 60, 83; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:name; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:re; 67, identifier:sub; 68, argument_list; 68, 69; 68, 70; 68, 71; 69, string:r"gopkg\.in"; 70, string:"gopkg"; 71, identifier:name; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:name; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:re; 78, identifier:sub; 79, argument_list; 79, 80; 79, 81; 79, 82; 80, string:r"\.v\d"; 81, string:""; 82, identifier:name; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:name; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:re; 89, identifier:sub; 90, argument_list; 90, 91; 90, 92; 90, 93; 91, string:r"/v\d/"; 92, string:"/"; 93, identifier:name; 94, if_statement; 94, 95; 94, 101; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:name; 98, identifier:startswith; 99, argument_list; 99, 100; 100, string:"code.google.com/p"; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:name; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:re; 108, identifier:sub; 109, argument_list; 109, 110; 109, 111; 109, 112; 110, string:r"^code\.google\.com/p"; 111, string:"googlecode"; 112, identifier:name; 113, if_statement; 113, 114; 113, 120; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:name; 117, identifier:startswith; 118, argument_list; 118, 119; 119, string:"golang.org/x"; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:name; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:re; 127, identifier:sub; 128, argument_list; 128, 129; 128, 130; 128, 131; 129, string:r"^golang\.org/x"; 130, string:"golangorg"; 131, identifier:name; 132, if_statement; 132, 133; 132, 139; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:name; 136, identifier:startswith; 137, argument_list; 137, 138; 138, string:"google.golang.org"; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:name; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:re; 146, identifier:sub; 147, argument_list; 147, 148; 147, 149; 147, 150; 148, string:r"^google\.golang\.org"; 149, string:"googlegolangorg"; 150, identifier:name; 151, if_statement; 151, 152; 151, 158; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:name; 155, identifier:startswith; 156, argument_list; 156, 157; 157, string:"bitbucket.org"; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:name; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:re; 165, identifier:sub; 166, argument_list; 166, 167; 166, 168; 166, 169; 167, string:r"^bitbucket\.org"; 168, string:"bitbucket"; 169, identifier:name; 170, if_statement; 170, 171; 170, 177; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:name; 174, identifier:startswith; 175, argument_list; 175, 176; 176, string:"k8s.io"; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:name; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:re; 184, identifier:sub; 185, argument_list; 185, 186; 185, 187; 185, 188; 186, string:r"^k8s\.io"; 187, string:"k8s"; 188, identifier:name; 189, if_statement; 189, 190; 189, 196; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:name; 193, identifier:endswith; 194, argument_list; 194, 195; 195, string:".org"; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:name; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:re; 203, identifier:sub; 204, argument_list; 204, 205; 204, 206; 204, 207; 205, string:r"\.org$"; 206, string:""; 207, identifier:name; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:name; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:name; 214, identifier:replace; 215, argument_list; 215, 216; 215, 217; 216, string:"/"; 217, string:"-"; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:self; 222, identifier:_name; 223, binary_operator:%; 223, 224; 223, 225; 224, string:"golang-%s"; 225, identifier:name; 226, return_statement; 226, 227; 227, identifier:self | def generate(self, project):
for assignment in self.s2n_mapping:
if assignment["ipprefix"] == project:
self._name = assignment["package"]
return self
name = project
if name.startswith("github.com"):
name = re.sub(r"^github\.com", "github", name)
if name.startswith("gopkg.in"):
name = re.sub(r"gopkg\.in", "gopkg", name)
name = re.sub(r"\.v\d", "", name)
name = re.sub(r"/v\d/", "/", name)
if name.startswith("code.google.com/p"):
name = re.sub(r"^code\.google\.com/p", "googlecode", name)
if name.startswith("golang.org/x"):
name = re.sub(r"^golang\.org/x", "golangorg", name)
if name.startswith("google.golang.org"):
name = re.sub(r"^google\.golang\.org", "googlegolangorg", name)
if name.startswith("bitbucket.org"):
name = re.sub(r"^bitbucket\.org", "bitbucket", name)
if name.startswith("k8s.io"):
name = re.sub(r"^k8s\.io", "k8s", name)
if name.endswith(".org"):
name = re.sub(r"\.org$", "", name)
name = name.replace("/", "-")
self._name = "golang-%s" % name
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_read_elem_nodes; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:fid; 6, block; 6, 7; 6, 11; 6, 29; 6, 72; 6, 96; 6, 140; 6, 288; 6, 294; 6, 300; 6, 306; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:nodes; 10, dictionary; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:nodes_raw; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:np; 17, identifier:empty; 18, argument_list; 18, 19; 18, 26; 19, tuple; 19, 20; 19, 25; 20, subscript; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:header; 24, string:'nr_nodes'; 25, integer:3; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:dtype; 28, identifier:float; 29, for_statement; 29, 30; 29, 31; 29, 40; 30, identifier:nr; 31, call; 31, 32; 31, 33; 32, identifier:range; 33, argument_list; 33, 34; 33, 35; 34, integer:0; 35, subscript; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:header; 39, string:'nr_nodes'; 40, block; 40, 41; 40, 53; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:node_line; 44, call; 44, 45; 44, 52; 45, attribute; 45, 46; 45, 51; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:fid; 49, identifier:readline; 50, argument_list; 51, identifier:lstrip; 52, argument_list; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 60; 55, subscript; 55, 56; 55, 57; 55, 58; 56, identifier:nodes_raw; 57, identifier:nr; 58, slice; 58, 59; 59, colon; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:np; 63, identifier:fromstring; 64, argument_list; 64, 65; 64, 66; 64, 69; 65, identifier:node_line; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:dtype; 68, identifier:float; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:sep; 71, string:' '; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 82; 74, subscript; 74, 75; 74, 76; 74, 78; 75, identifier:nodes_raw; 76, slice; 76, 77; 77, colon; 78, slice; 78, 79; 78, 80; 78, 81; 79, integer:1; 80, colon; 81, integer:3; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:np; 85, identifier:round; 86, argument_list; 86, 87; 86, 95; 87, subscript; 87, 88; 87, 89; 87, 91; 88, identifier:nodes_raw; 89, slice; 89, 90; 90, colon; 91, slice; 91, 92; 91, 93; 91, 94; 92, integer:1; 93, colon; 94, integer:3; 95, integer:5; 96, if_statement; 96, 97; 96, 116; 96, 130; 97, parenthesized_expression; 97, 98; 98, comparison_operator:!=; 98, 99; 98, 104; 99, subscript; 99, 100; 99, 101; 99, 103; 100, identifier:nodes_raw; 101, slice; 101, 102; 102, colon; 103, integer:0; 104, call; 104, 105; 104, 106; 105, identifier:list; 106, argument_list; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:range; 109, argument_list; 109, 110; 109, 111; 110, integer:1; 111, subscript; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:nodes_raw; 114, identifier:shape; 115, integer:0; 116, block; 116, 117; 116, 125; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 124; 119, subscript; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:header; 123, string:'cutmck'; 124, True; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:print; 128, argument_list; 128, 129; 129, string:'This grid was sorted using CutMcK. The nodes were resorted!'; 130, else_clause; 130, 131; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 139; 134, subscript; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:header; 138, string:'cutmck'; 139, False; 140, if_statement; 140, 141; 140, 147; 140, 276; 141, parenthesized_expression; 141, 142; 142, subscript; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:header; 146, string:'cutmck'; 147, block; 147, 148; 147, 157; 147, 173; 147, 245; 147, 253; 147, 259; 147, 265; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:nodes_cutmck; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:np; 154, identifier:empty_like; 155, argument_list; 155, 156; 156, identifier:nodes_raw; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:nodes_cutmck_index; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:np; 163, identifier:zeros; 164, argument_list; 164, 165; 164, 170; 165, subscript; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:nodes_raw; 168, identifier:shape; 169, integer:0; 170, keyword_argument; 170, 171; 170, 172; 171, identifier:dtype; 172, identifier:int; 173, for_statement; 173, 174; 173, 175; 173, 184; 174, identifier:node; 175, call; 175, 176; 175, 177; 176, identifier:range; 177, argument_list; 177, 178; 177, 179; 178, integer:0; 179, subscript; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:header; 183, string:'nr_nodes'; 184, block; 184, 185; 184, 208; 184, 226; 184, 237; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:new_index; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:np; 191, identifier:where; 192, argument_list; 192, 193; 193, comparison_operator:==; 193, 194; 193, 204; 194, call; 194, 195; 194, 202; 195, attribute; 195, 196; 195, 201; 196, subscript; 196, 197; 196, 198; 196, 200; 197, identifier:nodes_raw; 198, slice; 198, 199; 199, colon; 200, integer:0; 201, identifier:astype; 202, argument_list; 202, 203; 203, identifier:int; 204, parenthesized_expression; 204, 205; 205, binary_operator:+; 205, 206; 205, 207; 206, identifier:node; 207, integer:1; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 219; 210, subscript; 210, 211; 210, 212; 210, 215; 211, identifier:nodes_cutmck; 212, subscript; 212, 213; 212, 214; 213, identifier:new_index; 214, integer:0; 215, slice; 215, 216; 215, 217; 215, 218; 216, integer:1; 217, colon; 218, integer:3; 219, subscript; 219, 220; 219, 221; 219, 222; 220, identifier:nodes_raw; 221, identifier:node; 222, slice; 222, 223; 222, 224; 222, 225; 223, integer:1; 224, colon; 225, integer:3; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 234; 228, subscript; 228, 229; 228, 230; 228, 233; 229, identifier:nodes_cutmck; 230, subscript; 230, 231; 230, 232; 231, identifier:new_index; 232, integer:0; 233, integer:0; 234, subscript; 234, 235; 234, 236; 235, identifier:new_index; 236, integer:0; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 242; 239, subscript; 239, 240; 239, 241; 240, identifier:nodes_cutmck_index; 241, identifier:node; 242, subscript; 242, 243; 242, 244; 243, identifier:new_index; 244, integer:0; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:nodes_sorted; 248, subscript; 248, 249; 248, 250; 248, 251; 249, identifier:nodes_cutmck; 250, identifier:nodes_cutmck_index; 251, slice; 251, 252; 252, colon; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 258; 255, subscript; 255, 256; 255, 257; 256, identifier:nodes; 257, string:'presort'; 258, identifier:nodes_cutmck; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 264; 261, subscript; 261, 262; 261, 263; 262, identifier:nodes; 263, string:'cutmck_index'; 264, identifier:nodes_cutmck_index; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 270; 267, subscript; 267, 268; 267, 269; 268, identifier:nodes; 269, string:'rev_cutmck_index'; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:np; 273, identifier:argsort; 274, argument_list; 274, 275; 275, identifier:nodes_cutmck_index; 276, else_clause; 276, 277; 277, block; 277, 278; 277, 282; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:nodes_sorted; 281, identifier:nodes_raw; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 287; 284, subscript; 284, 285; 284, 286; 285, identifier:nodes; 286, string:'presort'; 287, identifier:nodes_raw; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 293; 290, subscript; 290, 291; 290, 292; 291, identifier:nodes; 292, string:'raw'; 293, identifier:nodes_raw; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 299; 296, subscript; 296, 297; 296, 298; 297, identifier:nodes; 298, string:'sorted'; 299, identifier:nodes_sorted; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:self; 304, identifier:nodes; 305, identifier:nodes; 306, expression_statement; 306, 307; 307, assignment; 307, 308; 307, 311; 308, attribute; 308, 309; 308, 310; 309, identifier:self; 310, identifier:nr_of_nodes; 311, subscript; 311, 312; 311, 317; 312, attribute; 312, 313; 312, 316; 313, subscript; 313, 314; 313, 315; 314, identifier:nodes; 315, string:'raw'; 316, identifier:shape; 317, integer:0 | def _read_elem_nodes(self, fid):
nodes = {}
nodes_raw = np.empty((self.header['nr_nodes'], 3), dtype=float)
for nr in range(0, self.header['nr_nodes']):
node_line = fid.readline().lstrip()
nodes_raw[nr, :] = np.fromstring(
node_line, dtype=float, sep=' ')
nodes_raw[:, 1:3] = np.round(nodes_raw[:, 1:3], 5)
if(nodes_raw[:, 0] != list(range(1, nodes_raw.shape[0]))):
self.header['cutmck'] = True
print(
'This grid was sorted using CutMcK. The nodes were resorted!')
else:
self.header['cutmck'] = False
if(self.header['cutmck']):
nodes_cutmck = np.empty_like(nodes_raw)
nodes_cutmck_index = np.zeros(nodes_raw.shape[0], dtype=int)
for node in range(0, self.header['nr_nodes']):
new_index = np.where(nodes_raw[:, 0].astype(int) == (node + 1))
nodes_cutmck[new_index[0], 1:3] = nodes_raw[node, 1:3]
nodes_cutmck[new_index[0], 0] = new_index[0]
nodes_cutmck_index[node] = new_index[0]
nodes_sorted = nodes_cutmck[nodes_cutmck_index, :]
nodes['presort'] = nodes_cutmck
nodes['cutmck_index'] = nodes_cutmck_index
nodes['rev_cutmck_index'] = np.argsort(nodes_cutmck_index)
else:
nodes_sorted = nodes_raw
nodes['presort'] = nodes_raw
nodes['raw'] = nodes_raw
nodes['sorted'] = nodes_sorted
self.nodes = nodes
self.nr_of_nodes = nodes['raw'].shape[0] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:errorhandle; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:resp; 6, block; 6, 7; 6, 201; 7, if_statement; 7, 8; 7, 13; 7, 141; 7, 190; 8, comparison_operator:==; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:format; 12, string:'json'; 13, block; 13, 14; 13, 23; 13, 35; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:parsed; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:xmltodict; 20, identifier:parse; 21, argument_list; 21, 22; 22, identifier:resp; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:errors; 26, subscript; 26, 27; 26, 32; 27, subscript; 27, 28; 27, 29; 28, identifier:parsed; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:RESPONSE_TOKEN; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:ERROR_TOKEN; 35, if_statement; 35, 36; 35, 49; 35, 84; 36, boolean_operator:and; 36, 37; 36, 43; 37, comparison_operator:is; 37, 38; 37, 42; 38, call; 38, 39; 38, 40; 39, identifier:type; 40, argument_list; 40, 41; 41, identifier:errors; 42, identifier:list; 43, comparison_operator:>; 43, 44; 43, 48; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:errors; 48, integer:1; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:messages; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, string:", "; 56, identifier:join; 57, argument_list; 57, 58; 58, list_comprehension; 58, 59; 58, 81; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, string:" "; 62, identifier:join; 63, argument_list; 63, 64; 64, list_comprehension; 64, 65; 64, 72; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, string:"{}: {}"; 68, identifier:format; 69, argument_list; 69, 70; 69, 71; 70, identifier:k; 71, identifier:v; 72, for_in_clause; 72, 73; 72, 76; 73, pattern_list; 73, 74; 73, 75; 74, identifier:k; 75, identifier:v; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:e; 79, identifier:items; 80, argument_list; 81, for_in_clause; 81, 82; 81, 83; 82, identifier:e; 83, identifier:errors; 84, else_clause; 84, 85; 85, block; 85, 86; 85, 106; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:overlimit; 89, call; 89, 90; 89, 91; 90, identifier:any; 91, generator_expression; 91, 92; 91, 99; 92, comparison_operator:in; 92, 93; 92, 94; 93, string:'transaction limit'; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:msg; 97, identifier:lower; 98, argument_list; 99, for_in_clause; 99, 100; 99, 101; 100, identifier:msg; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:errors; 104, identifier:values; 105, argument_list; 106, if_statement; 106, 107; 106, 108; 106, 114; 107, identifier:overlimit; 108, block; 108, 109; 109, raise_statement; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:APILimitExceeded; 112, argument_list; 112, 113; 113, string:"This API key has used up its daily quota of calls."; 114, else_clause; 114, 115; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:messages; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, string:" "; 122, identifier:join; 123, argument_list; 123, 124; 124, list_comprehension; 124, 125; 124, 132; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, string:"{}: {}"; 128, identifier:format; 129, argument_list; 129, 130; 129, 131; 130, identifier:k; 131, identifier:v; 132, for_in_clause; 132, 133; 132, 136; 133, pattern_list; 133, 134; 133, 135; 134, identifier:k; 135, identifier:v; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:errors; 139, identifier:items; 140, argument_list; 141, elif_clause; 141, 142; 141, 147; 142, comparison_operator:==; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:format; 146, string:'xml'; 147, block; 147, 148; 147, 155; 147, 171; 148, import_statement; 148, 149; 149, aliased_import; 149, 150; 149, 154; 150, dotted_name; 150, 151; 150, 152; 150, 153; 151, identifier:xml; 152, identifier:etree; 153, identifier:ElementTree; 154, identifier:ET; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:errors; 158, call; 158, 159; 158, 167; 159, attribute; 159, 160; 159, 166; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:ET; 163, identifier:fromstring; 164, argument_list; 164, 165; 165, identifier:resp; 166, identifier:findall; 167, argument_list; 167, 168; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:ERROR_TOKEN; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:messages; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, string:", "; 177, identifier:join; 178, generator_expression; 178, 179; 178, 187; 179, attribute; 179, 180; 179, 186; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:err; 183, identifier:find; 184, argument_list; 184, 185; 185, string:'msg'; 186, identifier:text; 187, for_in_clause; 187, 188; 187, 189; 188, identifier:err; 189, identifier:errors; 190, else_clause; 190, 191; 191, block; 191, 192; 192, raise_statement; 192, 193; 193, call; 193, 194; 193, 195; 194, identifier:ValueError; 195, argument_list; 195, 196; 196, binary_operator:%; 196, 197; 196, 198; 197, string:"Invalid API response format specified: {}."; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:format; 201, raise_statement; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:BustimeError; 204, argument_list; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, string:"API returned: {}"; 208, identifier:format; 209, argument_list; 209, 210; 210, identifier:messages | def errorhandle(self, resp):
if self.format == 'json':
parsed = xmltodict.parse(resp)
errors = parsed[self.RESPONSE_TOKEN][self.ERROR_TOKEN]
if type(errors) is list and len(errors) > 1:
messages = ", ".join([" ".join(["{}: {}".format(k,v) for k, v in e.items()]) for e in errors])
else:
overlimit = any('transaction limit' in msg.lower() for msg in errors.values())
if overlimit:
raise APILimitExceeded("This API key has used up its daily quota of calls.")
else:
messages = " ".join(["{}: {}".format(k,v) for k, v in errors.items()])
elif self.format == 'xml':
import xml.etree.ElementTree as ET
errors = ET.fromstring(resp).findall(self.ERROR_TOKEN)
messages = ", ".join(err.find('msg').text for err in errors)
else:
raise ValueError("Invalid API response format specified: {}." % self.format)
raise BustimeError("API returned: {}".format(messages)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:cleanup; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:config; 5, identifier:searchstring; 6, default_parameter; 6, 7; 6, 8; 7, identifier:force; 8, False; 9, block; 9, 10; 9, 16; 9, 27; 9, 68; 9, 75; 9, 83; 9, 89; 9, 101; 9, 105; 9, 109; 9, 118; 9, 128; 9, 146; 9, 160; 9, 170; 9, 181; 9, 222; 9, 228; 9, 234; 9, 261; 9, 267; 9, 292; 9, 296; 9, 305; 9, 328; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:repo; 13, attribute; 13, 14; 13, 15; 14, identifier:config; 15, identifier:repo; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:branches_; 19, call; 19, 20; 19, 21; 20, identifier:list; 21, argument_list; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:find; 24, argument_list; 24, 25; 24, 26; 25, identifier:repo; 26, identifier:searchstring; 27, if_statement; 27, 28; 27, 30; 27, 36; 28, not_operator; 28, 29; 29, identifier:branches_; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:error_out; 34, argument_list; 34, 35; 35, string:"No branches found"; 36, elif_clause; 36, 37; 36, 43; 37, comparison_operator:>; 37, 38; 37, 42; 38, call; 38, 39; 38, 40; 39, identifier:len; 40, argument_list; 40, 41; 41, identifier:branches_; 42, integer:1; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:error_out; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, string:"More than one branch found.{}"; 51, identifier:format; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, string:"\n\t"; 56, identifier:join; 57, argument_list; 57, 58; 58, binary_operator:+; 58, 59; 58, 61; 59, list:[""]; 59, 60; 60, string:""; 61, list_comprehension; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:x; 64, identifier:name; 65, for_in_clause; 65, 66; 65, 67; 66, identifier:x; 67, identifier:branches_; 68, assert_statement; 68, 69; 69, comparison_operator:==; 69, 70; 69, 74; 70, call; 70, 71; 70, 72; 71, identifier:len; 72, argument_list; 72, 73; 73, identifier:branches_; 74, integer:1; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:branch_name; 78, attribute; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:branches_; 81, integer:0; 82, identifier:name; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:active_branch; 86, attribute; 86, 87; 86, 88; 87, identifier:repo; 88, identifier:active_branch; 89, if_statement; 89, 90; 89, 95; 90, comparison_operator:==; 90, 91; 90, 92; 91, identifier:branch_name; 92, attribute; 92, 93; 92, 94; 93, identifier:active_branch; 94, identifier:name; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:error_out; 99, argument_list; 99, 100; 100, string:"Can't clean up the current active branch."; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:upstream_remote; 104, None; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:fork_remote; 108, None; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:state; 112, call; 112, 113; 112, 114; 113, identifier:read; 114, argument_list; 114, 115; 115, attribute; 115, 116; 115, 117; 116, identifier:config; 117, identifier:configfile; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:origin_name; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:state; 124, identifier:get; 125, argument_list; 125, 126; 125, 127; 126, string:"ORIGIN_NAME"; 127, string:"origin"; 128, for_statement; 128, 129; 128, 130; 128, 133; 129, identifier:remote; 130, attribute; 130, 131; 130, 132; 131, identifier:repo; 132, identifier:remotes; 133, block; 133, 134; 134, if_statement; 134, 135; 134, 140; 135, comparison_operator:==; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:remote; 138, identifier:name; 139, identifier:origin_name; 140, block; 140, 141; 140, 145; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:upstream_remote; 144, identifier:remote; 145, break_statement; 146, if_statement; 146, 147; 146, 149; 147, not_operator; 147, 148; 148, identifier:upstream_remote; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 153; 152, identifier:error_out; 153, argument_list; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, string:"No remote called {!r} found"; 157, identifier:format; 158, argument_list; 158, 159; 159, identifier:origin_name; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 169; 162, attribute; 162, 163; 162, 168; 163, attribute; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:repo; 166, identifier:heads; 167, identifier:master; 168, identifier:checkout; 169, argument_list; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:upstream_remote; 174, identifier:pull; 175, argument_list; 175, 176; 176, attribute; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:repo; 179, identifier:heads; 180, identifier:master; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:merged_branches; 184, list_comprehension; 184, 185; 184, 190; 184, 204; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:x; 188, identifier:strip; 189, argument_list; 190, for_in_clause; 190, 191; 190, 192; 191, identifier:x; 192, call; 192, 193; 192, 203; 193, attribute; 193, 194; 193, 202; 194, call; 194, 195; 194, 200; 195, attribute; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:repo; 198, identifier:git; 199, identifier:branch; 200, argument_list; 200, 201; 201, string:"--merged"; 202, identifier:splitlines; 203, argument_list; 204, if_clause; 204, 205; 205, boolean_operator:and; 205, 206; 205, 211; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:x; 209, identifier:strip; 210, argument_list; 211, not_operator; 211, 212; 212, call; 212, 213; 212, 220; 213, attribute; 213, 214; 213, 219; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:x; 217, identifier:strip; 218, argument_list; 219, identifier:startswith; 220, argument_list; 220, 221; 221, string:"*"; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:was_merged; 225, comparison_operator:in; 225, 226; 225, 227; 226, identifier:branch_name; 227, identifier:merged_branches; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:certain; 231, boolean_operator:or; 231, 232; 231, 233; 232, identifier:was_merged; 233, identifier:force; 234, if_statement; 234, 235; 234, 237; 235, not_operator; 235, 236; 236, identifier:certain; 237, block; 237, 238; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:certain; 241, parenthesized_expression; 241, 242; 242, comparison_operator:!=; 242, 243; 242, 260; 243, call; 243, 244; 243, 259; 244, attribute; 244, 245; 244, 258; 245, call; 245, 246; 245, 257; 246, attribute; 246, 247; 246, 256; 247, call; 247, 248; 247, 249; 248, identifier:input; 249, argument_list; 249, 250; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, string:"Are you certain {} is actually merged? [Y/n] "; 253, identifier:format; 254, argument_list; 254, 255; 255, identifier:branch_name; 256, identifier:lower; 257, argument_list; 258, identifier:strip; 259, argument_list; 260, string:"n"; 261, if_statement; 261, 262; 261, 264; 262, not_operator; 262, 263; 263, identifier:certain; 264, block; 264, 265; 265, return_statement; 265, 266; 266, integer:1; 267, if_statement; 267, 268; 267, 269; 267, 280; 268, identifier:was_merged; 269, block; 269, 270; 270, expression_statement; 270, 271; 271, call; 271, 272; 271, 277; 272, attribute; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:repo; 275, identifier:git; 276, identifier:branch; 277, argument_list; 277, 278; 277, 279; 278, string:"-d"; 279, identifier:branch_name; 280, else_clause; 280, 281; 281, block; 281, 282; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 289; 284, attribute; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:repo; 287, identifier:git; 288, identifier:branch; 289, argument_list; 289, 290; 289, 291; 290, string:"-D"; 291, identifier:branch_name; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:fork_remote; 295, None; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 299; 298, identifier:state; 299, call; 299, 300; 299, 301; 300, identifier:read; 301, argument_list; 301, 302; 302, attribute; 302, 303; 302, 304; 303, identifier:config; 304, identifier:configfile; 305, for_statement; 305, 306; 305, 307; 305, 310; 306, identifier:remote; 307, attribute; 307, 308; 307, 309; 308, identifier:repo; 309, identifier:remotes; 310, block; 310, 311; 311, if_statement; 311, 312; 311, 322; 312, comparison_operator:==; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:remote; 315, identifier:name; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:state; 319, identifier:get; 320, argument_list; 320, 321; 321, string:"FORK_NAME"; 322, block; 322, 323; 322, 327; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:fork_remote; 326, identifier:remote; 327, break_statement; 328, if_statement; 328, 329; 328, 330; 329, identifier:fork_remote; 330, block; 330, 331; 330, 340; 331, expression_statement; 331, 332; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:fork_remote; 335, identifier:push; 336, argument_list; 336, 337; 337, binary_operator:+; 337, 338; 337, 339; 338, string:":"; 339, identifier:branch_name; 340, expression_statement; 340, 341; 341, call; 341, 342; 341, 343; 342, identifier:info_out; 343, argument_list; 343, 344; 344, string:"Remote branch on fork deleted too." | def cleanup(config, searchstring, force=False):
repo = config.repo
branches_ = list(find(repo, searchstring))
if not branches_:
error_out("No branches found")
elif len(branches_) > 1:
error_out(
"More than one branch found.{}".format(
"\n\t".join([""] + [x.name for x in branches_])
)
)
assert len(branches_) == 1
branch_name = branches_[0].name
active_branch = repo.active_branch
if branch_name == active_branch.name:
error_out("Can't clean up the current active branch.")
upstream_remote = None
fork_remote = None
state = read(config.configfile)
origin_name = state.get("ORIGIN_NAME", "origin")
for remote in repo.remotes:
if remote.name == origin_name:
upstream_remote = remote
break
if not upstream_remote:
error_out("No remote called {!r} found".format(origin_name))
repo.heads.master.checkout()
upstream_remote.pull(repo.heads.master)
merged_branches = [
x.strip()
for x in repo.git.branch("--merged").splitlines()
if x.strip() and not x.strip().startswith("*")
]
was_merged = branch_name in merged_branches
certain = was_merged or force
if not certain:
certain = (
input("Are you certain {} is actually merged? [Y/n] ".format(branch_name))
.lower()
.strip()
!= "n"
)
if not certain:
return 1
if was_merged:
repo.git.branch("-d", branch_name)
else:
repo.git.branch("-D", branch_name)
fork_remote = None
state = read(config.configfile)
for remote in repo.remotes:
if remote.name == state.get("FORK_NAME"):
fork_remote = remote
break
if fork_remote:
fork_remote.push(":" + branch_name)
info_out("Remote branch on fork deleted too.") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:construct; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:data; 6, block; 6, 7; 6, 11; 6, 15; 6, 94; 6, 100; 6, 143; 6, 149; 6, 171; 6, 184; 6, 188; 6, 192; 6, 236; 6, 245; 6, 254; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:occurrences; 10, dictionary; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:main_occurrences; 14, dictionary; 15, for_statement; 15, 16; 15, 17; 15, 22; 16, identifier:pkg; 17, subscript; 17, 18; 17, 21; 18, subscript; 18, 19; 18, 20; 19, identifier:data; 20, string:"data"; 21, string:"dependencies"; 22, block; 22, 23; 22, 29; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:package; 26, subscript; 26, 27; 26, 28; 27, identifier:pkg; 28, string:"package"; 29, for_statement; 29, 30; 29, 31; 29, 34; 30, identifier:item; 31, subscript; 31, 32; 31, 33; 32, identifier:pkg; 33, string:"dependencies"; 34, block; 34, 35; 34, 41; 34, 71; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:dep; 38, subscript; 38, 39; 38, 40; 39, identifier:item; 40, string:"name"; 41, if_statement; 41, 42; 41, 45; 41, 63; 42, comparison_operator:!=; 42, 43; 42, 44; 43, identifier:package; 44, string:"."; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:deps; 49, call; 49, 50; 49, 51; 50, identifier:map; 51, argument_list; 51, 52; 51, 60; 52, lambda; 52, 53; 52, 55; 53, lambda_parameters; 53, 54; 54, identifier:l; 55, binary_operator:%; 55, 56; 55, 57; 56, string:"%s/%s"; 57, tuple; 57, 58; 57, 59; 58, identifier:package; 59, identifier:l; 60, subscript; 60, 61; 60, 62; 61, identifier:item; 62, string:"location"; 63, else_clause; 63, 64; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:deps; 68, subscript; 68, 69; 68, 70; 69, identifier:item; 70, string:"location"; 71, if_statement; 71, 72; 71, 75; 71, 82; 72, comparison_operator:not; 72, 73; 72, 74; 73, identifier:dep; 74, identifier:occurrences; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 81; 78, subscript; 78, 79; 78, 80; 79, identifier:occurrences; 80, identifier:dep; 81, identifier:deps; 82, else_clause; 82, 83; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:occurrences; 88, identifier:dep; 89, binary_operator:+; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:occurrences; 92, identifier:dep; 93, identifier:deps; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:occurrences; 99, identifier:occurrences; 100, for_statement; 100, 101; 100, 102; 100, 107; 101, identifier:main; 102, subscript; 102, 103; 102, 106; 103, subscript; 103, 104; 103, 105; 104, identifier:data; 105, string:"data"; 106, string:"main"; 107, block; 107, 108; 107, 114; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:filename; 111, subscript; 111, 112; 111, 113; 112, identifier:main; 113, string:"filename"; 114, for_statement; 114, 115; 114, 116; 114, 119; 115, identifier:dep; 116, subscript; 116, 117; 116, 118; 117, identifier:main; 118, string:"dependencies"; 119, block; 119, 120; 120, if_statement; 120, 121; 120, 124; 120, 132; 121, comparison_operator:not; 121, 122; 121, 123; 122, identifier:dep; 123, identifier:main_occurrences; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:main_occurrences; 129, identifier:dep; 130, list:[filename]; 130, 131; 131, identifier:filename; 132, else_clause; 132, 133; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 141; 136, attribute; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:main_occurrences; 139, identifier:dep; 140, identifier:append; 141, argument_list; 141, 142; 142, identifier:filename; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:main_occurrences; 148, identifier:main_occurrences; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:test_directories; 154, call; 154, 155; 154, 156; 155, identifier:sorted; 156, argument_list; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:map; 159, argument_list; 159, 160; 159, 166; 160, lambda; 160, 161; 160, 163; 161, lambda_parameters; 161, 162; 162, identifier:l; 163, subscript; 163, 164; 163, 165; 164, identifier:l; 165, string:"test"; 166, subscript; 166, 167; 166, 170; 167, subscript; 167, 168; 167, 169; 168, identifier:data; 169, string:"data"; 170, string:"tests"; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:provided_packages; 176, call; 176, 177; 176, 178; 177, identifier:sorted; 178, argument_list; 178, 179; 179, subscript; 179, 180; 179, 183; 180, subscript; 180, 181; 180, 182; 181, identifier:data; 182, string:"data"; 183, string:"packages"; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:imported_packages; 187, list:[]; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:imported_native_packages; 191, list:[]; 192, for_statement; 192, 193; 192, 194; 192, 195; 193, identifier:path; 194, identifier:occurrences; 195, block; 195, 196; 195, 211; 196, try_statement; 196, 197; 196, 207; 197, block; 197, 198; 198, expression_statement; 198, 199; 199, call; 199, 200; 199, 205; 200, attribute; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:self; 203, identifier:ipparser; 204, identifier:parse; 205, argument_list; 205, 206; 206, identifier:path; 207, except_clause; 207, 208; 207, 209; 208, identifier:ValueError; 209, block; 209, 210; 210, continue_statement; 211, if_statement; 211, 212; 211, 219; 211, 227; 212, call; 212, 213; 212, 218; 213, attribute; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:ipparser; 217, identifier:isNative; 218, argument_list; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:imported_native_packages; 224, identifier:append; 225, argument_list; 225, 226; 226, identifier:path; 227, else_clause; 227, 228; 228, block; 228, 229; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:imported_packages; 233, identifier:append; 234, argument_list; 234, 235; 235, identifier:path; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:self; 240, identifier:imported_packages; 241, call; 241, 242; 241, 243; 242, identifier:sorted; 243, argument_list; 243, 244; 244, identifier:imported_packages; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:self; 249, identifier:imported_native_packages; 250, call; 250, 251; 250, 252; 251, identifier:sorted; 252, argument_list; 252, 253; 253, identifier:imported_native_packages; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:self; 258, identifier:main_packages; 259, call; 259, 260; 259, 261; 260, identifier:map; 261, argument_list; 261, 262; 261, 268; 262, lambda; 262, 263; 262, 265; 263, lambda_parameters; 263, 264; 264, identifier:l; 265, subscript; 265, 266; 265, 267; 266, identifier:l; 267, string:"filename"; 268, subscript; 268, 269; 268, 272; 269, subscript; 269, 270; 269, 271; 270, identifier:data; 271, string:"data"; 272, string:"main" | def construct(self, data):
occurrences = {}
main_occurrences = {}
for pkg in data["data"]["dependencies"]:
package = pkg["package"]
for item in pkg["dependencies"]:
dep = item["name"]
if package != ".":
deps = map(lambda l: "%s/%s" % (package, l), item["location"])
else:
deps = item["location"]
if dep not in occurrences:
occurrences[dep] = deps
else:
occurrences[dep] = occurrences[dep] + deps
self.occurrences = occurrences
for main in data["data"]["main"]:
filename = main["filename"]
for dep in main["dependencies"]:
if dep not in main_occurrences:
main_occurrences[dep] = [filename]
else:
main_occurrences[dep].append(filename)
self.main_occurrences = main_occurrences
self.test_directories = sorted(map(lambda l: l["test"], data["data"]["tests"]))
self.provided_packages = sorted(data["data"]["packages"])
imported_packages = []
imported_native_packages = []
for path in occurrences:
try:
self.ipparser.parse(path)
except ValueError:
continue
if self.ipparser.isNative():
imported_native_packages.append(path)
else:
imported_packages.append(path)
self.imported_packages = sorted(imported_packages)
self.imported_native_packages = sorted(imported_native_packages)
self.main_packages = map(lambda l: l["filename"], data["data"]["main"]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:td_is_finished; 3, parameters; 3, 4; 4, identifier:tomodir; 5, block; 5, 6; 5, 18; 5, 120; 5, 292; 6, if_statement; 6, 7; 6, 12; 7, not_operator; 7, 8; 8, call; 8, 9; 8, 10; 9, identifier:is_tomodir; 10, argument_list; 10, 11; 11, identifier:tomodir; 12, block; 12, 13; 13, raise_statement; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:Exception; 16, argument_list; 16, 17; 17, string:'Supplied directory is not a tomodir!'; 18, if_statement; 18, 19; 18, 109; 18, 114; 19, parenthesized_expression; 19, 20; 20, boolean_operator:and; 20, 21; 20, 95; 21, boolean_operator:and; 21, 22; 21, 81; 22, boolean_operator:and; 22, 23; 22, 67; 23, boolean_operator:and; 23, 24; 23, 53; 24, boolean_operator:and; 24, 25; 24, 39; 25, call; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:os; 29, identifier:path; 30, identifier:isfile; 31, argument_list; 31, 32; 32, binary_operator:+; 32, 33; 32, 38; 33, binary_operator:+; 33, 34; 33, 35; 34, identifier:tomodir; 35, attribute; 35, 36; 35, 37; 36, identifier:os; 37, identifier:sep; 38, string:'config/config.dat'; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:os; 43, identifier:path; 44, identifier:isfile; 45, argument_list; 45, 46; 46, binary_operator:+; 46, 47; 46, 52; 47, binary_operator:+; 47, 48; 47, 49; 48, identifier:tomodir; 49, attribute; 49, 50; 49, 51; 50, identifier:os; 51, identifier:sep; 52, string:'rho/rho.dat'; 53, call; 53, 54; 53, 59; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:os; 57, identifier:path; 58, identifier:isfile; 59, argument_list; 59, 60; 60, binary_operator:+; 60, 61; 60, 66; 61, binary_operator:+; 61, 62; 61, 63; 62, identifier:tomodir; 63, attribute; 63, 64; 63, 65; 64, identifier:os; 65, identifier:sep; 66, string:'grid/elem.dat'; 67, call; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:os; 71, identifier:path; 72, identifier:isfile; 73, argument_list; 73, 74; 74, binary_operator:+; 74, 75; 74, 80; 75, binary_operator:+; 75, 76; 75, 77; 76, identifier:tomodir; 77, attribute; 77, 78; 77, 79; 78, identifier:os; 79, identifier:sep; 80, string:'grid/elec.dat'; 81, call; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:os; 85, identifier:path; 86, identifier:isfile; 87, argument_list; 87, 88; 88, binary_operator:+; 88, 89; 88, 94; 89, binary_operator:+; 89, 90; 89, 91; 90, identifier:tomodir; 91, attribute; 91, 92; 91, 93; 92, identifier:os; 93, identifier:sep; 94, string:'exe/crmod.cfg'; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:os; 99, identifier:path; 100, identifier:isfile; 101, argument_list; 101, 102; 102, binary_operator:+; 102, 103; 102, 108; 103, binary_operator:+; 103, 104; 103, 105; 104, identifier:tomodir; 105, attribute; 105, 106; 105, 107; 106, identifier:os; 107, identifier:sep; 108, string:'mod/volt.dat'; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:crmod_is_finished; 113, True; 114, else_clause; 114, 115; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:crmod_is_finished; 119, False; 120, if_statement; 120, 121; 120, 211; 120, 286; 121, parenthesized_expression; 121, 122; 122, boolean_operator:and; 122, 123; 122, 197; 123, boolean_operator:and; 123, 124; 123, 183; 124, boolean_operator:and; 124, 125; 124, 169; 125, boolean_operator:and; 125, 126; 125, 155; 126, boolean_operator:and; 126, 127; 126, 141; 127, call; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:os; 131, identifier:path; 132, identifier:isfile; 133, argument_list; 133, 134; 134, binary_operator:+; 134, 135; 134, 140; 135, binary_operator:+; 135, 136; 135, 137; 136, identifier:tomodir; 137, attribute; 137, 138; 137, 139; 138, identifier:os; 139, identifier:sep; 140, string:'grid/elem.dat'; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:os; 145, identifier:path; 146, identifier:isfile; 147, argument_list; 147, 148; 148, binary_operator:+; 148, 149; 148, 154; 149, binary_operator:+; 149, 150; 149, 151; 150, identifier:tomodir; 151, attribute; 151, 152; 151, 153; 152, identifier:os; 153, identifier:sep; 154, string:'grid/elec.dat'; 155, call; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:os; 159, identifier:path; 160, identifier:isfile; 161, argument_list; 161, 162; 162, binary_operator:+; 162, 163; 162, 168; 163, binary_operator:+; 163, 164; 163, 165; 164, identifier:tomodir; 165, attribute; 165, 166; 165, 167; 166, identifier:os; 167, identifier:sep; 168, string:'exe/crtomo.cfg'; 169, call; 169, 170; 169, 175; 170, attribute; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:os; 173, identifier:path; 174, identifier:isfile; 175, argument_list; 175, 176; 176, binary_operator:+; 176, 177; 176, 182; 177, binary_operator:+; 177, 178; 177, 179; 178, identifier:tomodir; 179, attribute; 179, 180; 179, 181; 180, identifier:os; 181, identifier:sep; 182, string:'inv/inv.ctr'; 183, call; 183, 184; 183, 189; 184, attribute; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:os; 187, identifier:path; 188, identifier:isfile; 189, argument_list; 189, 190; 190, binary_operator:+; 190, 191; 190, 196; 191, binary_operator:+; 191, 192; 191, 193; 192, identifier:tomodir; 193, attribute; 193, 194; 193, 195; 194, identifier:os; 195, identifier:sep; 196, string:'inv/run.ctr'; 197, call; 197, 198; 197, 203; 198, attribute; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:os; 201, identifier:path; 202, identifier:isfile; 203, argument_list; 203, 204; 204, binary_operator:+; 204, 205; 204, 210; 205, binary_operator:+; 205, 206; 205, 207; 206, identifier:tomodir; 207, attribute; 207, 208; 207, 209; 208, identifier:os; 209, identifier:sep; 210, string:'mod/volt.dat'; 211, block; 211, 212; 212, with_statement; 212, 213; 212, 229; 213, with_clause; 213, 214; 214, with_item; 214, 215; 215, as_pattern; 215, 216; 215, 227; 216, call; 216, 217; 216, 218; 217, identifier:open; 218, argument_list; 218, 219; 218, 226; 219, binary_operator:+; 219, 220; 219, 225; 220, binary_operator:+; 220, 221; 220, 222; 221, identifier:tomodir; 222, attribute; 222, 223; 222, 224; 223, identifier:os; 224, identifier:sep; 225, string:'inv/run.ctr'; 226, string:'r'; 227, as_pattern_target; 227, 228; 228, identifier:fid; 229, block; 229, 230; 229, 238; 229, 242; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:lines; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:fid; 236, identifier:readlines; 237, argument_list; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:crtomo_is_finished; 241, False; 242, for_statement; 242, 243; 242, 244; 242, 250; 243, identifier:line; 244, subscript; 244, 245; 244, 246; 245, identifier:lines; 246, slice; 246, 247; 246, 249; 247, unary_operator:-; 247, 248; 248, integer:5; 249, colon; 250, block; 250, 251; 250, 259; 250, 268; 250, 277; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:test_line; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:line; 257, identifier:strip; 258, argument_list; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:regex; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:re; 265, identifier:compile; 266, argument_list; 266, 267; 267, string:'CPU'; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:result; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:regex; 274, identifier:match; 275, argument_list; 275, 276; 276, identifier:test_line; 277, if_statement; 277, 278; 277, 281; 278, comparison_operator:is; 278, 279; 278, 280; 279, identifier:result; 280, None; 281, block; 281, 282; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 285; 284, identifier:crtomo_is_finished; 285, True; 286, else_clause; 286, 287; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:crtomo_is_finished; 291, False; 292, return_statement; 292, 293; 293, expression_list; 293, 294; 293, 295; 294, identifier:crmod_is_finished; 295, identifier:crtomo_is_finished | def td_is_finished(tomodir):
if not is_tomodir(tomodir):
raise Exception('Supplied directory is not a tomodir!')
if(os.path.isfile(tomodir + os.sep + 'config/config.dat') and
os.path.isfile(tomodir + os.sep + 'rho/rho.dat') and
os.path.isfile(tomodir + os.sep + 'grid/elem.dat') and
os.path.isfile(tomodir + os.sep + 'grid/elec.dat') and
os.path.isfile(tomodir + os.sep + 'exe/crmod.cfg') and
os.path.isfile(tomodir + os.sep + 'mod/volt.dat')):
crmod_is_finished = True
else:
crmod_is_finished = False
if(os.path.isfile(tomodir + os.sep + 'grid/elem.dat') and
os.path.isfile(tomodir + os.sep + 'grid/elec.dat') and
os.path.isfile(tomodir + os.sep + 'exe/crtomo.cfg') and
os.path.isfile(tomodir + os.sep + 'inv/inv.ctr') and
os.path.isfile(tomodir + os.sep + 'inv/run.ctr') and
os.path.isfile(tomodir + os.sep + 'mod/volt.dat')):
with open(tomodir + os.sep + 'inv/run.ctr', 'r') as fid:
lines = fid.readlines()
crtomo_is_finished = False
for line in lines[-5:]:
test_line = line.strip()
regex = re.compile('CPU')
result = regex.match(test_line)
if result is not None:
crtomo_is_finished = True
else:
crtomo_is_finished = False
return crmod_is_finished, crtomo_is_finished |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sipdir_is_finished; 3, parameters; 3, 4; 4, identifier:sipdir; 5, block; 5, 6; 5, 18; 5, 42; 5, 59; 5, 63; 5, 67; 5, 96; 6, if_statement; 6, 7; 6, 12; 7, not_operator; 7, 8; 8, call; 8, 9; 8, 10; 9, identifier:is_sipdir; 10, argument_list; 10, 11; 11, identifier:sipdir; 12, block; 12, 13; 13, raise_statement; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:Exception; 16, argument_list; 16, 17; 17, string:'Directory is not a valid SIP directory!'; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:subdirs_raw; 21, call; 21, 22; 21, 23; 22, identifier:sorted; 23, argument_list; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:glob; 27, identifier:glob; 28, argument_list; 28, 29; 29, binary_operator:+; 29, 30; 29, 41; 30, binary_operator:+; 30, 31; 30, 38; 31, binary_operator:+; 31, 32; 31, 37; 32, binary_operator:+; 32, 33; 32, 34; 33, identifier:sipdir; 34, attribute; 34, 35; 34, 36; 35, identifier:os; 36, identifier:sep; 37, string:'invmod'; 38, attribute; 38, 39; 38, 40; 39, identifier:os; 40, identifier:sep; 41, string:'*'; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:subdirs; 45, list_comprehension; 45, 46; 45, 47; 45, 50; 46, identifier:x; 47, for_in_clause; 47, 48; 47, 49; 48, identifier:x; 49, identifier:subdirs_raw; 50, if_clause; 50, 51; 51, call; 51, 52; 51, 57; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:os; 55, identifier:path; 56, identifier:isdir; 57, argument_list; 57, 58; 58, identifier:x; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:crmod_finished; 62, True; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:crtomo_finished; 66, True; 67, for_statement; 67, 68; 67, 69; 67, 70; 68, identifier:subdir; 69, identifier:subdirs; 70, block; 70, 71; 70, 80; 70, 88; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 76; 73, pattern_list; 73, 74; 73, 75; 74, identifier:subcrmod; 75, identifier:subcrtomo; 76, call; 76, 77; 76, 78; 77, identifier:td_is_finished; 78, argument_list; 78, 79; 79, identifier:subdir; 80, if_statement; 80, 81; 80, 83; 81, not_operator; 81, 82; 82, identifier:subcrmod; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:crmod_finished; 87, False; 88, if_statement; 88, 89; 88, 91; 89, not_operator; 89, 90; 90, identifier:subcrtomo; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:crtomo_finished; 95, False; 96, return_statement; 96, 97; 97, expression_list; 97, 98; 97, 99; 98, identifier:crmod_finished; 99, identifier:crtomo_finished | def sipdir_is_finished(sipdir):
if not is_sipdir(sipdir):
raise Exception('Directory is not a valid SIP directory!')
subdirs_raw = sorted(glob.glob(sipdir + os.sep + 'invmod' + os.sep + '*'))
subdirs = [x for x in subdirs_raw if os.path.isdir(x)]
crmod_finished = True
crtomo_finished = True
for subdir in subdirs:
subcrmod, subcrtomo = td_is_finished(subdir)
if not subcrmod:
crmod_finished = False
if not subcrtomo:
crtomo_finished = False
return crmod_finished, crtomo_finished |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 38; 2, function_name:list; 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; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:source_ids; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:seniority; 10, string:"all"; 11, default_parameter; 11, 12; 11, 13; 12, identifier:stage; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:date_start; 16, string:"1494539999"; 17, default_parameter; 17, 18; 17, 19; 18, identifier:date_end; 19, identifier:TIMESTAMP_NOW; 20, default_parameter; 20, 21; 20, 22; 21, identifier:filter_id; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:page; 25, integer:1; 26, default_parameter; 26, 27; 26, 28; 27, identifier:limit; 28, integer:30; 29, default_parameter; 29, 30; 29, 31; 30, identifier:sort_by; 31, string:'ranking'; 32, default_parameter; 32, 33; 32, 34; 33, identifier:filter_reference; 34, None; 35, default_parameter; 35, 36; 35, 37; 36, identifier:order_by; 37, None; 38, block; 38, 39; 38, 43; 38, 53; 38, 63; 38, 75; 38, 87; 38, 96; 38, 105; 38, 114; 38, 123; 38, 137; 38, 146; 38, 152; 38, 164; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:query_params; 42, dictionary; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:query_params; 47, string:"date_end"; 48, call; 48, 49; 48, 50; 49, identifier:_validate_timestamp; 50, argument_list; 50, 51; 50, 52; 51, identifier:date_end; 52, string:"date_end"; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:query_params; 57, string:"date_start"; 58, call; 58, 59; 58, 60; 59, identifier:_validate_timestamp; 60, argument_list; 60, 61; 60, 62; 61, identifier:date_start; 62, string:"date_start"; 63, if_statement; 63, 64; 63, 65; 64, identifier:filter_id; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:query_params; 70, string:"filter_id"; 71, call; 71, 72; 71, 73; 72, identifier:_validate_filter_id; 73, argument_list; 73, 74; 74, identifier:filter_id; 75, if_statement; 75, 76; 75, 77; 76, identifier:filter_reference; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, subscript; 80, 81; 80, 82; 81, identifier:query_params; 82, string:"filter_reference"; 83, call; 83, 84; 83, 85; 84, identifier:_validate_filter_reference; 85, argument_list; 85, 86; 86, identifier:filter_reference; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:query_params; 91, string:"limit"; 92, call; 92, 93; 92, 94; 93, identifier:_validate_limit; 94, argument_list; 94, 95; 95, identifier:limit; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, subscript; 98, 99; 98, 100; 99, identifier:query_params; 100, string:"page"; 101, call; 101, 102; 101, 103; 102, identifier:_validate_page; 103, argument_list; 103, 104; 104, identifier:page; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 110; 107, subscript; 107, 108; 107, 109; 108, identifier:query_params; 109, string:"seniority"; 110, call; 110, 111; 110, 112; 111, identifier:_validate_seniority; 112, argument_list; 112, 113; 113, identifier:seniority; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 119; 116, subscript; 116, 117; 116, 118; 117, identifier:query_params; 118, string:"sort_by"; 119, call; 119, 120; 119, 121; 120, identifier:_validate_sort_by; 121, argument_list; 121, 122; 122, identifier:sort_by; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:query_params; 127, string:"source_ids"; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:json; 131, identifier:dumps; 132, argument_list; 132, 133; 133, call; 133, 134; 133, 135; 134, identifier:_validate_source_ids; 135, argument_list; 135, 136; 136, identifier:source_ids; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:query_params; 141, string:"stage"; 142, call; 142, 143; 142, 144; 143, identifier:_validate_stage; 144, argument_list; 144, 145; 145, identifier:stage; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:query_params; 150, string:"order_by"; 151, identifier:order_by; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:response; 155, call; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:client; 160, identifier:get; 161, argument_list; 161, 162; 161, 163; 162, string:"profiles"; 163, identifier:query_params; 164, return_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:response; 168, identifier:json; 169, argument_list | def list(self, source_ids=None, seniority="all", stage=None,
date_start="1494539999", date_end=TIMESTAMP_NOW, filter_id=None,
page=1, limit=30, sort_by='ranking', filter_reference=None, order_by=None):
query_params = {}
query_params["date_end"] = _validate_timestamp(date_end, "date_end")
query_params["date_start"] = _validate_timestamp(date_start, "date_start")
if filter_id:
query_params["filter_id"] = _validate_filter_id(filter_id)
if filter_reference:
query_params["filter_reference"] = _validate_filter_reference(filter_reference)
query_params["limit"] = _validate_limit(limit)
query_params["page"] = _validate_page(page)
query_params["seniority"] = _validate_seniority(seniority)
query_params["sort_by"] = _validate_sort_by(sort_by)
query_params["source_ids"] = json.dumps(_validate_source_ids(source_ids))
query_params["stage"] = _validate_stage(stage)
query_params["order_by"] = order_by
response = self.client.get("profiles", query_params)
return response.json() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:iterdupes; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:compare; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:filt; 10, None; 11, block; 11, 12; 11, 14; 11, 24; 11, 28; 11, 32; 11, 46; 12, expression_statement; 12, 13; 13, string:''' streaming item iterator with low overhead duplicate file detection
Parameters:
- compare compare function between files (defaults to md5sum)
'''; 14, if_statement; 14, 15; 14, 17; 15, not_operator; 15, 16; 16, identifier:compare; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:compare; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:md5sum; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:seen_siz; 27, dictionary; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:seen_sum; 31, dictionary; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:size_func; 35, lambda; 35, 36; 35, 38; 36, lambda_parameters; 36, 37; 37, identifier:x; 38, attribute; 38, 39; 38, 45; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:os; 42, identifier:stat; 43, argument_list; 43, 44; 44, identifier:x; 45, identifier:st_size; 46, for_statement; 46, 47; 46, 50; 46, 64; 47, tuple_pattern; 47, 48; 47, 49; 48, identifier:fsize; 49, identifier:f; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:iteritems; 54, argument_list; 54, 55; 54, 58; 54, 61; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:want_dirs; 57, False; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:func; 60, identifier:size_func; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:filt; 63, identifier:filt; 64, block; 64, 65; 65, if_statement; 65, 66; 65, 69; 65, 77; 66, comparison_operator:not; 66, 67; 66, 68; 67, identifier:fsize; 68, identifier:seen_siz; 69, block; 69, 70; 69, 76; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 75; 72, subscript; 72, 73; 72, 74; 73, identifier:seen_siz; 74, identifier:fsize; 75, identifier:f; 76, continue_statement; 77, else_clause; 77, 78; 78, block; 78, 79; 78, 121; 78, 128; 79, if_statement; 79, 80; 79, 83; 80, subscript; 80, 81; 80, 82; 81, identifier:seen_siz; 82, identifier:fsize; 83, block; 83, 84; 83, 93; 83, 115; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:chksum; 87, call; 87, 88; 87, 89; 88, identifier:compare; 89, argument_list; 89, 90; 90, subscript; 90, 91; 90, 92; 91, identifier:seen_siz; 92, identifier:fsize; 93, if_statement; 93, 94; 93, 97; 93, 105; 94, comparison_operator:in; 94, 95; 94, 96; 95, identifier:chksum; 96, identifier:seen_sum; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, yield; 99, 100; 100, tuple; 100, 101; 100, 102; 101, identifier:chksum; 102, subscript; 102, 103; 102, 104; 103, identifier:seen_siz; 104, identifier:fsize; 105, else_clause; 105, 106; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 112; 109, subscript; 109, 110; 109, 111; 110, identifier:seen_sum; 111, identifier:chksum; 112, subscript; 112, 113; 112, 114; 113, identifier:seen_siz; 114, identifier:fsize; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 120; 117, subscript; 117, 118; 117, 119; 118, identifier:seen_siz; 119, identifier:fsize; 120, None; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:chksum; 124, call; 124, 125; 124, 126; 125, identifier:compare; 126, argument_list; 126, 127; 127, identifier:f; 128, if_statement; 128, 129; 128, 132; 128, 156; 129, comparison_operator:in; 129, 130; 129, 131; 130, identifier:chksum; 131, identifier:seen_sum; 132, block; 132, 133; 132, 151; 133, if_statement; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:seen_sum; 136, identifier:chksum; 137, block; 137, 138; 137, 145; 138, expression_statement; 138, 139; 139, yield; 139, 140; 140, tuple; 140, 141; 140, 142; 141, identifier:chksum; 142, subscript; 142, 143; 142, 144; 143, identifier:seen_sum; 144, identifier:chksum; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 150; 147, subscript; 147, 148; 147, 149; 148, identifier:seen_sum; 149, identifier:chksum; 150, None; 151, expression_statement; 151, 152; 152, yield; 152, 153; 153, tuple; 153, 154; 153, 155; 154, identifier:chksum; 155, identifier:f; 156, else_clause; 156, 157; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 163; 160, subscript; 160, 161; 160, 162; 161, identifier:seen_sum; 162, identifier:chksum; 163, identifier:f | def iterdupes(self, compare=None, filt=None):
''' streaming item iterator with low overhead duplicate file detection
Parameters:
- compare compare function between files (defaults to md5sum)
'''
if not compare: compare = self.md5sum
seen_siz = {}
seen_sum = {}
size_func = lambda x: os.stat(x).st_size
for (fsize, f) in self.iteritems(want_dirs=False, func=size_func, filt=filt):
if fsize not in seen_siz:
seen_siz[fsize] = f
continue
else:
if seen_siz[fsize]:
chksum = compare(seen_siz[fsize])
if chksum in seen_sum: yield (chksum, seen_siz[fsize])
else: seen_sum[chksum] = seen_siz[fsize]
seen_siz[fsize] = None
chksum = compare(f)
if chksum in seen_sum:
if seen_sum[chksum]:
yield (chksum, seen_sum[chksum])
seen_sum[chksum] = None
yield (chksum, f)
else:
seen_sum[chksum] = f |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 1, 10; 2, function_name:objects_to_root; 3, parameters; 3, 4; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:objects; 6, type; 6, 7; 7, identifier:List; 8, type; 8, 9; 9, identifier:Root; 10, block; 10, 11; 10, 118; 10, 192; 10, 199; 11, function_definition; 11, 12; 11, 13; 11, 18; 11, 20; 12, function_name:_to_tree; 13, parameters; 13, 14; 14, typed_parameter; 14, 15; 14, 16; 15, identifier:objs; 16, type; 16, 17; 17, identifier:Iterable; 18, type; 18, 19; 19, identifier:Dict; 20, block; 20, 21; 20, 25; 20, 116; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:path_tree; 24, dictionary; 25, for_statement; 25, 26; 25, 27; 25, 28; 26, identifier:obj; 27, identifier:objs; 28, block; 28, 29; 28, 40; 28, 57; 28, 64; 28, 68; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:is_dir; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:obj; 36, identifier:key; 37, identifier:endswith; 38, argument_list; 38, 39; 39, string:'/'; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:chunks; 43, list_comprehension; 43, 44; 43, 45; 43, 55; 44, identifier:chunk; 45, for_in_clause; 45, 46; 45, 47; 46, identifier:chunk; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:obj; 51, identifier:key; 52, identifier:split; 53, argument_list; 53, 54; 54, string:'/'; 55, if_clause; 55, 56; 56, identifier:chunk; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:chunk_count; 60, call; 60, 61; 60, 62; 61, identifier:len; 62, argument_list; 62, 63; 63, identifier:chunks; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:tmp; 67, identifier:path_tree; 68, for_statement; 68, 69; 68, 72; 68, 76; 69, pattern_list; 69, 70; 69, 71; 70, identifier:i; 71, identifier:chunk; 72, call; 72, 73; 72, 74; 73, identifier:enumerate; 74, argument_list; 74, 75; 75, identifier:chunks; 76, block; 76, 77; 76, 85; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:is_last_chunk; 80, comparison_operator:==; 80, 81; 80, 82; 81, identifier:i; 82, binary_operator:-; 82, 83; 82, 84; 83, identifier:chunk_count; 84, integer:1; 85, if_statement; 85, 86; 85, 90; 85, 97; 86, boolean_operator:and; 86, 87; 86, 88; 87, identifier:is_last_chunk; 88, not_operator; 88, 89; 89, identifier:is_dir; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, subscript; 93, 94; 93, 95; 94, identifier:tmp; 95, identifier:chunk; 96, identifier:obj; 97, else_clause; 97, 98; 98, block; 98, 99; 98, 110; 99, if_statement; 99, 100; 99, 103; 100, comparison_operator:not; 100, 101; 100, 102; 101, identifier:chunk; 102, identifier:tmp; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:tmp; 108, identifier:chunk; 109, dictionary; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:tmp; 113, subscript; 113, 114; 113, 115; 114, identifier:tmp; 115, identifier:chunk; 116, return_statement; 116, 117; 117, identifier:path_tree; 118, function_definition; 118, 119; 118, 120; 118, 135; 118, 137; 119, function_name:_to_entity; 120, parameters; 120, 121; 120, 125; 121, typed_parameter; 121, 122; 121, 123; 122, identifier:key; 123, type; 123, 124; 124, identifier:str; 125, typed_parameter; 125, 126; 125, 127; 126, identifier:value; 127, type; 127, 128; 128, generic_type; 128, 129; 128, 130; 129, identifier:Union; 130, type_parameter; 130, 131; 130, 133; 131, type; 131, 132; 132, identifier:Dict; 133, type; 133, 134; 134, identifier:Any; 135, type; 135, 136; 136, identifier:Entity; 137, block; 137, 138; 137, 167; 138, if_statement; 138, 139; 138, 144; 139, call; 139, 140; 139, 141; 140, identifier:isinstance; 141, argument_list; 141, 142; 141, 143; 142, identifier:value; 143, identifier:dict; 144, block; 144, 145; 145, return_statement; 145, 146; 146, call; 146, 147; 146, 148; 147, identifier:Directory; 148, argument_list; 148, 149; 148, 150; 149, identifier:key; 150, dictionary_comprehension; 150, 151; 150, 158; 151, pair; 151, 152; 151, 153; 152, identifier:key_; 153, call; 153, 154; 153, 155; 154, identifier:_to_entity; 155, argument_list; 155, 156; 155, 157; 156, identifier:key_; 157, identifier:value_; 158, for_in_clause; 158, 159; 158, 162; 159, pattern_list; 159, 160; 159, 161; 160, identifier:key_; 161, identifier:value_; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:value; 165, identifier:items; 166, argument_list; 167, return_statement; 167, 168; 168, call; 168, 169; 168, 170; 169, identifier:File; 170, argument_list; 170, 171; 170, 181; 170, 184; 171, attribute; 171, 172; 171, 180; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:pathlib; 175, identifier:PurePath; 176, argument_list; 176, 177; 177, attribute; 177, 178; 177, 179; 178, identifier:value; 179, identifier:key; 180, identifier:name; 181, attribute; 181, 182; 181, 183; 182, identifier:value; 183, identifier:size; 184, call; 184, 185; 184, 190; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:value; 188, identifier:e_tag; 189, identifier:strip; 190, argument_list; 190, 191; 191, string:'"'; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:tree; 195, call; 195, 196; 195, 197; 196, identifier:_to_tree; 197, argument_list; 197, 198; 198, identifier:objects; 199, return_statement; 199, 200; 200, call; 200, 201; 200, 202; 201, identifier:Root; 202, argument_list; 202, 203; 203, dictionary_comprehension; 203, 204; 203, 218; 204, pair; 204, 205; 204, 213; 205, attribute; 205, 206; 205, 212; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:pathlib; 209, identifier:PurePath; 210, argument_list; 210, 211; 211, identifier:key; 212, identifier:name; 213, call; 213, 214; 213, 215; 214, identifier:_to_entity; 215, argument_list; 215, 216; 215, 217; 216, identifier:key; 217, identifier:value; 218, for_in_clause; 218, 219; 218, 222; 219, pattern_list; 219, 220; 219, 221; 220, identifier:key; 221, identifier:value; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:tree; 225, identifier:items; 226, argument_list | def objects_to_root(objects: List) -> Root:
def _to_tree(objs: Iterable) -> Dict:
path_tree = {}
for obj in objs:
is_dir = obj.key.endswith('/')
chunks = [chunk for chunk in obj.key.split('/') if chunk]
chunk_count = len(chunks)
tmp = path_tree
for i, chunk in enumerate(chunks):
is_last_chunk = i == chunk_count - 1
if is_last_chunk and not is_dir:
tmp[chunk] = obj
else:
if chunk not in tmp:
tmp[chunk] = {}
tmp = tmp[chunk]
return path_tree
def _to_entity(key: str, value: Union[Dict, Any]) -> Entity:
if isinstance(value, dict):
return Directory(
key,
{key_: _to_entity(key_, value_)
for key_, value_ in value.items()})
return File(pathlib.PurePath(value.key).name, value.size,
value.e_tag.strip('"'))
tree = _to_tree(objects)
return Root({pathlib.PurePath(key).name: _to_entity(key, value)
for key, value in tree.items()}) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:parse; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:xml_file; 6, block; 6, 7; 6, 9; 6, 13; 6, 34; 6, 337; 7, expression_statement; 7, 8; 8, string:"Get a list of parsed recipes from BeerXML input"; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:recipes; 12, list:[]; 13, with_statement; 13, 14; 13, 24; 14, with_clause; 14, 15; 15, with_item; 15, 16; 16, as_pattern; 16, 17; 16, 22; 17, call; 17, 18; 17, 19; 18, identifier:open; 19, argument_list; 19, 20; 19, 21; 20, identifier:xml_file; 21, string:"rt"; 22, as_pattern_target; 22, 23; 23, identifier:f; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:tree; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:ElementTree; 31, identifier:parse; 32, argument_list; 32, 33; 33, identifier:f; 34, for_statement; 34, 35; 34, 36; 34, 41; 35, identifier:recipeNode; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:tree; 39, identifier:iter; 40, argument_list; 41, block; 41, 42; 41, 55; 41, 61; 41, 68; 42, if_statement; 42, 43; 42, 53; 43, comparison_operator:!=; 43, 44; 43, 52; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:to_lower; 48, argument_list; 48, 49; 49, attribute; 49, 50; 49, 51; 50, identifier:recipeNode; 51, identifier:tag; 52, string:"recipe"; 53, block; 53, 54; 54, continue_statement; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:recipe; 58, call; 58, 59; 58, 60; 59, identifier:Recipe; 60, argument_list; 61, expression_statement; 61, 62; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:recipes; 65, identifier:append; 66, argument_list; 66, 67; 67, identifier:recipe; 68, for_statement; 68, 69; 68, 70; 68, 74; 69, identifier:recipeProperty; 70, call; 70, 71; 70, 72; 71, identifier:list; 72, argument_list; 72, 73; 73, identifier:recipeNode; 74, block; 74, 75; 74, 86; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:tag_name; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:to_lower; 82, argument_list; 82, 83; 83, attribute; 83, 84; 83, 85; 84, identifier:recipeProperty; 85, identifier:tag; 86, if_statement; 86, 87; 86, 90; 86, 121; 86, 156; 86, 191; 86, 226; 86, 251; 86, 327; 87, comparison_operator:==; 87, 88; 87, 89; 88, identifier:tag_name; 89, string:"fermentables"; 90, block; 90, 91; 91, for_statement; 91, 92; 91, 93; 91, 97; 92, identifier:fermentable_node; 93, call; 93, 94; 93, 95; 94, identifier:list; 95, argument_list; 95, 96; 96, identifier:recipeProperty; 97, block; 97, 98; 97, 104; 97, 112; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:fermentable; 101, call; 101, 102; 101, 103; 102, identifier:Fermentable; 103, argument_list; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:nodes_to_object; 109, argument_list; 109, 110; 109, 111; 110, identifier:fermentable_node; 111, identifier:fermentable; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 119; 114, attribute; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:recipe; 117, identifier:fermentables; 118, identifier:append; 119, argument_list; 119, 120; 120, identifier:fermentable; 121, elif_clause; 121, 122; 121, 125; 122, comparison_operator:==; 122, 123; 122, 124; 123, identifier:tag_name; 124, string:"yeasts"; 125, block; 125, 126; 126, for_statement; 126, 127; 126, 128; 126, 132; 127, identifier:yeast_node; 128, call; 128, 129; 128, 130; 129, identifier:list; 130, argument_list; 130, 131; 131, identifier:recipeProperty; 132, block; 132, 133; 132, 139; 132, 147; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:yeast; 136, call; 136, 137; 136, 138; 137, identifier:Yeast; 138, argument_list; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:nodes_to_object; 144, argument_list; 144, 145; 144, 146; 145, identifier:yeast_node; 146, identifier:yeast; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 154; 149, attribute; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:recipe; 152, identifier:yeasts; 153, identifier:append; 154, argument_list; 154, 155; 155, identifier:yeast; 156, elif_clause; 156, 157; 156, 160; 157, comparison_operator:==; 157, 158; 157, 159; 158, identifier:tag_name; 159, string:"hops"; 160, block; 160, 161; 161, for_statement; 161, 162; 161, 163; 161, 167; 162, identifier:hop_node; 163, call; 163, 164; 163, 165; 164, identifier:list; 165, argument_list; 165, 166; 166, identifier:recipeProperty; 167, block; 167, 168; 167, 174; 167, 182; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:hop; 171, call; 171, 172; 171, 173; 172, identifier:Hop; 173, argument_list; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:nodes_to_object; 179, argument_list; 179, 180; 179, 181; 180, identifier:hop_node; 181, identifier:hop; 182, expression_statement; 182, 183; 183, call; 183, 184; 183, 189; 184, attribute; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:recipe; 187, identifier:hops; 188, identifier:append; 189, argument_list; 189, 190; 190, identifier:hop; 191, elif_clause; 191, 192; 191, 195; 192, comparison_operator:==; 192, 193; 192, 194; 193, identifier:tag_name; 194, string:"miscs"; 195, block; 195, 196; 196, for_statement; 196, 197; 196, 198; 196, 202; 197, identifier:misc_node; 198, call; 198, 199; 198, 200; 199, identifier:list; 200, argument_list; 200, 201; 201, identifier:recipeProperty; 202, block; 202, 203; 202, 209; 202, 217; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:misc; 206, call; 206, 207; 206, 208; 207, identifier:Misc; 208, argument_list; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:self; 213, identifier:nodes_to_object; 214, argument_list; 214, 215; 214, 216; 215, identifier:misc_node; 216, identifier:misc; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 224; 219, attribute; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:recipe; 222, identifier:miscs; 223, identifier:append; 224, argument_list; 224, 225; 225, identifier:misc; 226, elif_clause; 226, 227; 226, 230; 227, comparison_operator:==; 227, 228; 227, 229; 228, identifier:tag_name; 229, string:"style"; 230, block; 230, 231; 230, 237; 230, 243; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:style; 234, call; 234, 235; 234, 236; 235, identifier:Style; 236, argument_list; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:recipe; 241, identifier:style; 242, identifier:style; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:self; 247, identifier:nodes_to_object; 248, argument_list; 248, 249; 248, 250; 249, identifier:recipeProperty; 250, identifier:style; 251, elif_clause; 251, 252; 251, 255; 252, comparison_operator:==; 252, 253; 252, 254; 253, identifier:tag_name; 254, string:"mash"; 255, block; 255, 256; 256, for_statement; 256, 257; 256, 258; 256, 262; 257, identifier:mash_node; 258, call; 258, 259; 258, 260; 259, identifier:list; 260, argument_list; 260, 261; 261, identifier:recipeProperty; 262, block; 262, 263; 262, 269; 262, 275; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 266; 265, identifier:mash; 266, call; 266, 267; 266, 268; 267, identifier:Mash; 268, argument_list; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:recipe; 273, identifier:mash; 274, identifier:mash; 275, if_statement; 275, 276; 275, 286; 275, 317; 276, comparison_operator:==; 276, 277; 276, 285; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:self; 280, identifier:to_lower; 281, argument_list; 281, 282; 282, attribute; 282, 283; 282, 284; 283, identifier:mash_node; 284, identifier:tag; 285, string:"mash_steps"; 286, block; 286, 287; 287, for_statement; 287, 288; 287, 289; 287, 293; 288, identifier:mash_step_node; 289, call; 289, 290; 289, 291; 290, identifier:list; 291, argument_list; 291, 292; 292, identifier:mash_node; 293, block; 293, 294; 293, 300; 293, 308; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:mash_step; 297, call; 297, 298; 297, 299; 298, identifier:MashStep; 299, argument_list; 300, expression_statement; 300, 301; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:self; 304, identifier:nodes_to_object; 305, argument_list; 305, 306; 305, 307; 306, identifier:mash_step_node; 307, identifier:mash_step; 308, expression_statement; 308, 309; 309, call; 309, 310; 309, 315; 310, attribute; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:mash; 313, identifier:steps; 314, identifier:append; 315, argument_list; 315, 316; 316, identifier:mash_step; 317, else_clause; 317, 318; 318, block; 318, 319; 319, expression_statement; 319, 320; 320, call; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:self; 323, identifier:nodes_to_object; 324, argument_list; 324, 325; 324, 326; 325, identifier:mash_node; 326, identifier:mash; 327, else_clause; 327, 328; 328, block; 328, 329; 329, expression_statement; 329, 330; 330, call; 330, 331; 330, 334; 331, attribute; 331, 332; 331, 333; 332, identifier:self; 333, identifier:node_to_object; 334, argument_list; 334, 335; 334, 336; 335, identifier:recipeProperty; 336, identifier:recipe; 337, return_statement; 337, 338; 338, identifier:recipes | def parse(self, xml_file):
"Get a list of parsed recipes from BeerXML input"
recipes = []
with open(xml_file, "rt") as f:
tree = ElementTree.parse(f)
for recipeNode in tree.iter():
if self.to_lower(recipeNode.tag) != "recipe":
continue
recipe = Recipe()
recipes.append(recipe)
for recipeProperty in list(recipeNode):
tag_name = self.to_lower(recipeProperty.tag)
if tag_name == "fermentables":
for fermentable_node in list(recipeProperty):
fermentable = Fermentable()
self.nodes_to_object(fermentable_node, fermentable)
recipe.fermentables.append(fermentable)
elif tag_name == "yeasts":
for yeast_node in list(recipeProperty):
yeast = Yeast()
self.nodes_to_object(yeast_node, yeast)
recipe.yeasts.append(yeast)
elif tag_name == "hops":
for hop_node in list(recipeProperty):
hop = Hop()
self.nodes_to_object(hop_node, hop)
recipe.hops.append(hop)
elif tag_name == "miscs":
for misc_node in list(recipeProperty):
misc = Misc()
self.nodes_to_object(misc_node, misc)
recipe.miscs.append(misc)
elif tag_name == "style":
style = Style()
recipe.style = style
self.nodes_to_object(recipeProperty, style)
elif tag_name == "mash":
for mash_node in list(recipeProperty):
mash = Mash()
recipe.mash = mash
if self.to_lower(mash_node.tag) == "mash_steps":
for mash_step_node in list(mash_node):
mash_step = MashStep()
self.nodes_to_object(mash_step_node, mash_step)
mash.steps.append(mash_step)
else:
self.nodes_to_object(mash_node, mash)
else:
self.node_to_object(recipeProperty, recipe)
return recipes |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_parse_extra; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:fp; 6, block; 6, 7; 6, 11; 6, 15; 6, 22; 6, 146; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:comment; 10, string:''; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:section; 14, string:''; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:fp; 19, identifier:seek; 20, argument_list; 20, 21; 21, integer:0; 22, for_statement; 22, 23; 22, 24; 22, 25; 23, identifier:line; 24, identifier:fp; 25, block; 25, 26; 25, 34; 25, 46; 25, 142; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:line; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:line; 32, identifier:rstrip; 33, argument_list; 34, if_statement; 34, 35; 34, 37; 35, not_operator; 35, 36; 36, identifier:line; 37, block; 37, 38; 37, 45; 38, if_statement; 38, 39; 38, 40; 39, identifier:comment; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, augmented_assignment:+=; 42, 43; 42, 44; 43, identifier:comment; 44, string:'\n'; 45, continue_statement; 46, if_statement; 46, 47; 46, 50; 46, 61; 46, 93; 47, attribute; 47, 48; 47, 49; 48, identifier:line; 49, identifier:startswith; 50, ERROR; 50, 51; 50, 52; 50, 55; 51, string:'
comment += line + '; 52, ERROR; 52, 53; 52, 54; 53, escape_sequence:\n; 54, identifier:continue; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:line; 58, identifier:startswith; 59, argument_list; 59, 60; 60, string:'['; 61, block; 61, 62; 61, 71; 61, 78; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:section; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:line; 68, identifier:strip; 69, argument_list; 69, 70; 70, string:'[]'; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:_add_dot_key; 76, argument_list; 76, 77; 77, identifier:section; 78, if_statement; 78, 79; 78, 80; 79, identifier:comment; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 88; 83, subscript; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:_comments; 87, identifier:section; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:comment; 91, identifier:rstrip; 92, argument_list; 93, elif_clause; 93, 94; 93, 100; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:CONFIG_KEY_RE; 97, identifier:match; 98, argument_list; 98, 99; 99, identifier:line; 100, block; 100, 101; 100, 117; 100, 125; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:key; 104, call; 104, 105; 104, 116; 105, attribute; 105, 106; 105, 115; 106, subscript; 106, 107; 106, 114; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:line; 110, identifier:split; 111, argument_list; 111, 112; 111, 113; 112, string:'='; 113, integer:1; 114, integer:0; 115, identifier:strip; 116, argument_list; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:_add_dot_key; 122, argument_list; 122, 123; 122, 124; 123, identifier:section; 124, identifier:key; 125, if_statement; 125, 126; 125, 127; 126, identifier:comment; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 137; 130, subscript; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:_comments; 134, tuple; 134, 135; 134, 136; 135, identifier:section; 136, identifier:key; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:comment; 140, identifier:rstrip; 141, argument_list; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:comment; 145, string:''; 146, if_statement; 146, 147; 146, 148; 147, identifier:comment; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 158; 151, subscript; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:_comments; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:LAST_COMMENT_KEY; 158, identifier:comment | def _parse_extra(self, fp):
comment = ''
section = ''
fp.seek(0)
for line in fp:
line = line.rstrip()
if not line:
if comment:
comment += '\n'
continue
if line.startswith('
comment += line + '\n'
continue
if line.startswith('['):
section = line.strip('[]')
self._add_dot_key(section)
if comment:
self._comments[section] = comment.rstrip()
elif CONFIG_KEY_RE.match(line):
key = line.split('=', 1)[0].strip()
self._add_dot_key(section, key)
if comment:
self._comments[(section, key)] = comment.rstrip()
comment = ''
if comment:
self._comments[self.LAST_COMMENT_KEY] = comment |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 43; 1, 47; 2, function_name:_sample_action_fluent; 3, parameters; 3, 4; 3, 5; 3, 9; 3, 15; 3, 23; 3, 33; 3, 39; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:name; 7, type; 7, 8; 8, identifier:str; 9, typed_parameter; 9, 10; 9, 11; 10, identifier:dtype; 11, type; 11, 12; 12, attribute; 12, 13; 12, 14; 13, identifier:tf; 14, identifier:DType; 15, typed_parameter; 15, 16; 15, 17; 16, identifier:size; 17, type; 17, 18; 18, generic_type; 18, 19; 18, 20; 19, identifier:Sequence; 20, type_parameter; 20, 21; 21, type; 21, 22; 22, identifier:int; 23, typed_parameter; 23, 24; 23, 25; 24, identifier:constraints; 25, type; 25, 26; 26, generic_type; 26, 27; 26, 28; 27, identifier:Dict; 28, type_parameter; 28, 29; 28, 31; 29, type; 29, 30; 30, identifier:str; 31, type; 31, 32; 32, identifier:Constraints; 33, typed_parameter; 33, 34; 33, 35; 34, identifier:default_value; 35, type; 35, 36; 36, attribute; 36, 37; 36, 38; 37, identifier:tf; 38, identifier:Tensor; 39, typed_parameter; 39, 40; 39, 41; 40, identifier:prob; 41, type; 41, 42; 42, identifier:float; 43, type; 43, 44; 44, attribute; 44, 45; 44, 46; 45, identifier:tf; 46, identifier:Tensor; 47, block; 47, 48; 47, 50; 47, 62; 47, 364; 47, 387; 47, 398; 48, expression_statement; 48, 49; 49, string:'''Samples the action fluent with given `name`, `dtype`, and `size`.
With probability `prob` it chooses the action fluent `default_value`,
with probability 1-`prob` it samples the fluent w.r.t. its `constraints`.
Args:
name (str): The name of the action fluent.
dtype (tf.DType): The data type of the action fluent.
size (Sequence[int]): The size and shape of the action fluent.
constraints (Dict[str, Tuple[Optional[TensorFluent], Optional[TensorFluent]]]): The bounds for each action fluent.
default_value (tf.Tensor): The default value for the action fluent.
prob (float): A probability measure.
Returns:
tf.Tensor: A tensor for sampling the action fluent.
'''; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:shape; 53, binary_operator:+; 53, 54; 53, 58; 54, list:[self.batch_size]; 54, 55; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:batch_size; 58, call; 58, 59; 58, 60; 59, identifier:list; 60, argument_list; 60, 61; 61, identifier:size; 62, if_statement; 62, 63; 62, 68; 62, 283; 62, 326; 63, comparison_operator:==; 63, 64; 63, 65; 64, identifier:dtype; 65, attribute; 65, 66; 65, 67; 66, identifier:tf; 67, identifier:float32; 68, block; 68, 69; 68, 78; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:bounds; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:constraints; 75, identifier:get; 76, argument_list; 76, 77; 77, identifier:name; 78, if_statement; 78, 79; 78, 82; 78, 121; 79, comparison_operator:is; 79, 80; 79, 81; 80, identifier:bounds; 81, None; 82, block; 82, 83; 82, 96; 82, 112; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 88; 85, pattern_list; 85, 86; 85, 87; 86, identifier:low; 87, identifier:high; 88, expression_list; 88, 89; 88, 93; 89, unary_operator:-; 89, 90; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:MAX_REAL_VALUE; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:MAX_REAL_VALUE; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:dist; 99, call; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:tf; 103, identifier:distributions; 104, identifier:Uniform; 105, argument_list; 105, 106; 105, 109; 106, keyword_argument; 106, 107; 106, 108; 107, identifier:low; 108, identifier:low; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:high; 111, identifier:high; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:sampled_fluent; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:dist; 118, identifier:sample; 119, argument_list; 119, 120; 120, identifier:shape; 121, else_clause; 121, 122; 122, block; 122, 123; 122, 129; 122, 149; 122, 171; 122, 192; 122, 208; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 128; 125, pattern_list; 125, 126; 125, 127; 126, identifier:low; 127, identifier:high; 128, identifier:bounds; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:batch; 132, boolean_operator:or; 132, 133; 132, 141; 133, parenthesized_expression; 133, 134; 134, boolean_operator:and; 134, 135; 134, 138; 135, comparison_operator:is; 135, 136; 135, 137; 136, identifier:low; 137, None; 138, attribute; 138, 139; 138, 140; 139, identifier:low; 140, identifier:batch; 141, parenthesized_expression; 141, 142; 142, boolean_operator:and; 142, 143; 142, 146; 143, comparison_operator:is; 143, 144; 143, 145; 144, identifier:high; 145, None; 146, attribute; 146, 147; 146, 148; 147, identifier:high; 148, identifier:batch; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:low; 152, conditional_expression:if; 152, 153; 152, 164; 152, 167; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:tf; 156, identifier:cast; 157, argument_list; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:low; 160, identifier:tensor; 161, attribute; 161, 162; 161, 163; 162, identifier:tf; 163, identifier:float32; 164, comparison_operator:is; 164, 165; 164, 166; 165, identifier:low; 166, None; 167, unary_operator:-; 167, 168; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:MAX_REAL_VALUE; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:high; 174, conditional_expression:if; 174, 175; 174, 186; 174, 189; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:tf; 178, identifier:cast; 179, argument_list; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:high; 182, identifier:tensor; 183, attribute; 183, 184; 183, 185; 184, identifier:tf; 185, identifier:float32; 186, comparison_operator:is; 186, 187; 186, 188; 187, identifier:high; 188, None; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:MAX_REAL_VALUE; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:dist; 195, call; 195, 196; 195, 201; 196, attribute; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:tf; 199, identifier:distributions; 200, identifier:Uniform; 201, argument_list; 201, 202; 201, 205; 202, keyword_argument; 202, 203; 202, 204; 203, identifier:low; 204, identifier:low; 205, keyword_argument; 205, 206; 205, 207; 206, identifier:high; 207, identifier:high; 208, if_statement; 208, 209; 208, 210; 208, 219; 208, 272; 209, identifier:batch; 210, block; 210, 211; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:sampled_fluent; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:dist; 217, identifier:sample; 218, argument_list; 219, elif_clause; 219, 220; 219, 235; 220, boolean_operator:or; 220, 221; 220, 228; 221, call; 221, 222; 221, 223; 222, identifier:isinstance; 223, argument_list; 223, 224; 223, 225; 224, identifier:low; 225, attribute; 225, 226; 225, 227; 226, identifier:tf; 227, identifier:Tensor; 228, call; 228, 229; 228, 230; 229, identifier:isinstance; 230, argument_list; 230, 231; 230, 232; 231, identifier:high; 232, attribute; 232, 233; 232, 234; 233, identifier:tf; 234, identifier:Tensor; 235, block; 235, 236; 236, if_statement; 236, 237; 236, 252; 236, 265; 237, comparison_operator:==; 237, 238; 237, 248; 238, call; 238, 239; 238, 247; 239, attribute; 239, 240; 239, 246; 240, attribute; 240, 241; 240, 245; 241, parenthesized_expression; 241, 242; 242, binary_operator:+; 242, 243; 242, 244; 243, identifier:low; 244, identifier:high; 245, identifier:shape; 246, identifier:as_list; 247, argument_list; 248, call; 248, 249; 248, 250; 249, identifier:list; 250, argument_list; 250, 251; 251, identifier:size; 252, block; 252, 253; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:sampled_fluent; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:dist; 259, identifier:sample; 260, argument_list; 260, 261; 261, list:[self.batch_size]; 261, 262; 262, attribute; 262, 263; 262, 264; 263, identifier:self; 264, identifier:batch_size; 265, else_clause; 265, 266; 266, block; 266, 267; 267, raise_statement; 267, 268; 268, call; 268, 269; 268, 270; 269, identifier:ValueError; 270, argument_list; 270, 271; 271, string:'bounds are not compatible with action fluent.'; 272, else_clause; 272, 273; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:sampled_fluent; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:dist; 280, identifier:sample; 281, argument_list; 281, 282; 282, identifier:shape; 283, elif_clause; 283, 284; 283, 289; 284, comparison_operator:==; 284, 285; 284, 286; 285, identifier:dtype; 286, attribute; 286, 287; 286, 288; 287, identifier:tf; 288, identifier:int32; 289, block; 289, 290; 289, 299; 289, 317; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:logits; 293, binary_operator:*; 293, 294; 293, 296; 294, list:[1.0]; 294, 295; 295, float:1.0; 296, attribute; 296, 297; 296, 298; 297, identifier:self; 298, identifier:MAX_INT_VALUE; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:dist; 302, call; 302, 303; 302, 308; 303, attribute; 303, 304; 303, 307; 304, attribute; 304, 305; 304, 306; 305, identifier:tf; 306, identifier:distributions; 307, identifier:Categorical; 308, argument_list; 308, 309; 308, 312; 309, keyword_argument; 309, 310; 309, 311; 310, identifier:logits; 311, identifier:logits; 312, keyword_argument; 312, 313; 312, 314; 313, identifier:dtype; 314, attribute; 314, 315; 314, 316; 315, identifier:tf; 316, identifier:int32; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 320; 319, identifier:sampled_fluent; 320, call; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:dist; 323, identifier:sample; 324, argument_list; 324, 325; 325, identifier:shape; 326, elif_clause; 326, 327; 326, 332; 327, comparison_operator:==; 327, 328; 327, 329; 328, identifier:dtype; 329, attribute; 329, 330; 329, 331; 330, identifier:tf; 331, identifier:bool; 332, block; 332, 333; 332, 337; 332, 355; 333, expression_statement; 333, 334; 334, assignment; 334, 335; 334, 336; 335, identifier:probs; 336, float:0.5; 337, expression_statement; 337, 338; 338, assignment; 338, 339; 338, 340; 339, identifier:dist; 340, call; 340, 341; 340, 346; 341, attribute; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, identifier:tf; 344, identifier:distributions; 345, identifier:Bernoulli; 346, argument_list; 346, 347; 346, 350; 347, keyword_argument; 347, 348; 347, 349; 348, identifier:probs; 349, identifier:probs; 350, keyword_argument; 350, 351; 350, 352; 351, identifier:dtype; 352, attribute; 352, 353; 352, 354; 353, identifier:tf; 354, identifier:bool; 355, expression_statement; 355, 356; 356, assignment; 356, 357; 356, 358; 357, identifier:sampled_fluent; 358, call; 358, 359; 358, 362; 359, attribute; 359, 360; 359, 361; 360, identifier:dist; 361, identifier:sample; 362, argument_list; 362, 363; 363, identifier:shape; 364, expression_statement; 364, 365; 365, assignment; 365, 366; 365, 367; 366, identifier:select_default; 367, call; 367, 368; 367, 383; 368, attribute; 368, 369; 368, 382; 369, call; 369, 370; 369, 375; 370, attribute; 370, 371; 370, 374; 371, attribute; 371, 372; 371, 373; 372, identifier:tf; 373, identifier:distributions; 374, identifier:Bernoulli; 375, argument_list; 375, 376; 375, 377; 376, identifier:prob; 377, keyword_argument; 377, 378; 377, 379; 378, identifier:dtype; 379, attribute; 379, 380; 379, 381; 380, identifier:tf; 381, identifier:bool; 382, identifier:sample; 383, argument_list; 383, 384; 384, attribute; 384, 385; 384, 386; 385, identifier:self; 386, identifier:batch_size; 387, expression_statement; 387, 388; 388, assignment; 388, 389; 388, 390; 389, identifier:action_fluent; 390, call; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, identifier:tf; 393, identifier:where; 394, argument_list; 394, 395; 394, 396; 394, 397; 395, identifier:select_default; 396, identifier:default_value; 397, identifier:sampled_fluent; 398, return_statement; 398, 399; 399, identifier:action_fluent | def _sample_action_fluent(self,
name: str,
dtype: tf.DType,
size: Sequence[int],
constraints: Dict[str, Constraints],
default_value: tf.Tensor,
prob: float) -> tf.Tensor:
'''Samples the action fluent with given `name`, `dtype`, and `size`.
With probability `prob` it chooses the action fluent `default_value`,
with probability 1-`prob` it samples the fluent w.r.t. its `constraints`.
Args:
name (str): The name of the action fluent.
dtype (tf.DType): The data type of the action fluent.
size (Sequence[int]): The size and shape of the action fluent.
constraints (Dict[str, Tuple[Optional[TensorFluent], Optional[TensorFluent]]]): The bounds for each action fluent.
default_value (tf.Tensor): The default value for the action fluent.
prob (float): A probability measure.
Returns:
tf.Tensor: A tensor for sampling the action fluent.
'''
shape = [self.batch_size] + list(size)
if dtype == tf.float32:
bounds = constraints.get(name)
if bounds is None:
low, high = -self.MAX_REAL_VALUE, self.MAX_REAL_VALUE
dist = tf.distributions.Uniform(low=low, high=high)
sampled_fluent = dist.sample(shape)
else:
low, high = bounds
batch = (low is not None and low.batch) or (high is not None and high.batch)
low = tf.cast(low.tensor, tf.float32) if low is not None else -self.MAX_REAL_VALUE
high = tf.cast(high.tensor, tf.float32) if high is not None else self.MAX_REAL_VALUE
dist = tf.distributions.Uniform(low=low, high=high)
if batch:
sampled_fluent = dist.sample()
elif isinstance(low, tf.Tensor) or isinstance(high, tf.Tensor):
if (low+high).shape.as_list() == list(size):
sampled_fluent = dist.sample([self.batch_size])
else:
raise ValueError('bounds are not compatible with action fluent.')
else:
sampled_fluent = dist.sample(shape)
elif dtype == tf.int32:
logits = [1.0] * self.MAX_INT_VALUE
dist = tf.distributions.Categorical(logits=logits, dtype=tf.int32)
sampled_fluent = dist.sample(shape)
elif dtype == tf.bool:
probs = 0.5
dist = tf.distributions.Bernoulli(probs=probs, dtype=tf.bool)
sampled_fluent = dist.sample(shape)
select_default = tf.distributions.Bernoulli(prob, dtype=tf.bool).sample(self.batch_size)
action_fluent = tf.where(select_default, default_value, sampled_fluent)
return action_fluent |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 29; 1, 31; 2, function_name:UnitToLNode; 3, parameters; 3, 4; 3, 8; 3, 17; 3, 26; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:u; 6, type; 6, 7; 7, identifier:Unit; 8, typed_default_parameter; 8, 9; 8, 10; 8, 16; 9, identifier:node; 10, type; 10, 11; 11, generic_type; 11, 12; 11, 13; 12, identifier:Optional; 13, type_parameter; 13, 14; 14, type; 14, 15; 15, identifier:LNode; 16, None; 17, typed_default_parameter; 17, 18; 17, 19; 17, 25; 18, identifier:toL; 19, type; 19, 20; 20, generic_type; 20, 21; 20, 22; 21, identifier:Optional; 22, type_parameter; 22, 23; 23, type; 23, 24; 24, identifier:dict; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:optimizations; 28, list:[]; 29, type; 29, 30; 30, identifier:LNode; 31, block; 31, 32; 31, 41; 31, 69; 31, 73; 31, 80; 31, 110; 31, 128; 31, 140; 31, 198; 31, 267; 31, 274; 31, 283; 31, 291; 31, 386; 32, if_statement; 32, 33; 32, 36; 33, comparison_operator:is; 33, 34; 33, 35; 34, identifier:toL; 35, None; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:toL; 40, dictionary; 41, if_statement; 41, 42; 41, 45; 41, 63; 42, comparison_operator:is; 42, 43; 42, 44; 43, identifier:node; 44, None; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:root; 49, call; 49, 50; 49, 51; 50, identifier:LNode; 51, argument_list; 51, 52; 51, 57; 51, 60; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:name; 54, attribute; 54, 55; 54, 56; 55, identifier:u; 56, identifier:_name; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:originObj; 59, identifier:u; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:node2lnode; 62, identifier:toL; 63, else_clause; 63, 64; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:root; 68, identifier:node; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:stmPorts; 72, dictionary; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:netCtx; 76, call; 76, 77; 76, 78; 77, identifier:NetCtxs; 78, argument_list; 78, 79; 79, identifier:root; 80, for_statement; 80, 81; 80, 82; 80, 85; 81, identifier:su; 82, attribute; 82, 83; 82, 84; 83, identifier:u; 84, identifier:_units; 85, block; 85, 86; 85, 102; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:n; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:root; 92, identifier:addNode; 93, argument_list; 93, 94; 93, 99; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:name; 96, attribute; 96, 97; 96, 98; 97, identifier:su; 98, identifier:_name; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:originObj; 101, identifier:su; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 105; 104, identifier:UnitToLNode; 105, argument_list; 105, 106; 105, 107; 105, 108; 105, 109; 106, identifier:su; 107, identifier:n; 108, identifier:toL; 109, identifier:optimizations; 110, for_statement; 110, 111; 110, 112; 110, 117; 111, identifier:stm; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:u; 115, identifier:_ctx; 116, identifier:statements; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:n; 121, call; 121, 122; 121, 123; 122, identifier:addStmAsLNode; 123, argument_list; 123, 124; 123, 125; 123, 126; 123, 127; 124, identifier:root; 125, identifier:stm; 126, identifier:stmPorts; 127, identifier:netCtx; 128, for_statement; 128, 129; 128, 130; 128, 133; 129, identifier:intf; 130, attribute; 130, 131; 130, 132; 131, identifier:u; 132, identifier:_interfaces; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:addPort; 137, argument_list; 137, 138; 137, 139; 138, identifier:root; 139, identifier:intf; 140, for_statement; 140, 141; 140, 142; 140, 147; 141, identifier:stm; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:u; 145, identifier:_ctx; 146, identifier:statements; 147, block; 147, 148; 147, 158; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:n; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:toL; 154, identifier:get; 155, argument_list; 155, 156; 155, 157; 156, identifier:stm; 157, None; 158, if_statement; 158, 159; 158, 162; 159, comparison_operator:is; 159, 160; 159, 161; 160, identifier:n; 161, None; 162, block; 162, 163; 162, 182; 162, 192; 163, if_statement; 163, 164; 163, 169; 163, 174; 164, call; 164, 165; 164, 166; 165, identifier:isinstance; 166, argument_list; 166, 167; 166, 168; 167, identifier:n; 168, identifier:VirtualLNode; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:p; 173, None; 174, else_clause; 174, 175; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:p; 179, subscript; 179, 180; 179, 181; 180, identifier:stmPorts; 181, identifier:n; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:r; 185, call; 185, 186; 185, 187; 186, identifier:StatementRenderer; 187, argument_list; 187, 188; 187, 189; 187, 190; 187, 191; 188, identifier:n; 189, identifier:toL; 190, identifier:p; 191, identifier:netCtx; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:r; 196, identifier:renderContent; 197, argument_list; 198, for_statement; 198, 199; 198, 200; 198, 205; 199, identifier:s; 200, attribute; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:u; 203, identifier:_ctx; 204, identifier:signals; 205, block; 205, 206; 206, if_statement; 206, 207; 206, 211; 207, not_operator; 207, 208; 208, attribute; 208, 209; 208, 210; 209, identifier:s; 210, identifier:hidden; 211, block; 211, 212; 211, 223; 211, 245; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 217; 214, pattern_list; 214, 215; 214, 216; 215, identifier:net; 216, identifier:_; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:netCtx; 220, identifier:getDefault; 221, argument_list; 221, 222; 222, identifier:s; 223, for_statement; 223, 224; 223, 225; 223, 228; 224, identifier:e; 225, attribute; 225, 226; 225, 227; 226, identifier:s; 227, identifier:endpoints; 228, block; 228, 229; 229, if_statement; 229, 230; 229, 235; 230, call; 230, 231; 230, 232; 231, identifier:isinstance; 232, argument_list; 232, 233; 232, 234; 233, identifier:e; 234, identifier:PortItem; 235, block; 235, 236; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:net; 240, identifier:addEndpoint; 241, argument_list; 241, 242; 242, subscript; 242, 243; 242, 244; 243, identifier:toL; 244, identifier:e; 245, for_statement; 245, 246; 245, 247; 245, 250; 246, identifier:d; 247, attribute; 247, 248; 247, 249; 248, identifier:s; 249, identifier:drivers; 250, block; 250, 251; 251, if_statement; 251, 252; 251, 257; 252, call; 252, 253; 252, 254; 253, identifier:isinstance; 254, argument_list; 254, 255; 254, 256; 255, identifier:d; 256, identifier:PortItem; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:net; 262, identifier:addDriver; 263, argument_list; 263, 264; 264, subscript; 264, 265; 264, 266; 265, identifier:toL; 266, identifier:d; 267, expression_statement; 267, 268; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:netCtx; 271, identifier:applyConnections; 272, argument_list; 272, 273; 273, identifier:root; 274, for_statement; 274, 275; 274, 276; 274, 277; 275, identifier:opt; 276, identifier:optimizations; 277, block; 277, 278; 278, expression_statement; 278, 279; 279, call; 279, 280; 279, 281; 280, identifier:opt; 281, argument_list; 281, 282; 282, identifier:root; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:isRootOfWholeGraph; 286, comparison_operator:is; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:root; 289, identifier:parent; 290, None; 291, if_statement; 291, 292; 291, 294; 292, not_operator; 292, 293; 293, identifier:isRootOfWholeGraph; 294, block; 294, 295; 295, for_statement; 295, 296; 295, 297; 295, 300; 296, identifier:intf; 297, attribute; 297, 298; 297, 299; 298, identifier:u; 299, identifier:_interfaces; 300, block; 300, 301; 300, 312; 300, 320; 300, 369; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:ext_p; 304, attribute; 304, 305; 304, 311; 305, subscript; 305, 306; 305, 307; 306, identifier:toL; 307, call; 307, 308; 307, 309; 308, identifier:originObjOfPort; 309, argument_list; 309, 310; 310, identifier:intf; 311, identifier:parentNode; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 315; 314, identifier:nodePort; 315, call; 315, 316; 315, 317; 316, identifier:addPortToLNode; 317, argument_list; 317, 318; 317, 319; 318, identifier:root; 319, identifier:intf; 320, if_statement; 320, 321; 320, 328; 320, 348; 321, comparison_operator:==; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, identifier:intf; 324, identifier:_direction; 325, attribute; 325, 326; 325, 327; 326, identifier:INTF_DIRECTION; 327, identifier:SLAVE; 328, block; 328, 329; 328, 333; 329, expression_statement; 329, 330; 330, assignment; 330, 331; 330, 332; 331, identifier:src; 332, identifier:nodePort; 333, expression_statement; 333, 334; 334, assignment; 334, 335; 334, 336; 335, identifier:dst; 336, call; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:ext_p; 339, identifier:addPort; 340, argument_list; 340, 341; 340, 342; 340, 345; 341, string:""; 342, attribute; 342, 343; 342, 344; 343, identifier:PortType; 344, identifier:INPUT; 345, attribute; 345, 346; 345, 347; 346, identifier:PortSide; 347, identifier:WEST; 348, else_clause; 348, 349; 349, block; 349, 350; 349, 365; 350, expression_statement; 350, 351; 351, assignment; 351, 352; 351, 353; 352, identifier:src; 353, call; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:ext_p; 356, identifier:addPort; 357, argument_list; 357, 358; 357, 359; 357, 362; 358, string:""; 359, attribute; 359, 360; 359, 361; 360, identifier:PortType; 361, identifier:OUTPUT; 362, attribute; 362, 363; 362, 364; 363, identifier:PortSide; 364, identifier:EAST; 365, expression_statement; 365, 366; 366, assignment; 366, 367; 366, 368; 367, identifier:dst; 368, identifier:nodePort; 369, expression_statement; 369, 370; 370, call; 370, 371; 370, 374; 371, attribute; 371, 372; 371, 373; 372, identifier:root; 373, identifier:addEdge; 374, argument_list; 374, 375; 374, 376; 374, 377; 374, 383; 375, identifier:src; 376, identifier:dst; 377, keyword_argument; 377, 378; 377, 379; 378, identifier:name; 379, call; 379, 380; 379, 381; 380, identifier:repr; 381, argument_list; 381, 382; 382, identifier:intf; 383, keyword_argument; 383, 384; 383, 385; 384, identifier:originObj; 385, identifier:intf; 386, return_statement; 386, 387; 387, identifier:root | def UnitToLNode(u: Unit, node: Optional[LNode]=None,
toL: Optional[dict]=None,
optimizations=[]) -> LNode:
if toL is None:
toL = {}
if node is None:
root = LNode(name=u._name, originObj=u, node2lnode=toL)
else:
root = node
stmPorts = {}
netCtx = NetCtxs(root)
for su in u._units:
n = root.addNode(name=su._name, originObj=su)
UnitToLNode(su, n, toL, optimizations)
for stm in u._ctx.statements:
n = addStmAsLNode(root, stm, stmPorts, netCtx)
for intf in u._interfaces:
addPort(root, intf)
for stm in u._ctx.statements:
n = toL.get(stm, None)
if n is not None:
if isinstance(n, VirtualLNode):
p = None
else:
p = stmPorts[n]
r = StatementRenderer(n, toL, p, netCtx)
r.renderContent()
for s in u._ctx.signals:
if not s.hidden:
net, _ = netCtx.getDefault(s)
for e in s.endpoints:
if isinstance(e, PortItem):
net.addEndpoint(toL[e])
for d in s.drivers:
if isinstance(d, PortItem):
net.addDriver(toL[d])
netCtx.applyConnections(root)
for opt in optimizations:
opt(root)
isRootOfWholeGraph = root.parent is None
if not isRootOfWholeGraph:
for intf in u._interfaces:
ext_p = toL[originObjOfPort(intf)].parentNode
nodePort = addPortToLNode(root, intf)
if intf._direction == INTF_DIRECTION.SLAVE:
src = nodePort
dst = ext_p.addPort("", PortType.INPUT, PortSide.WEST)
else:
src = ext_p.addPort("", PortType.OUTPUT, PortSide.EAST)
dst = nodePort
root.addEdge(src, dst, name=repr(intf), originObj=intf)
return root |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_hypergeometric_stats; 3, parameters; 3, 4; 3, 5; 4, identifier:N; 5, identifier:indices; 6, block; 6, 7; 6, 17; 6, 38; 6, 44; 6, 60; 6, 76; 6, 82; 6, 88; 6, 92; 6, 96; 6, 100; 6, 221; 7, assert_statement; 7, 8; 8, call; 8, 9; 8, 10; 9, identifier:isinstance; 10, argument_list; 10, 11; 10, 12; 11, identifier:N; 12, tuple; 12, 13; 12, 14; 13, identifier:int; 14, attribute; 14, 15; 14, 16; 15, identifier:np; 16, identifier:integer; 17, assert_statement; 17, 18; 18, boolean_operator:and; 18, 19; 18, 26; 18, 27; 19, call; 19, 20; 19, 21; 20, identifier:isinstance; 21, argument_list; 21, 22; 21, 23; 22, identifier:indices; 23, attribute; 23, 24; 23, 25; 24, identifier:np; 25, identifier:ndarray; 26, line_continuation:\; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:np; 30, identifier:issubdtype; 31, argument_list; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:indices; 34, identifier:dtype; 35, attribute; 35, 36; 35, 37; 36, identifier:np; 37, identifier:uint16; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:K; 41, attribute; 41, 42; 41, 43; 42, identifier:indices; 43, identifier:size; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:pvals; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:np; 50, identifier:empty; 51, argument_list; 51, 52; 51, 55; 52, binary_operator:+; 52, 53; 52, 54; 53, identifier:N; 54, integer:1; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:dtype; 57, attribute; 57, 58; 57, 59; 58, identifier:np; 59, identifier:float64; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:folds; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:np; 66, identifier:empty; 67, argument_list; 67, 68; 67, 71; 68, binary_operator:+; 68, 69; 68, 70; 69, identifier:N; 70, integer:1; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:dtype; 73, attribute; 73, 74; 73, 75; 74, identifier:np; 75, identifier:float64; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 81; 78, subscript; 78, 79; 78, 80; 79, identifier:pvals; 80, integer:0; 81, float:1.0; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:folds; 86, integer:0; 87, float:1.0; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:n; 91, integer:0; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:k; 95, integer:0; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:p; 99, float:1.0; 100, while_statement; 100, 101; 100, 104; 101, comparison_operator:<; 101, 102; 101, 103; 102, identifier:n; 103, identifier:N; 104, block; 104, 105; 104, 187; 104, 191; 104, 204; 105, if_statement; 105, 106; 105, 115; 105, 150; 106, boolean_operator:and; 106, 107; 106, 110; 107, comparison_operator:<; 107, 108; 107, 109; 108, identifier:k; 109, identifier:K; 110, comparison_operator:==; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:indices; 113, identifier:k; 114, identifier:n; 115, block; 115, 116; 115, 146; 116, expression_statement; 116, 117; 117, augmented_assignment:*=; 117, 118; 117, 119; 118, identifier:p; 119, parenthesized_expression; 119, 120; 120, binary_operator:/; 120, 121; 120, 133; 120, 134; 121, call; 121, 122; 121, 123; 122, identifier:float; 123, argument_list; 123, 124; 124, binary_operator:*; 124, 125; 124, 129; 125, parenthesized_expression; 125, 126; 126, binary_operator:+; 126, 127; 126, 128; 127, identifier:n; 128, integer:1; 129, parenthesized_expression; 129, 130; 130, binary_operator:-; 130, 131; 130, 132; 131, identifier:K; 132, identifier:k; 133, line_continuation:\; 134, call; 134, 135; 134, 136; 135, identifier:float; 136, argument_list; 136, 137; 137, binary_operator:*; 137, 138; 137, 142; 138, parenthesized_expression; 138, 139; 139, binary_operator:-; 139, 140; 139, 141; 140, identifier:N; 141, identifier:n; 142, parenthesized_expression; 142, 143; 143, binary_operator:+; 143, 144; 143, 145; 144, identifier:k; 145, integer:1; 146, expression_statement; 146, 147; 147, augmented_assignment:+=; 147, 148; 147, 149; 148, identifier:k; 149, integer:1; 150, else_clause; 150, 151; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, augmented_assignment:*=; 153, 154; 153, 155; 154, identifier:p; 155, parenthesized_expression; 155, 156; 156, binary_operator:/; 156, 157; 156, 173; 157, call; 157, 158; 157, 159; 158, identifier:float; 159, argument_list; 159, 160; 160, binary_operator:*; 160, 161; 160, 165; 161, parenthesized_expression; 161, 162; 162, binary_operator:+; 162, 163; 162, 164; 163, identifier:n; 164, integer:1; 165, parenthesized_expression; 165, 166; 166, binary_operator:+; 166, 167; 166, 172; 167, binary_operator:-; 167, 168; 167, 171; 168, binary_operator:-; 168, 169; 168, 170; 169, identifier:N; 170, identifier:K; 171, identifier:n; 172, identifier:k; 173, call; 173, 174; 173, 175; 174, identifier:float; 175, argument_list; 175, 176; 176, binary_operator:*; 176, 177; 176, 181; 177, parenthesized_expression; 177, 178; 178, binary_operator:-; 178, 179; 178, 180; 179, identifier:N; 180, identifier:n; 181, parenthesized_expression; 181, 182; 182, binary_operator:+; 182, 183; 182, 186; 183, binary_operator:-; 183, 184; 183, 185; 184, identifier:n; 185, identifier:k; 186, integer:1; 187, expression_statement; 187, 188; 188, augmented_assignment:+=; 188, 189; 188, 190; 189, identifier:n; 190, integer:1; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 196; 193, subscript; 193, 194; 193, 195; 194, identifier:pvals; 195, identifier:n; 196, call; 196, 197; 196, 198; 197, identifier:get_hgp; 198, argument_list; 198, 199; 198, 200; 198, 201; 198, 202; 198, 203; 199, identifier:p; 200, identifier:k; 201, identifier:N; 202, identifier:K; 203, identifier:n; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 209; 206, subscript; 206, 207; 206, 208; 207, identifier:folds; 208, identifier:n; 209, binary_operator:/; 209, 210; 209, 211; 210, identifier:k; 211, parenthesized_expression; 211, 212; 212, binary_operator:*; 212, 213; 212, 214; 213, identifier:K; 214, parenthesized_expression; 214, 215; 215, binary_operator:/; 215, 216; 215, 217; 216, identifier:n; 217, call; 217, 218; 217, 219; 218, identifier:float; 219, argument_list; 219, 220; 220, identifier:N; 221, return_statement; 221, 222; 222, expression_list; 222, 223; 222, 224; 223, identifier:pvals; 224, identifier:folds | def get_hypergeometric_stats(N, indices):
assert isinstance(N, (int, np.integer))
assert isinstance(indices, np.ndarray) and \
np.issubdtype(indices.dtype, np.uint16)
K = indices.size
pvals = np.empty(N+1, dtype=np.float64)
folds = np.empty(N+1, dtype=np.float64)
pvals[0] = 1.0
folds[0] = 1.0
n = 0
k = 0
p = 1.0
while n < N:
if k < K and indices[k] == n:
p *= (float((n+1) * (K-k)) / \
float((N-n) * (k+1)))
k += 1
else:
p *= (float((n+1) * (N-K-n+k)) /
float((N-n) * (n-k+1)))
n += 1
pvals[n] = get_hgp(p, k, N, K, n)
folds[n] = k / (K*(n/float(N)))
return pvals, folds |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:purge_existing_ovb; 3, parameters; 3, 4; 3, 5; 4, identifier:nova_api; 5, identifier:neutron; 6, block; 6, 7; 6, 14; 6, 55; 6, 137; 6, 228; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:LOG; 11, identifier:info; 12, argument_list; 12, 13; 13, string:'Cleaning up OVB environment from the tenant.'; 14, for_statement; 14, 15; 14, 16; 14, 23; 15, identifier:server; 16, call; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:nova_api; 20, identifier:servers; 21, identifier:list; 22, argument_list; 23, block; 23, 24; 23, 39; 24, if_statement; 24, 25; 24, 32; 25, comparison_operator:in; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:server; 28, identifier:name; 29, tuple; 29, 30; 29, 31; 30, string:'bmc'; 31, string:'undercloud'; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:server; 37, identifier:delete; 38, argument_list; 39, if_statement; 39, 40; 39, 48; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:server; 44, identifier:name; 45, identifier:startswith; 46, argument_list; 46, 47; 47, string:'baremetal_'; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:server; 53, identifier:delete; 54, argument_list; 55, for_statement; 55, 56; 55, 57; 55, 67; 56, identifier:router; 57, call; 57, 58; 57, 65; 58, attribute; 58, 59; 58, 64; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:neutron; 62, identifier:list_routers; 63, argument_list; 64, identifier:get; 65, argument_list; 65, 66; 66, string:'routers'; 67, block; 67, 68; 67, 78; 68, if_statement; 68, 69; 68, 76; 69, comparison_operator:not; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:router; 72, string:'name'; 73, tuple; 73, 74; 73, 75; 74, string:'router'; 75, string:'bmc_router'; 76, block; 76, 77; 77, continue_statement; 78, for_statement; 78, 79; 78, 80; 78, 90; 79, identifier:subnet; 80, call; 80, 81; 80, 88; 81, attribute; 81, 82; 81, 87; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:neutron; 85, identifier:list_subnets; 86, argument_list; 87, identifier:get; 88, argument_list; 88, 89; 89, string:'subnets'; 90, block; 90, 91; 90, 110; 91, if_statement; 91, 92; 91, 108; 92, not_operator; 92, 93; 93, parenthesized_expression; 93, 94; 94, boolean_operator:or; 94, 95; 94, 103; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:subnet; 99, string:'name'; 100, identifier:startswith; 101, argument_list; 101, 102; 102, string:'bmc_eth'; 103, comparison_operator:==; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:subnet; 106, string:'name'; 107, string:'rdo-m-subnet'; 108, block; 108, 109; 109, continue_statement; 110, try_statement; 110, 111; 110, 127; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:neutron; 116, identifier:remove_interface_router; 117, argument_list; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:router; 120, string:'id'; 121, dictionary; 121, 122; 122, pair; 122, 123; 122, 124; 123, string:'subnet_id'; 124, subscript; 124, 125; 124, 126; 125, identifier:subnet; 126, string:'id'; 127, except_clause; 127, 128; 127, 135; 128, attribute; 128, 129; 128, 134; 129, attribute; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:neutronclient; 132, identifier:common; 133, identifier:exceptions; 134, identifier:NotFound; 135, block; 135, 136; 136, pass_statement; 137, try_statement; 137, 138; 137, 224; 138, block; 138, 139; 138, 157; 138, 215; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:bmc_router; 142, subscript; 142, 143; 142, 156; 143, call; 143, 144; 143, 154; 144, attribute; 144, 145; 144, 153; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:neutron; 148, identifier:list_routers; 149, argument_list; 149, 150; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:name; 152, string:'bmc_router'; 153, identifier:get; 154, argument_list; 154, 155; 155, string:'routers'; 156, integer:0; 157, for_statement; 157, 158; 157, 159; 157, 171; 158, identifier:port; 159, subscript; 159, 160; 159, 170; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:neutron; 163, identifier:list_ports; 164, argument_list; 164, 165; 165, keyword_argument; 165, 166; 165, 167; 166, identifier:device_id; 167, subscript; 167, 168; 167, 169; 168, identifier:bmc_router; 169, string:'id'; 170, string:'ports'; 171, block; 171, 172; 171, 183; 171, 205; 172, if_statement; 172, 173; 172, 181; 173, comparison_operator:==; 173, 174; 173, 180; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:port; 177, identifier:get; 178, argument_list; 178, 179; 179, string:'device_owner'; 180, string:'network:router_gateway'; 181, block; 181, 182; 182, continue_statement; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:info; 186, dictionary; 186, 187; 186, 192; 186, 197; 187, pair; 187, 188; 187, 189; 188, string:'id'; 189, subscript; 189, 190; 189, 191; 190, identifier:router; 191, string:'id'; 192, pair; 192, 193; 192, 194; 193, string:'port_id'; 194, subscript; 194, 195; 194, 196; 195, identifier:port; 196, string:'id'; 197, pair; 197, 198; 197, 199; 198, string:'tenant_id'; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:bmc_router; 202, identifier:get; 203, argument_list; 203, 204; 204, string:'tenant_id'; 205, expression_statement; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:neutron; 209, identifier:remove_interface_router; 210, argument_list; 210, 211; 210, 214; 211, subscript; 211, 212; 211, 213; 212, identifier:bmc_router; 213, string:'id'; 214, identifier:info; 215, expression_statement; 215, 216; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:neutron; 219, identifier:delete_router; 220, argument_list; 220, 221; 221, subscript; 221, 222; 221, 223; 222, identifier:bmc_router; 223, string:'id'; 224, except_clause; 224, 225; 224, 226; 225, identifier:IndexError; 226, block; 226, 227; 227, pass_statement; 228, for_statement; 228, 229; 228, 230; 228, 235; 229, identifier:_; 230, call; 230, 231; 230, 232; 231, identifier:range; 232, argument_list; 232, 233; 232, 234; 233, integer:0; 234, integer:5; 235, block; 235, 236; 236, try_statement; 236, 237; 236, 372; 236, 395; 237, block; 237, 238; 237, 267; 238, for_statement; 238, 239; 238, 240; 238, 247; 239, identifier:port; 240, subscript; 240, 241; 240, 246; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:neutron; 244, identifier:list_ports; 245, argument_list; 246, string:'ports'; 247, block; 247, 248; 248, if_statement; 248, 249; 248, 257; 249, call; 249, 250; 249, 255; 250, attribute; 250, 251; 250, 254; 251, subscript; 251, 252; 251, 253; 252, identifier:port; 253, string:'name'; 254, identifier:endswith; 255, argument_list; 255, 256; 256, string:'_provision'; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:neutron; 262, identifier:delete_port; 263, argument_list; 263, 264; 264, subscript; 264, 265; 264, 266; 265, identifier:port; 266, string:'id'; 267, for_statement; 267, 268; 267, 269; 267, 279; 268, identifier:net; 269, call; 269, 270; 269, 277; 270, attribute; 270, 271; 270, 276; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:neutron; 274, identifier:list_networks; 275, argument_list; 276, identifier:get; 277, argument_list; 277, 278; 278, string:'networks'; 279, block; 279, 280; 279, 292; 279, 363; 280, if_statement; 280, 281; 280, 290; 281, not_operator; 281, 282; 282, call; 282, 283; 282, 288; 283, attribute; 283, 284; 283, 287; 284, subscript; 284, 285; 284, 286; 285, identifier:net; 286, string:'name'; 287, identifier:startswith; 288, argument_list; 288, 289; 289, string:'provision_'; 290, block; 290, 291; 291, continue_statement; 292, for_statement; 292, 293; 292, 294; 292, 306; 293, identifier:port; 294, subscript; 294, 295; 294, 305; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:neutron; 298, identifier:list_ports; 299, argument_list; 299, 300; 300, keyword_argument; 300, 301; 300, 302; 301, identifier:network_id; 302, subscript; 302, 303; 302, 304; 303, identifier:net; 304, string:'id'; 305, string:'ports'; 306, block; 306, 307; 306, 318; 306, 339; 307, if_statement; 307, 308; 307, 316; 308, comparison_operator:==; 308, 309; 308, 315; 309, call; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:port; 312, identifier:get; 313, argument_list; 313, 314; 314, string:'device_owner'; 315, string:'network:router_interface'; 316, block; 316, 317; 317, continue_statement; 318, try_statement; 318, 319; 318, 329; 319, block; 319, 320; 320, expression_statement; 320, 321; 321, call; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, identifier:neutron; 324, identifier:delete_port; 325, argument_list; 325, 326; 326, subscript; 326, 327; 326, 328; 327, identifier:port; 328, string:'id'; 329, except_clause; 329, 330; 329, 337; 330, attribute; 330, 331; 330, 336; 331, attribute; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:neutronclient; 334, identifier:common; 335, identifier:exceptions; 336, identifier:PortNotFoundClient; 337, block; 337, 338; 338, pass_statement; 339, for_statement; 339, 340; 339, 341; 339, 353; 340, identifier:subnet; 341, subscript; 341, 342; 341, 352; 342, call; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:neutron; 345, identifier:list_subnets; 346, argument_list; 346, 347; 347, keyword_argument; 347, 348; 347, 349; 348, identifier:network_id; 349, subscript; 349, 350; 349, 351; 350, identifier:net; 351, string:'id'; 352, string:'subnets'; 353, block; 353, 354; 354, expression_statement; 354, 355; 355, call; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, identifier:neutron; 358, identifier:delete_subnet; 359, argument_list; 359, 360; 360, subscript; 360, 361; 360, 362; 361, identifier:subnet; 362, string:'id'; 363, expression_statement; 363, 364; 364, call; 364, 365; 364, 368; 365, attribute; 365, 366; 365, 367; 366, identifier:neutron; 367, identifier:delete_network; 368, argument_list; 368, 369; 369, subscript; 369, 370; 369, 371; 370, identifier:net; 371, string:'id'; 372, except_clause; 372, 373; 372, 380; 373, attribute; 373, 374; 373, 379; 374, attribute; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:neutronclient; 377, identifier:common; 378, identifier:exceptions; 379, identifier:Conflict; 380, block; 380, 381; 380, 388; 381, expression_statement; 381, 382; 382, call; 382, 383; 382, 386; 383, attribute; 383, 384; 383, 385; 384, identifier:LOG; 385, identifier:debug; 386, argument_list; 386, 387; 387, string:'waiting for all the ports to be freed...'; 388, expression_statement; 388, 389; 389, call; 389, 390; 389, 393; 390, attribute; 390, 391; 390, 392; 391, identifier:time; 392, identifier:sleep; 393, argument_list; 393, 394; 394, integer:5; 395, else_clause; 395, 396; 396, block; 396, 397; 397, return_statement | def purge_existing_ovb(nova_api, neutron):
LOG.info('Cleaning up OVB environment from the tenant.')
for server in nova_api.servers.list():
if server.name in ('bmc', 'undercloud'):
server.delete()
if server.name.startswith('baremetal_'):
server.delete()
for router in neutron.list_routers().get('routers'):
if router['name'] not in ('router', 'bmc_router'):
continue
for subnet in neutron.list_subnets().get('subnets'):
if not (subnet['name'].startswith('bmc_eth') or subnet['name'] == 'rdo-m-subnet'):
continue
try:
neutron.remove_interface_router(router['id'], {'subnet_id': subnet['id']})
except neutronclient.common.exceptions.NotFound:
pass
try:
bmc_router = neutron.list_routers(name='bmc_router').get('routers')[0]
for port in neutron.list_ports(device_id=bmc_router['id'])['ports']:
if port.get('device_owner') == 'network:router_gateway':
continue
info = {'id': router['id'],
'port_id': port['id'],
'tenant_id': bmc_router.get('tenant_id'),
}
neutron.remove_interface_router(bmc_router['id'], info)
neutron.delete_router(bmc_router['id'])
except IndexError:
pass
for _ in range(0, 5):
try:
for port in neutron.list_ports()['ports']:
if port['name'].endswith('_provision'):
neutron.delete_port(port['id'])
for net in neutron.list_networks().get('networks'):
if not net['name'].startswith('provision_'):
continue
for port in neutron.list_ports(network_id=net['id'])['ports']:
if port.get('device_owner') == 'network:router_interface':
continue
try:
neutron.delete_port(port['id'])
except neutronclient.common.exceptions.PortNotFoundClient:
pass
for subnet in neutron.list_subnets(network_id=net['id'])['subnets']:
neutron.delete_subnet(subnet['id'])
neutron.delete_network(net['id'])
except neutronclient.common.exceptions.Conflict:
LOG.debug('waiting for all the ports to be freed...')
time.sleep(5)
else:
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:reduceUselessAssignments; 3, parameters; 3, 4; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:root; 6, type; 6, 7; 7, identifier:LNode; 8, block; 8, 9; 8, 25; 8, 29; 8, 223; 9, for_statement; 9, 10; 9, 11; 9, 14; 10, identifier:n; 11, attribute; 11, 12; 11, 13; 12, identifier:root; 13, identifier:children; 14, block; 14, 15; 15, if_statement; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:n; 18, identifier:children; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:reduceUselessAssignments; 23, argument_list; 23, 24; 24, identifier:n; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:do_update; 28, False; 29, for_statement; 29, 30; 29, 31; 29, 34; 30, identifier:n; 31, attribute; 31, 32; 31, 33; 32, identifier:root; 33, identifier:children; 34, block; 34, 35; 35, if_statement; 35, 36; 35, 61; 36, boolean_operator:and; 36, 37; 36, 52; 36, 53; 37, boolean_operator:and; 37, 38; 37, 45; 37, 46; 38, call; 38, 39; 38, 40; 39, identifier:isinstance; 40, argument_list; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:n; 43, identifier:originObj; 44, identifier:Assignment; 45, line_continuation:\; 46, not_operator; 46, 47; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:n; 50, identifier:originObj; 51, identifier:indexes; 52, line_continuation:\; 53, comparison_operator:==; 53, 54; 53, 60; 54, call; 54, 55; 54, 56; 55, identifier:len; 56, argument_list; 56, 57; 57, attribute; 57, 58; 57, 59; 58, identifier:n; 59, identifier:west; 60, integer:1; 61, block; 61, 62; 61, 70; 61, 82; 61, 99; 61, 106; 61, 110; 61, 114; 61, 118; 61, 127; 61, 136; 61, 166; 61, 192; 61, 202; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:src; 65, attribute; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:n; 68, identifier:originObj; 69, identifier:src; 70, if_statement; 70, 71; 70, 80; 71, boolean_operator:and; 71, 72; 71, 77; 72, call; 72, 73; 72, 74; 73, identifier:isinstance; 74, argument_list; 74, 75; 74, 76; 75, identifier:src; 76, identifier:RtlSignalBase; 77, attribute; 77, 78; 77, 79; 78, identifier:src; 79, identifier:hidden; 80, block; 80, 81; 81, continue_statement; 82, if_statement; 82, 83; 82, 85; 83, not_operator; 83, 84; 84, identifier:do_update; 85, block; 85, 86; 85, 95; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:nodes; 89, call; 89, 90; 89, 91; 90, identifier:set; 91, argument_list; 91, 92; 92, attribute; 92, 93; 92, 94; 93, identifier:root; 94, identifier:children; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:do_update; 98, True; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:nodes; 103, identifier:remove; 104, argument_list; 104, 105; 105, identifier:n; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:srcPorts; 109, list:[]; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:dstPorts; 113, list:[]; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:edgesToRemove; 117, list:[]; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:inP; 121, call; 121, 122; 121, 123; 122, identifier:getSinglePort; 123, argument_list; 123, 124; 124, attribute; 124, 125; 124, 126; 125, identifier:n; 126, identifier:west; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:outP; 130, call; 130, 131; 130, 132; 131, identifier:getSinglePort; 132, argument_list; 132, 133; 133, attribute; 133, 134; 133, 135; 134, identifier:n; 135, identifier:east; 136, for_statement; 136, 137; 136, 138; 136, 141; 137, identifier:e; 138, attribute; 138, 139; 138, 140; 139, identifier:inP; 140, identifier:incomingEdges; 141, block; 141, 142; 141, 148; 141, 159; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:sPort; 145, attribute; 145, 146; 145, 147; 146, identifier:e; 147, identifier:src; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:srcPorts; 152, identifier:append; 153, argument_list; 153, 154; 154, tuple; 154, 155; 154, 156; 155, identifier:sPort; 156, attribute; 156, 157; 156, 158; 157, identifier:e; 158, identifier:originObj; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:edgesToRemove; 163, identifier:append; 164, argument_list; 164, 165; 165, identifier:e; 166, for_statement; 166, 167; 166, 168; 166, 171; 167, identifier:e; 168, attribute; 168, 169; 168, 170; 169, identifier:outP; 170, identifier:outgoingEdges; 171, block; 171, 172; 171, 178; 171, 185; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:dPort; 175, attribute; 175, 176; 175, 177; 176, identifier:e; 177, identifier:dst; 178, expression_statement; 178, 179; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:dstPorts; 182, identifier:append; 183, argument_list; 183, 184; 184, identifier:dPort; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:edgesToRemove; 189, identifier:append; 190, argument_list; 190, 191; 191, identifier:e; 192, for_statement; 192, 193; 192, 194; 192, 195; 193, identifier:e; 194, identifier:edgesToRemove; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:e; 200, identifier:remove; 201, argument_list; 202, for_statement; 202, 203; 202, 206; 202, 207; 203, pattern_list; 203, 204; 203, 205; 204, identifier:srcPort; 205, identifier:originObj; 206, identifier:srcPorts; 207, block; 207, 208; 208, for_statement; 208, 209; 208, 210; 208, 211; 209, identifier:dstPort; 210, identifier:dstPorts; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:root; 216, identifier:addEdge; 217, argument_list; 217, 218; 217, 219; 217, 220; 218, identifier:srcPort; 219, identifier:dstPort; 220, keyword_argument; 220, 221; 220, 222; 221, identifier:originObj; 222, identifier:originObj; 223, if_statement; 223, 224; 223, 225; 224, identifier:do_update; 225, block; 225, 226; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:root; 230, identifier:children; 231, call; 231, 232; 231, 233; 232, identifier:list; 233, argument_list; 233, 234; 234, identifier:nodes | def reduceUselessAssignments(root: LNode):
for n in root.children:
if n.children:
reduceUselessAssignments(n)
do_update = False
for n in root.children:
if isinstance(n.originObj, Assignment)\
and not n.originObj.indexes\
and len(n.west) == 1:
src = n.originObj.src
if isinstance(src, RtlSignalBase) and src.hidden:
continue
if not do_update:
nodes = set(root.children)
do_update = True
nodes.remove(n)
srcPorts = []
dstPorts = []
edgesToRemove = []
inP = getSinglePort(n.west)
outP = getSinglePort(n.east)
for e in inP.incomingEdges:
sPort = e.src
srcPorts.append((sPort, e.originObj))
edgesToRemove.append(e)
for e in outP.outgoingEdges:
dPort = e.dst
dstPorts.append(dPort)
edgesToRemove.append(e)
for e in edgesToRemove:
e.remove()
for srcPort, originObj in srcPorts:
for dstPort in dstPorts:
root.addEdge(srcPort, dstPort,
originObj=originObj)
if do_update:
root.children = list(nodes) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:determine_completeness; 3, parameters; 3, 4; 4, identifier:py_untl; 5, block; 5, 6; 5, 91; 5, 107; 5, 111; 5, 199; 5, 222; 5, 228; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:completeness_dict; 9, dictionary; 9, 10; 9, 19; 9, 28; 9, 37; 9, 46; 9, 55; 9, 64; 9, 73; 9, 82; 10, pair; 10, 11; 10, 12; 11, string:'title'; 12, dictionary; 12, 13; 12, 16; 13, pair; 13, 14; 13, 15; 14, string:'present'; 15, False; 16, pair; 16, 17; 16, 18; 17, string:'weight'; 18, integer:10; 19, pair; 19, 20; 19, 21; 20, string:'description'; 21, dictionary; 21, 22; 21, 25; 22, pair; 22, 23; 22, 24; 23, string:'present'; 24, False; 25, pair; 25, 26; 25, 27; 26, string:'weight'; 27, integer:1; 28, pair; 28, 29; 28, 30; 29, string:'language'; 30, dictionary; 30, 31; 30, 34; 31, pair; 31, 32; 31, 33; 32, string:'present'; 33, False; 34, pair; 34, 35; 34, 36; 35, string:'weight'; 36, integer:1; 37, pair; 37, 38; 37, 39; 38, string:'collection'; 39, dictionary; 39, 40; 39, 43; 40, pair; 40, 41; 40, 42; 41, string:'present'; 42, False; 43, pair; 43, 44; 43, 45; 44, string:'weight'; 45, integer:10; 46, pair; 46, 47; 46, 48; 47, string:'institution'; 48, dictionary; 48, 49; 48, 52; 49, pair; 49, 50; 49, 51; 50, string:'present'; 51, False; 52, pair; 52, 53; 52, 54; 53, string:'weight'; 54, integer:10; 55, pair; 55, 56; 55, 57; 56, string:'resourceType'; 57, dictionary; 57, 58; 57, 61; 58, pair; 58, 59; 58, 60; 59, string:'present'; 60, False; 61, pair; 61, 62; 61, 63; 62, string:'weight'; 63, integer:5; 64, pair; 64, 65; 64, 66; 65, string:'format'; 66, dictionary; 66, 67; 66, 70; 67, pair; 67, 68; 67, 69; 68, string:'present'; 69, False; 70, pair; 70, 71; 70, 72; 71, string:'weight'; 72, integer:1; 73, pair; 73, 74; 73, 75; 74, string:'subject'; 75, dictionary; 75, 76; 75, 79; 76, pair; 76, 77; 76, 78; 77, string:'present'; 78, False; 79, pair; 79, 80; 79, 81; 80, string:'weight'; 81, integer:1; 82, pair; 82, 83; 82, 84; 83, string:'meta'; 84, dictionary; 84, 85; 84, 88; 85, pair; 85, 86; 85, 87; 86, string:'present'; 87, False; 88, pair; 88, 89; 88, 90; 89, string:'weight'; 90, integer:20; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:total_points; 94, call; 94, 95; 94, 96; 95, identifier:sum; 96, generator_expression; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:item; 99, string:'weight'; 100, for_in_clause; 100, 101; 100, 102; 101, identifier:item; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:completeness_dict; 105, identifier:values; 106, argument_list; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:py_untl_object_score; 110, float:0.0; 111, for_statement; 111, 112; 111, 113; 111, 116; 112, identifier:i; 113, attribute; 113, 114; 113, 115; 114, identifier:py_untl; 115, identifier:children; 116, block; 116, 117; 117, if_statement; 117, 118; 117, 123; 118, comparison_operator:in; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:i; 121, identifier:tag; 122, identifier:PYUNTL_COMPLETENESS_SCORED_ATTRIBUTES; 123, block; 123, 124; 124, if_statement; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:i; 127, identifier:content; 128, block; 128, 129; 128, 139; 128, 151; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:content; 132, call; 132, 133; 132, 138; 133, attribute; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:i; 136, identifier:content; 137, identifier:lower; 138, argument_list; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:match; 142, call; 142, 143; 142, 144; 143, identifier:bool; 144, argument_list; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:DEFAULT_VALUE_REGEX; 148, identifier:search; 149, argument_list; 149, 150; 150, identifier:content; 151, if_statement; 151, 152; 151, 158; 152, boolean_operator:and; 152, 153; 152, 156; 153, comparison_operator:not; 153, 154; 153, 155; 154, identifier:content; 155, identifier:COMMON_DEFAULT_ATTRIBUTE_VALUES; 156, not_operator; 156, 157; 157, identifier:match; 158, block; 158, 159; 159, if_statement; 159, 160; 159, 165; 159, 185; 160, comparison_operator:==; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:i; 163, identifier:tag; 164, string:'meta'; 165, block; 165, 166; 166, if_statement; 166, 167; 166, 172; 167, comparison_operator:==; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:i; 170, identifier:qualifier; 171, string:'system'; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 184; 175, subscript; 175, 176; 175, 183; 176, subscript; 176, 177; 176, 178; 177, identifier:completeness_dict; 178, binary_operator:%; 178, 179; 178, 180; 179, string:'%s'; 180, attribute; 180, 181; 180, 182; 181, identifier:i; 182, identifier:tag; 183, string:'present'; 184, True; 185, else_clause; 185, 186; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 198; 189, subscript; 189, 190; 189, 197; 190, subscript; 190, 191; 190, 192; 191, identifier:completeness_dict; 192, binary_operator:%; 192, 193; 192, 194; 193, string:'%s'; 194, attribute; 194, 195; 194, 196; 195, identifier:i; 196, identifier:tag; 197, string:'present'; 198, True; 199, for_statement; 199, 200; 199, 203; 199, 208; 200, pattern_list; 200, 201; 200, 202; 201, identifier:k; 202, identifier:v; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:completeness_dict; 206, identifier:iteritems; 207, argument_list; 208, block; 208, 209; 209, if_statement; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:v; 212, string:'present'; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, augmented_assignment:+=; 215, 216; 215, 217; 216, identifier:py_untl_object_score; 217, subscript; 217, 218; 217, 221; 218, subscript; 218, 219; 218, 220; 219, identifier:completeness_dict; 220, identifier:k; 221, string:'weight'; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:completeness; 225, binary_operator:/; 225, 226; 225, 227; 226, identifier:py_untl_object_score; 227, identifier:total_points; 228, return_statement; 228, 229; 229, identifier:completeness | def determine_completeness(py_untl):
completeness_dict = {
'title': {'present': False, 'weight': 10, },
'description': {'present': False, 'weight': 1, },
'language': {'present': False, 'weight': 1, },
'collection': {'present': False, 'weight': 10, },
'institution': {'present': False, 'weight': 10, },
'resourceType': {'present': False, 'weight': 5, },
'format': {'present': False, 'weight': 1, },
'subject': {'present': False, 'weight': 1, },
'meta': {'present': False, 'weight': 20, },
}
total_points = sum(item['weight'] for item in completeness_dict.values())
py_untl_object_score = 0.0
for i in py_untl.children:
if i.tag in PYUNTL_COMPLETENESS_SCORED_ATTRIBUTES:
if i.content:
content = i.content.lower()
match = bool(DEFAULT_VALUE_REGEX.search(content))
if content not in COMMON_DEFAULT_ATTRIBUTE_VALUES and not match:
if i.tag == 'meta':
if i.qualifier == 'system':
completeness_dict['%s' % i.tag]['present'] = True
else:
completeness_dict['%s' % i.tag]['present'] = True
for k, v in completeness_dict.iteritems():
if v['present']:
py_untl_object_score += completeness_dict[k]['weight']
completeness = py_untl_object_score / total_points
return completeness |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:read_char_lengths; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:filename; 6, identifier:electrode_filename; 7, block; 7, 8; 7, 144; 7, 161; 7, 167; 8, if_statement; 8, 9; 8, 17; 8, 133; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:os; 13, identifier:path; 14, identifier:isfile; 15, argument_list; 15, 16; 16, identifier:filename; 17, block; 17, 18; 17, 32; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:data; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:atleast_1d; 25, argument_list; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:np; 29, identifier:loadtxt; 30, argument_list; 30, 31; 31, identifier:filename; 32, if_statement; 32, 33; 32, 38; 32, 118; 33, comparison_operator:==; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:data; 36, identifier:size; 37, integer:4; 38, block; 38, 39; 38, 43; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:characteristic_length; 42, identifier:data; 43, if_statement; 43, 44; 43, 49; 44, comparison_operator:<; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:characteristic_length; 47, integer:0; 48, integer:0; 49, block; 49, 50; 49, 68; 49, 73; 49, 86; 49, 104; 50, try_statement; 50, 51; 50, 61; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:elec_positions; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:np; 58, identifier:loadtxt; 59, argument_list; 59, 60; 60, identifier:electrode_filename; 61, except_clause; 61, 62; 62, block; 62, 63; 63, raise_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:IOError; 66, argument_list; 66, 67; 67, string:'The was an error opening the electrode file'; 68, import_statement; 68, 69; 69, dotted_name; 69, 70; 69, 71; 69, 72; 70, identifier:scipy; 71, identifier:spatial; 72, identifier:distance; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:distances; 76, call; 76, 77; 76, 84; 77, attribute; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:scipy; 81, identifier:spatial; 82, identifier:distance; 83, identifier:pdist; 84, argument_list; 84, 85; 85, identifier:elec_positions; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:characteristic_length; 90, integer:0; 91, binary_operator:*; 91, 92; 91, 96; 92, call; 92, 93; 92, 94; 93, identifier:min; 94, argument_list; 94, 95; 95, identifier:distances; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:np; 99, identifier:abs; 100, argument_list; 100, 101; 101, subscript; 101, 102; 101, 103; 102, identifier:characteristic_length; 103, integer:0; 104, if_statement; 104, 105; 104, 110; 105, comparison_operator:==; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:characteristic_length; 108, integer:0; 109, integer:0; 110, block; 110, 111; 111, raise_statement; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:Exception; 114, argument_list; 114, 115; 115, binary_operator:+; 115, 116; 115, 117; 116, string:'Error computing electrode '; 117, string:'distances (got a minimal distance of zero'; 118, else_clause; 118, 119; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:characteristic_length; 123, binary_operator:*; 123, 124; 123, 130; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:np; 127, identifier:ones; 128, argument_list; 128, 129; 129, integer:4; 130, subscript; 130, 131; 130, 132; 131, identifier:data; 132, integer:0; 133, else_clause; 133, 134; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:characteristic_length; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:np; 141, identifier:ones; 142, argument_list; 142, 143; 143, integer:4; 144, if_statement; 144, 145; 144, 153; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:np; 148, identifier:any; 149, argument_list; 149, 150; 150, comparison_operator:<=; 150, 151; 150, 152; 151, identifier:characteristic_length; 152, integer:0; 153, block; 153, 154; 154, raise_statement; 154, 155; 155, call; 155, 156; 155, 157; 156, identifier:Exception; 157, argument_list; 157, 158; 158, binary_operator:+; 158, 159; 158, 160; 159, string:'No negative characteristic lengths allowed '; 160, string:'(except for electrode length'; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:char_lengths; 166, dictionary; 167, for_statement; 167, 168; 167, 171; 167, 180; 168, pattern_list; 168, 169; 168, 170; 169, identifier:key; 170, identifier:item; 171, call; 171, 172; 171, 173; 172, identifier:zip; 173, argument_list; 173, 174; 173, 179; 174, tuple; 174, 175; 174, 176; 174, 177; 174, 178; 175, string:'electrode'; 176, string:'boundary'; 177, string:'extra_line'; 178, string:'extra_node'; 179, identifier:characteristic_length; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 188; 183, subscript; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:char_lengths; 187, identifier:key; 188, identifier:item | def read_char_lengths(self, filename, electrode_filename):
if os.path.isfile(filename):
data = np.atleast_1d(np.loadtxt(filename))
if data.size == 4:
characteristic_length = data
if characteristic_length[0] < 0:
try:
elec_positions = np.loadtxt(electrode_filename)
except:
raise IOError(
'The was an error opening the electrode file')
import scipy.spatial.distance
distances = scipy.spatial.distance.pdist(elec_positions)
characteristic_length[0] = min(distances) * np.abs(
characteristic_length[0])
if characteristic_length[0] == 0:
raise Exception(
'Error computing electrode ' +
'distances (got a minimal distance of zero')
else:
characteristic_length = np.ones(4) * data[0]
else:
characteristic_length = np.ones(4)
if np.any(characteristic_length <= 0):
raise Exception('No negative characteristic lengths allowed ' +
'(except for electrode length')
self.char_lengths = {}
for key, item in zip(('electrode',
'boundary',
'extra_line',
'extra_node'),
characteristic_length):
self.char_lengths[key] = item |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:parse_atom_tag_data; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:name; 6, identifier:tag_content; 7, block; 7, 8; 7, 10; 7, 16; 8, expression_statement; 8, 9; 9, string:'''Parse the atom tag data.'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:current_atom_site; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:current_atom_site; 16, if_statement; 16, 17; 16, 20; 16, 22; 16, 168; 16, 204; 16, 256; 16, 277; 16, 310; 16, 328; 16, 349; 17, attribute; 17, 18; 17, 19; 18, identifier:current_atom_site; 19, identifier:IsHETATM; 20, block; 20, 21; 21, return_statement; 22, elif_clause; 22, 23; 22, 26; 23, comparison_operator:==; 23, 24; 23, 25; 24, identifier:name; 25, string:'PDBx:atom_site'; 26, block; 26, 27; 26, 33; 26, 39; 26, 45; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_BLOCK; 32, None; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:current_atom_site; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:current_atom_site; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:current_atom_site; 43, identifier:validate; 44, argument_list; 45, if_statement; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:current_atom_site; 48, identifier:IsATOM; 49, block; 49, 50; 49, 65; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 57; 52, pattern_list; 52, 53; 52, 54; 52, 55; 52, 56; 53, identifier:r; 54, identifier:seqres; 55, identifier:ResidueAA; 56, identifier:Residue3AA; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:current_atom_site; 60, identifier:convert_to_residue; 61, argument_list; 61, 62; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:modified_residues; 65, if_statement; 65, 66; 65, 67; 66, identifier:r; 67, block; 67, 68; 68, if_statement; 68, 69; 68, 80; 69, not_operator; 69, 70; 70, parenthesized_expression; 70, 71; 71, boolean_operator:and; 71, 72; 71, 77; 72, comparison_operator:in; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:pdb_id; 76, identifier:cases_with_ACE_residues_we_can_ignore; 77, comparison_operator:==; 77, 78; 77, 79; 78, identifier:Residue3AA; 79, string:'ACE'; 80, block; 80, 81; 80, 88; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:full_residue_id; 84, call; 84, 85; 84, 86; 85, identifier:str; 86, argument_list; 86, 87; 87, identifier:r; 88, if_statement; 88, 89; 88, 97; 88, 111; 89, call; 89, 90; 89, 95; 90, attribute; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:_residues_read; 94, identifier:get; 95, argument_list; 95, 96; 96, identifier:full_residue_id; 97, block; 97, 98; 98, assert_statement; 98, 99; 99, parenthesized_expression; 99, 100; 100, comparison_operator:==; 100, 101; 100, 106; 101, subscript; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:_residues_read; 105, identifier:full_residue_id; 106, tuple; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:r; 109, identifier:ResidueAA; 110, identifier:seqres; 111, else_clause; 111, 112; 112, block; 112, 113; 112, 125; 112, 145; 112, 153; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 120; 115, subscript; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:_residues_read; 119, identifier:full_residue_id; 120, tuple; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:r; 123, identifier:ResidueAA; 124, identifier:seqres; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 134; 127, subscript; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:_residue_map; 131, attribute; 131, 132; 131, 133; 132, identifier:r; 133, identifier:Chain; 134, call; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:_residue_map; 139, identifier:get; 140, argument_list; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:r; 143, identifier:Chain; 144, dictionary; 145, assert_statement; 145, 146; 146, parenthesized_expression; 146, 147; 147, comparison_operator:==; 147, 148; 147, 152; 148, call; 148, 149; 148, 150; 149, identifier:type; 150, argument_list; 150, 151; 151, identifier:seqres; 152, identifier:int_type; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 167; 155, subscript; 155, 156; 155, 163; 156, subscript; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:_residue_map; 160, attribute; 160, 161; 160, 162; 161, identifier:r; 162, identifier:Chain; 163, call; 163, 164; 163, 165; 164, identifier:str; 165, argument_list; 165, 166; 166, identifier:r; 167, identifier:seqres; 168, elif_clause; 168, 169; 168, 172; 169, comparison_operator:==; 169, 170; 169, 171; 170, identifier:name; 171, string:'PDBx:group_PDB'; 172, block; 172, 173; 173, if_statement; 173, 174; 173, 177; 173, 184; 173, 195; 174, comparison_operator:==; 174, 175; 174, 176; 175, identifier:tag_content; 176, string:'ATOM'; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:current_atom_site; 182, identifier:IsATOM; 183, True; 184, elif_clause; 184, 185; 184, 188; 185, comparison_operator:==; 185, 186; 185, 187; 186, identifier:tag_content; 187, string:'HETATM'; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:current_atom_site; 193, identifier:IsHETATM; 194, True; 195, else_clause; 195, 196; 196, block; 196, 197; 197, raise_statement; 197, 198; 198, call; 198, 199; 198, 200; 199, identifier:Exception; 200, argument_list; 200, 201; 201, binary_operator:%; 201, 202; 201, 203; 202, string:"PDBx:group_PDB was expected to be 'ATOM' or 'HETATM'. '%s' read instead."; 203, identifier:tag_content; 204, elif_clause; 204, 205; 204, 208; 205, comparison_operator:==; 205, 206; 205, 207; 206, identifier:name; 207, string:'PDBx:auth_asym_id'; 208, block; 208, 209; 208, 216; 208, 222; 209, assert_statement; 209, 210; 210, parenthesized_expression; 210, 211; 211, not_operator; 211, 212; 212, parenthesized_expression; 212, 213; 213, attribute; 213, 214; 213, 215; 214, identifier:current_atom_site; 215, identifier:PDBChainID; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:current_atom_site; 220, identifier:PDBChainID; 221, identifier:tag_content; 222, if_statement; 222, 223; 222, 225; 223, not_operator; 223, 224; 224, identifier:tag_content; 225, block; 225, 226; 225, 231; 226, assert_statement; 226, 227; 227, parenthesized_expression; 227, 228; 228, attribute; 228, 229; 228, 230; 229, identifier:current_atom_site; 230, identifier:PDBChainIDIsNull; 231, if_statement; 231, 232; 231, 241; 231, 248; 232, comparison_operator:==; 232, 233; 232, 240; 233, call; 233, 234; 233, 239; 234, attribute; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:self; 237, identifier:pdb_id; 238, identifier:upper; 239, argument_list; 240, string:'2MBP'; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:current_atom_site; 246, identifier:PDBChainID; 247, string:'A'; 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:current_atom_site; 254, identifier:PDBChainID; 255, string:' '; 256, elif_clause; 256, 257; 256, 260; 257, comparison_operator:==; 257, 258; 257, 259; 258, identifier:name; 259, string:'PDBx:auth_seq_id'; 260, block; 260, 261; 260, 268; 261, assert_statement; 261, 262; 262, parenthesized_expression; 262, 263; 263, not_operator; 263, 264; 264, parenthesized_expression; 264, 265; 265, attribute; 265, 266; 265, 267; 266, identifier:current_atom_site; 267, identifier:ATOMResidueID; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:current_atom_site; 272, identifier:ATOMResidueID; 273, call; 273, 274; 273, 275; 274, identifier:int; 275, argument_list; 275, 276; 276, identifier:tag_content; 277, elif_clause; 277, 278; 277, 281; 278, comparison_operator:==; 278, 279; 278, 280; 279, identifier:name; 280, string:"PDBx:pdbx_PDB_ins_code"; 281, block; 281, 282; 282, if_statement; 282, 283; 282, 286; 282, 295; 283, attribute; 283, 284; 283, 285; 284, identifier:current_atom_site; 285, identifier:ATOMResidueiCodeIsNull; 286, block; 286, 287; 287, assert_statement; 287, 288; 288, parenthesized_expression; 288, 289; 289, comparison_operator:==; 289, 290; 289, 294; 290, call; 290, 291; 290, 292; 291, identifier:len; 292, argument_list; 292, 293; 293, identifier:tag_content; 294, integer:0; 295, else_clause; 295, 296; 296, block; 296, 297; 296, 304; 297, assert_statement; 297, 298; 298, parenthesized_expression; 298, 299; 299, comparison_operator:==; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:current_atom_site; 302, identifier:ATOMResidueiCode; 303, string:' '; 304, expression_statement; 304, 305; 305, assignment; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:current_atom_site; 308, identifier:ATOMResidueiCode; 309, identifier:tag_content; 310, elif_clause; 310, 311; 310, 314; 311, comparison_operator:==; 311, 312; 311, 313; 312, identifier:name; 313, string:"PDBx:auth_comp_id"; 314, block; 314, 315; 314, 322; 315, assert_statement; 315, 316; 316, parenthesized_expression; 316, 317; 317, not_operator; 317, 318; 318, parenthesized_expression; 318, 319; 319, attribute; 319, 320; 319, 321; 320, identifier:current_atom_site; 321, identifier:ATOMResidueAA; 322, expression_statement; 322, 323; 323, assignment; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:current_atom_site; 326, identifier:ATOMResidueAA; 327, identifier:tag_content; 328, elif_clause; 328, 329; 328, 332; 329, comparison_operator:==; 329, 330; 329, 331; 330, identifier:name; 331, string:"PDBx:label_seq_id"; 332, block; 332, 333; 332, 340; 333, assert_statement; 333, 334; 334, parenthesized_expression; 334, 335; 335, not_operator; 335, 336; 336, parenthesized_expression; 336, 337; 337, attribute; 337, 338; 337, 339; 338, identifier:current_atom_site; 339, identifier:SEQRESIndex; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, identifier:current_atom_site; 344, identifier:SEQRESIndex; 345, call; 345, 346; 345, 347; 346, identifier:int; 347, argument_list; 347, 348; 348, identifier:tag_content; 349, elif_clause; 349, 350; 349, 353; 350, comparison_operator:==; 350, 351; 350, 352; 351, identifier:name; 352, string:"PDBx:label_comp_id"; 353, block; 353, 354; 353, 361; 354, assert_statement; 354, 355; 355, parenthesized_expression; 355, 356; 356, not_operator; 356, 357; 357, parenthesized_expression; 357, 358; 358, attribute; 358, 359; 358, 360; 359, identifier:current_atom_site; 360, identifier:ATOMSeqresResidueAA; 361, expression_statement; 361, 362; 362, assignment; 362, 363; 362, 366; 363, attribute; 363, 364; 363, 365; 364, identifier:current_atom_site; 365, identifier:ATOMSeqresResidueAA; 366, identifier:tag_content | def parse_atom_tag_data(self, name, tag_content):
'''Parse the atom tag data.'''
current_atom_site = self.current_atom_site
if current_atom_site.IsHETATM:
return
elif name == 'PDBx:atom_site':
self._BLOCK = None
current_atom_site = self.current_atom_site
current_atom_site.validate()
if current_atom_site.IsATOM:
r, seqres, ResidueAA, Residue3AA = current_atom_site.convert_to_residue(self.modified_residues)
if r:
if not(self.pdb_id in cases_with_ACE_residues_we_can_ignore and Residue3AA == 'ACE'):
full_residue_id = str(r)
if self._residues_read.get(full_residue_id):
assert(self._residues_read[full_residue_id] == (r.ResidueAA, seqres))
else:
self._residues_read[full_residue_id] = (r.ResidueAA, seqres)
self._residue_map[r.Chain] = self._residue_map.get(r.Chain, {})
assert(type(seqres) == int_type)
self._residue_map[r.Chain][str(r)] = seqres
elif name == 'PDBx:group_PDB':
if tag_content == 'ATOM':
current_atom_site.IsATOM = True
elif tag_content == 'HETATM':
current_atom_site.IsHETATM = True
else:
raise Exception("PDBx:group_PDB was expected to be 'ATOM' or 'HETATM'. '%s' read instead." % tag_content)
elif name == 'PDBx:auth_asym_id':
assert(not(current_atom_site.PDBChainID))
current_atom_site.PDBChainID = tag_content
if not tag_content:
assert(current_atom_site.PDBChainIDIsNull)
if self.pdb_id.upper() == '2MBP':
current_atom_site.PDBChainID = 'A'
else:
current_atom_site.PDBChainID = ' '
elif name == 'PDBx:auth_seq_id':
assert(not(current_atom_site.ATOMResidueID))
current_atom_site.ATOMResidueID = int(tag_content)
elif name == "PDBx:pdbx_PDB_ins_code":
if current_atom_site.ATOMResidueiCodeIsNull:
assert(len(tag_content) == 0)
else:
assert(current_atom_site.ATOMResidueiCode == ' ')
current_atom_site.ATOMResidueiCode = tag_content
elif name == "PDBx:auth_comp_id":
assert(not(current_atom_site.ATOMResidueAA))
current_atom_site.ATOMResidueAA = tag_content
elif name == "PDBx:label_seq_id":
assert(not(current_atom_site.SEQRESIndex))
current_atom_site.SEQRESIndex = int(tag_content)
elif name == "PDBx:label_comp_id":
assert(not(current_atom_site.ATOMSeqresResidueAA))
current_atom_site.ATOMSeqresResidueAA = tag_content |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:link; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 4, default_parameter; 4, 5; 4, 6; 5, identifier:origin; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:rel; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:value; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:attributes; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:source; 18, None; 19, block; 19, 20; 19, 22; 19, 28; 19, 238; 20, expression_statement; 20, 21; 21, string:'''
Action function generator to create a link based on the context's current link, or on provided parameters
:param origin: IRI/string, or list of same; origins for the created relationships.
If None, the action context provides the parameter.
:param rel: IRI/string, or list of same; IDs for the created relationships.
If None, the action context provides the parameter.
:param value: IRI/string, or list of same; values/targets for the created relationships.
If None, the action context provides the parameter.
:param source: pattern action to be executed, generating contexts to determine the output statements. If given, overrides specific origin, rel or value params
:return: Versa action function to do the actual work
'''; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:attributes; 25, boolean_operator:or; 25, 26; 25, 27; 26, identifier:attributes; 27, dictionary; 28, function_definition; 28, 29; 28, 30; 28, 32; 29, function_name:_link; 30, parameters; 30, 31; 31, identifier:ctx; 32, block; 32, 33; 32, 84; 32, 94; 32, 107; 32, 126; 32, 139; 32, 158; 32, 171; 32, 190; 32, 203; 32, 237; 33, if_statement; 33, 34; 33, 35; 34, identifier:source; 35, block; 35, 36; 35, 48; 35, 55; 35, 83; 36, if_statement; 36, 37; 36, 42; 37, not_operator; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:callable; 40, argument_list; 40, 41; 41, identifier:source; 42, block; 42, 43; 43, raise_statement; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:ValueError; 46, argument_list; 46, 47; 47, string:'Link source must be a pattern action function'; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:contexts; 51, call; 51, 52; 51, 53; 52, identifier:source; 53, argument_list; 53, 54; 54, identifier:ctx; 55, for_statement; 55, 56; 55, 57; 55, 58; 56, identifier:ctx; 57, identifier:contexts; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 66; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:ctx; 64, identifier:output_model; 65, identifier:add; 66, argument_list; 66, 67; 66, 72; 66, 77; 66, 82; 67, subscript; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:ctx; 70, identifier:current_link; 71, identifier:ORIGIN; 72, subscript; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:ctx; 75, identifier:current_link; 76, identifier:RELATIONSHIP; 77, subscript; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:ctx; 80, identifier:current_link; 81, identifier:TARGET; 82, identifier:attributes; 83, return_statement; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 91; 86, tuple_pattern; 86, 87; 86, 88; 86, 89; 86, 90; 87, identifier:o; 88, identifier:r; 89, identifier:v; 90, identifier:a; 91, attribute; 91, 92; 91, 93; 92, identifier:ctx; 93, identifier:current_link; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:_origin; 97, conditional_expression:if; 97, 98; 97, 102; 97, 106; 98, call; 98, 99; 98, 100; 99, identifier:origin; 100, argument_list; 100, 101; 101, identifier:ctx; 102, call; 102, 103; 102, 104; 103, identifier:callable; 104, argument_list; 104, 105; 105, identifier:origin; 106, identifier:origin; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:o_list; 110, conditional_expression:if; 110, 111; 110, 113; 110, 116; 111, list:[o]; 111, 112; 112, identifier:o; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:_origin; 115, None; 116, parenthesized_expression; 116, 117; 117, conditional_expression:if; 117, 118; 117, 119; 117, 124; 118, identifier:_origin; 119, call; 119, 120; 119, 121; 120, identifier:isinstance; 121, argument_list; 121, 122; 121, 123; 122, identifier:_origin; 123, identifier:list; 124, list:[_origin]; 124, 125; 125, identifier:_origin; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:_rel; 129, conditional_expression:if; 129, 130; 129, 134; 129, 138; 130, call; 130, 131; 130, 132; 131, identifier:rel; 132, argument_list; 132, 133; 133, identifier:ctx; 134, call; 134, 135; 134, 136; 135, identifier:callable; 136, argument_list; 136, 137; 137, identifier:rel; 138, identifier:rel; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:r_list; 142, conditional_expression:if; 142, 143; 142, 145; 142, 148; 143, list:[r]; 143, 144; 144, identifier:r; 145, comparison_operator:is; 145, 146; 145, 147; 146, identifier:_rel; 147, None; 148, parenthesized_expression; 148, 149; 149, conditional_expression:if; 149, 150; 149, 151; 149, 156; 150, identifier:_rel; 151, call; 151, 152; 151, 153; 152, identifier:isinstance; 153, argument_list; 153, 154; 153, 155; 154, identifier:_rel; 155, identifier:list; 156, list:[_rel]; 156, 157; 157, identifier:_rel; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:_value; 161, conditional_expression:if; 161, 162; 161, 166; 161, 170; 162, call; 162, 163; 162, 164; 163, identifier:value; 164, argument_list; 164, 165; 165, identifier:ctx; 166, call; 166, 167; 166, 168; 167, identifier:callable; 168, argument_list; 168, 169; 169, identifier:value; 170, identifier:value; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:v_list; 174, conditional_expression:if; 174, 175; 174, 177; 174, 180; 175, list:[v]; 175, 176; 176, identifier:v; 177, comparison_operator:is; 177, 178; 177, 179; 178, identifier:_value; 179, None; 180, parenthesized_expression; 180, 181; 181, conditional_expression:if; 181, 182; 181, 183; 181, 188; 182, identifier:_value; 183, call; 183, 184; 183, 185; 184, identifier:isinstance; 185, argument_list; 185, 186; 185, 187; 186, identifier:_value; 187, identifier:list; 188, list:[_value]; 188, 189; 189, identifier:_value; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:_attributes; 193, conditional_expression:if; 193, 194; 193, 198; 193, 202; 194, call; 194, 195; 194, 196; 195, identifier:attributes; 196, argument_list; 196, 197; 197, identifier:ctx; 198, call; 198, 199; 198, 200; 199, identifier:callable; 200, argument_list; 200, 201; 201, identifier:attributes; 202, identifier:attributes; 203, for_statement; 203, 204; 203, 209; 203, 224; 204, tuple_pattern; 204, 205; 204, 206; 204, 207; 204, 208; 205, identifier:o; 206, identifier:r; 207, identifier:v; 208, identifier:a; 209, list_comprehension; 209, 210; 209, 215; 209, 218; 209, 221; 210, tuple; 210, 211; 210, 212; 210, 213; 210, 214; 211, identifier:o; 212, identifier:r; 213, identifier:v; 214, identifier:a; 215, for_in_clause; 215, 216; 215, 217; 216, identifier:o; 217, identifier:o_list; 218, for_in_clause; 218, 219; 218, 220; 219, identifier:r; 220, identifier:r_list; 221, for_in_clause; 221, 222; 221, 223; 222, identifier:v; 223, identifier:v_list; 224, block; 224, 225; 225, expression_statement; 225, 226; 226, call; 226, 227; 226, 232; 227, attribute; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:ctx; 230, identifier:output_model; 231, identifier:add; 232, argument_list; 232, 233; 232, 234; 232, 235; 232, 236; 233, identifier:o; 234, identifier:r; 235, identifier:v; 236, identifier:attributes; 237, return_statement; 238, return_statement; 238, 239; 239, identifier:_link | def link(origin=None, rel=None, value=None, attributes=None, source=None):
'''
Action function generator to create a link based on the context's current link, or on provided parameters
:param origin: IRI/string, or list of same; origins for the created relationships.
If None, the action context provides the parameter.
:param rel: IRI/string, or list of same; IDs for the created relationships.
If None, the action context provides the parameter.
:param value: IRI/string, or list of same; values/targets for the created relationships.
If None, the action context provides the parameter.
:param source: pattern action to be executed, generating contexts to determine the output statements. If given, overrides specific origin, rel or value params
:return: Versa action function to do the actual work
'''
attributes = attributes or {}
def _link(ctx):
if source:
if not callable(source):
raise ValueError('Link source must be a pattern action function')
contexts = source(ctx)
for ctx in contexts:
ctx.output_model.add(ctx.current_link[ORIGIN], ctx.current_link[RELATIONSHIP], ctx.current_link[TARGET], attributes)
return
(o, r, v, a) = ctx.current_link
_origin = origin(ctx) if callable(origin) else origin
o_list = [o] if _origin is None else (_origin if isinstance(_origin, list) else [_origin])
_rel = rel(ctx) if callable(rel) else rel
r_list = [r] if _rel is None else (_rel if isinstance(_rel, list) else [_rel])
_value = value(ctx) if callable(value) else value
v_list = [v] if _value is None else (_value if isinstance(_value, list) else [_value])
_attributes = attributes(ctx) if callable(attributes) else attributes
for (o, r, v, a) in [ (o, r, v, a) for o in o_list for r in r_list for v in v_list ]:
ctx.output_model.add(o, r, v, attributes)
return
return _link |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:foreach; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 4, default_parameter; 4, 5; 4, 6; 5, identifier:origin; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:rel; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:target; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:attributes; 15, None; 16, block; 16, 17; 16, 19; 16, 193; 17, expression_statement; 17, 18; 18, string:'''
Action function generator to compute a combination of links
:return: Versa action function to do the actual work
'''; 19, function_definition; 19, 20; 19, 21; 19, 23; 20, function_name:_foreach; 21, parameters; 21, 22; 22, identifier:ctx; 23, block; 23, 24; 23, 26; 23, 39; 23, 52; 23, 65; 23, 78; 23, 88; 23, 107; 23, 126; 23, 145; 23, 164; 24, expression_statement; 24, 25; 25, string:'''
Versa action function utility to compute a list of values from a list of expressions
:param ctx: Versa context used in processing (e.g. includes the prototype link)
'''; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:_origin; 29, conditional_expression:if; 29, 30; 29, 34; 29, 38; 30, call; 30, 31; 30, 32; 31, identifier:origin; 32, argument_list; 32, 33; 33, identifier:ctx; 34, call; 34, 35; 34, 36; 35, identifier:callable; 36, argument_list; 36, 37; 37, identifier:origin; 38, identifier:origin; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:_rel; 42, conditional_expression:if; 42, 43; 42, 47; 42, 51; 43, call; 43, 44; 43, 45; 44, identifier:rel; 45, argument_list; 45, 46; 46, identifier:ctx; 47, call; 47, 48; 47, 49; 48, identifier:callable; 49, argument_list; 49, 50; 50, identifier:rel; 51, identifier:rel; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:_target; 55, conditional_expression:if; 55, 56; 55, 60; 55, 64; 56, call; 56, 57; 56, 58; 57, identifier:target; 58, argument_list; 58, 59; 59, identifier:ctx; 60, call; 60, 61; 60, 62; 61, identifier:callable; 62, argument_list; 62, 63; 63, identifier:target; 64, identifier:target; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:_attributes; 68, conditional_expression:if; 68, 69; 68, 73; 68, 77; 69, call; 69, 70; 69, 71; 70, identifier:attributes; 71, argument_list; 71, 72; 72, identifier:ctx; 73, call; 73, 74; 73, 75; 74, identifier:callable; 75, argument_list; 75, 76; 76, identifier:attributes; 77, identifier:attributes; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 85; 80, tuple_pattern; 80, 81; 80, 82; 80, 83; 80, 84; 81, identifier:o; 82, identifier:r; 83, identifier:t; 84, identifier:a; 85, attribute; 85, 86; 85, 87; 86, identifier:ctx; 87, identifier:current_link; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:o; 91, conditional_expression:if; 91, 92; 91, 94; 91, 97; 92, list:[o]; 92, 93; 93, identifier:o; 94, comparison_operator:is; 94, 95; 94, 96; 95, identifier:_origin; 96, None; 97, parenthesized_expression; 97, 98; 98, conditional_expression:if; 98, 99; 98, 100; 98, 105; 99, identifier:_origin; 100, call; 100, 101; 100, 102; 101, identifier:isinstance; 102, argument_list; 102, 103; 102, 104; 103, identifier:_origin; 104, identifier:list; 105, list:[_origin]; 105, 106; 106, identifier:_origin; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:r; 110, conditional_expression:if; 110, 111; 110, 113; 110, 116; 111, list:[r]; 111, 112; 112, identifier:r; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:_rel; 115, None; 116, parenthesized_expression; 116, 117; 117, conditional_expression:if; 117, 118; 117, 119; 117, 124; 118, identifier:_rel; 119, call; 119, 120; 119, 121; 120, identifier:isinstance; 121, argument_list; 121, 122; 121, 123; 122, identifier:_rel; 123, identifier:list; 124, list:[_rel]; 124, 125; 125, identifier:_rel; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:t; 129, conditional_expression:if; 129, 130; 129, 132; 129, 135; 130, list:[t]; 130, 131; 131, identifier:t; 132, comparison_operator:is; 132, 133; 132, 134; 133, identifier:_target; 134, None; 135, parenthesized_expression; 135, 136; 136, conditional_expression:if; 136, 137; 136, 138; 136, 143; 137, identifier:_target; 138, call; 138, 139; 138, 140; 139, identifier:isinstance; 140, argument_list; 140, 141; 140, 142; 141, identifier:_target; 142, identifier:list; 143, list:[_target]; 143, 144; 144, identifier:_target; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:a; 148, conditional_expression:if; 148, 149; 148, 151; 148, 154; 149, list:[a]; 149, 150; 150, identifier:a; 151, comparison_operator:is; 151, 152; 151, 153; 152, identifier:_attributes; 153, None; 154, parenthesized_expression; 154, 155; 155, conditional_expression:if; 155, 156; 155, 157; 155, 162; 156, identifier:_attributes; 157, call; 157, 158; 157, 159; 158, identifier:isinstance; 159, argument_list; 159, 160; 159, 161; 160, identifier:_attributes; 161, identifier:list; 162, list:[_attributes]; 162, 163; 163, identifier:_attributes; 164, return_statement; 164, 165; 165, list_comprehension; 165, 166; 165, 178; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:ctx; 169, identifier:copy; 170, argument_list; 170, 171; 171, keyword_argument; 171, 172; 171, 173; 172, identifier:current_link; 173, tuple; 173, 174; 173, 175; 173, 176; 173, 177; 174, identifier:curr_o; 175, identifier:curr_r; 176, identifier:curr_t; 177, identifier:curr_a; 178, for_in_clause; 178, 179; 178, 184; 179, tuple_pattern; 179, 180; 179, 181; 179, 182; 179, 183; 180, identifier:curr_o; 181, identifier:curr_r; 182, identifier:curr_t; 183, identifier:curr_a; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:itertools; 187, identifier:product; 188, argument_list; 188, 189; 188, 190; 188, 191; 188, 192; 189, identifier:o; 190, identifier:r; 191, identifier:t; 192, identifier:a; 193, return_statement; 193, 194; 194, identifier:_foreach | def foreach(origin=None, rel=None, target=None, attributes=None):
'''
Action function generator to compute a combination of links
:return: Versa action function to do the actual work
'''
def _foreach(ctx):
'''
Versa action function utility to compute a list of values from a list of expressions
:param ctx: Versa context used in processing (e.g. includes the prototype link)
'''
_origin = origin(ctx) if callable(origin) else origin
_rel = rel(ctx) if callable(rel) else rel
_target = target(ctx) if callable(target) else target
_attributes = attributes(ctx) if callable(attributes) else attributes
(o, r, t, a) = ctx.current_link
o = [o] if _origin is None else (_origin if isinstance(_origin, list) else [_origin])
r = [r] if _rel is None else (_rel if isinstance(_rel, list) else [_rel])
t = [t] if _target is None else (_target if isinstance(_target, list) else [_target])
a = [a] if _attributes is None else (_attributes if isinstance(_attributes, list) else [_attributes])
return [ ctx.copy(current_link=(curr_o, curr_r, curr_t, curr_a))
for (curr_o, curr_r, curr_t, curr_a)
in itertools.product(o, r, t, a) ]
return _foreach |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_method_documentation; 3, parameters; 3, 4; 4, identifier:method; 5, block; 5, 6; 5, 11; 5, 43; 5, 50; 5, 54; 5, 177; 5, 188; 5, 203; 5, 343; 5, 354; 6, import_from_statement; 6, 7; 6, 9; 7, dotted_name; 7, 8; 8, identifier:inspect; 9, dotted_name; 9, 10; 10, identifier:getargspec; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:result; 14, dictionary; 14, 15; 14, 20; 15, pair; 15, 16; 15, 17; 16, string:'name'; 17, attribute; 17, 18; 17, 19; 18, identifier:method; 19, identifier:__name__; 20, pair; 20, 21; 20, 22; 21, string:'friendly_name'; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, string:' '; 25, identifier:join; 26, argument_list; 26, 27; 27, list_comprehension; 27, 28; 27, 33; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:name; 31, identifier:capitalize; 32, argument_list; 33, for_in_clause; 33, 34; 33, 35; 34, identifier:name; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:method; 39, identifier:__name__; 40, identifier:split; 41, argument_list; 41, 42; 42, string:'_'; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:arg_specs; 46, call; 46, 47; 46, 48; 47, identifier:getargspec; 48, argument_list; 48, 49; 49, identifier:method; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:arguments; 53, dictionary; 54, if_statement; 54, 55; 54, 59; 54, 89; 55, not_operator; 55, 56; 56, attribute; 56, 57; 56, 58; 57, identifier:arg_specs; 58, identifier:defaults; 59, block; 59, 60; 60, if_statement; 60, 61; 60, 73; 61, comparison_operator:>; 61, 62; 61, 72; 62, call; 62, 63; 62, 64; 63, identifier:len; 64, argument_list; 64, 65; 65, subscript; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:arg_specs; 68, identifier:args; 69, slice; 69, 70; 69, 71; 70, integer:1; 71, colon; 72, integer:0; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:arguments; 78, string:'required'; 79, call; 79, 80; 79, 81; 80, identifier:list; 81, argument_list; 81, 82; 82, subscript; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:arg_specs; 85, identifier:args; 86, slice; 86, 87; 86, 88; 87, integer:1; 88, colon; 89, else_clause; 89, 90; 90, block; 90, 91; 90, 134; 90, 140; 91, if_statement; 91, 92; 91, 110; 92, call; 92, 93; 92, 94; 93, identifier:len; 94, argument_list; 94, 95; 95, subscript; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:arg_specs; 98, identifier:args; 99, slice; 99, 100; 99, 101; 99, 102; 100, integer:1; 101, colon; 102, unary_operator:-; 102, 103; 103, parenthesized_expression; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:len; 106, argument_list; 106, 107; 107, attribute; 107, 108; 107, 109; 108, identifier:arg_specs; 109, identifier:defaults; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:arguments; 115, string:'required'; 116, call; 116, 117; 116, 118; 117, identifier:list; 118, argument_list; 118, 119; 119, subscript; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:arg_specs; 122, identifier:args; 123, slice; 123, 124; 123, 125; 123, 126; 124, integer:1; 125, colon; 126, unary_operator:-; 126, 127; 127, parenthesized_expression; 127, 128; 128, call; 128, 129; 128, 130; 129, identifier:len; 130, argument_list; 130, 131; 131, attribute; 131, 132; 131, 133; 132, identifier:arg_specs; 133, identifier:defaults; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 139; 136, subscript; 136, 137; 136, 138; 137, identifier:arguments; 138, string:'optional'; 139, dictionary; 140, for_statement; 140, 141; 140, 142; 140, 151; 141, identifier:i; 142, call; 142, 143; 142, 144; 143, identifier:range; 144, argument_list; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:len; 147, argument_list; 147, 148; 148, attribute; 148, 149; 148, 150; 149, identifier:arg_specs; 150, identifier:defaults; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 172; 154, subscript; 154, 155; 154, 158; 155, subscript; 155, 156; 155, 157; 156, identifier:arguments; 157, string:'optional'; 158, subscript; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:arg_specs; 161, identifier:args; 162, binary_operator:+; 162, 163; 162, 171; 163, unary_operator:-; 163, 164; 164, parenthesized_expression; 164, 165; 165, call; 165, 166; 165, 167; 166, identifier:len; 167, argument_list; 167, 168; 168, attribute; 168, 169; 168, 170; 169, identifier:arg_specs; 170, identifier:defaults; 171, identifier:i; 172, subscript; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:arg_specs; 175, identifier:defaults; 176, identifier:i; 177, if_statement; 177, 178; 177, 181; 178, comparison_operator:!=; 178, 179; 178, 180; 179, identifier:arguments; 180, dictionary; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 187; 184, subscript; 184, 185; 184, 186; 185, identifier:result; 186, string:'parameters'; 187, identifier:arguments; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:doc; 191, conditional_expression:if; 191, 192; 191, 199; 191, 202; 192, call; 192, 193; 192, 198; 193, attribute; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:method; 196, identifier:__doc__; 197, identifier:strip; 198, argument_list; 199, attribute; 199, 200; 199, 201; 200, identifier:method; 201, identifier:__doc__; 202, string:''; 203, if_statement; 203, 204; 203, 209; 204, comparison_operator:in; 204, 205; 204, 206; 205, string:':'; 206, attribute; 206, 207; 206, 208; 207, identifier:method; 208, identifier:__doc__; 209, block; 209, 210; 209, 233; 209, 245; 209, 279; 209, 295; 209, 306; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:doc; 213, dictionary; 213, 214; 214, pair; 214, 215; 214, 216; 215, string:'summary'; 216, call; 216, 217; 216, 232; 217, attribute; 217, 218; 217, 231; 218, subscript; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:method; 221, identifier:__doc__; 222, slice; 222, 223; 222, 224; 222, 225; 223, integer:0; 224, colon; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:doc; 228, identifier:find; 229, argument_list; 229, 230; 230, string:' :'; 231, identifier:strip; 232, argument_list; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:params; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:re; 239, identifier:findall; 240, argument_list; 240, 241; 240, 242; 241, string:r":param ([^\s]*): (.*)\n"; 242, attribute; 242, 243; 242, 244; 243, identifier:method; 244, identifier:__doc__; 245, if_statement; 245, 246; 245, 252; 246, comparison_operator:>; 246, 247; 246, 251; 247, call; 247, 248; 247, 249; 248, identifier:len; 249, argument_list; 249, 250; 250, identifier:params; 251, integer:0; 252, block; 252, 253; 252, 259; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 258; 255, subscript; 255, 256; 255, 257; 256, identifier:doc; 257, string:'parameters'; 258, dictionary; 259, for_statement; 259, 260; 259, 261; 259, 262; 260, identifier:param; 261, identifier:params; 262, block; 262, 263; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 272; 265, subscript; 265, 266; 265, 269; 266, subscript; 266, 267; 266, 268; 267, identifier:doc; 268, string:'parameters'; 269, subscript; 269, 270; 269, 271; 270, identifier:param; 271, integer:0; 272, call; 272, 273; 272, 278; 273, attribute; 273, 274; 273, 277; 274, subscript; 274, 275; 274, 276; 275, identifier:param; 276, integer:1; 277, identifier:strip; 278, argument_list; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:regex; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:re; 285, identifier:compile; 286, argument_list; 286, 287; 286, 288; 287, string:r":returns:(.*)"; 288, binary_operator:|; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:re; 291, identifier:MULTILINE; 292, attribute; 292, 293; 292, 294; 293, identifier:re; 294, identifier:DOTALL; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:returns; 298, call; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:regex; 301, identifier:search; 302, argument_list; 302, 303; 303, attribute; 303, 304; 303, 305; 304, identifier:method; 305, identifier:__doc__; 306, if_statement; 306, 307; 306, 315; 307, boolean_operator:and; 307, 308; 307, 309; 308, identifier:returns; 309, call; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:returns; 312, identifier:group; 313, argument_list; 313, 314; 314, integer:0; 315, block; 315, 316; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 321; 318, subscript; 318, 319; 318, 320; 319, identifier:doc; 320, string:'return'; 321, call; 321, 322; 321, 342; 322, attribute; 322, 323; 322, 341; 323, call; 323, 324; 323, 338; 324, attribute; 324, 325; 324, 337; 325, call; 325, 326; 325, 334; 326, attribute; 326, 327; 326, 333; 327, call; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:returns; 330, identifier:group; 331, argument_list; 331, 332; 332, integer:0; 333, identifier:replace; 334, argument_list; 334, 335; 334, 336; 335, string:':returns:'; 336, string:''; 337, identifier:replace; 338, argument_list; 338, 339; 338, 340; 339, string:'\n '; 340, string:'\n'; 341, identifier:strip; 342, argument_list; 343, if_statement; 343, 344; 343, 347; 344, comparison_operator:!=; 344, 345; 344, 346; 345, identifier:doc; 346, string:''; 347, block; 347, 348; 348, expression_statement; 348, 349; 349, assignment; 349, 350; 349, 353; 350, subscript; 350, 351; 350, 352; 351, identifier:result; 352, string:'help'; 353, identifier:doc; 354, return_statement; 354, 355; 355, identifier:result | def get_method_documentation(method):
from inspect import getargspec
result = {
'name': method.__name__,
'friendly_name': ' '.join([name.capitalize() for name in method.__name__.split('_')]),
}
arg_specs = getargspec(method)
arguments = {}
if not arg_specs.defaults:
if len(arg_specs.args[1:]) > 0:
arguments['required'] = list(arg_specs.args[1:])
else:
if len(arg_specs.args[1:-(len(arg_specs.defaults))]):
arguments['required'] = list(arg_specs.args[1:-(len(arg_specs.defaults))])
arguments['optional'] = {}
for i in range(len(arg_specs.defaults)):
arguments['optional'][arg_specs.args[-(len(arg_specs.defaults)) + i]] = arg_specs.defaults[i]
if arguments != {}:
result['parameters'] = arguments
doc = method.__doc__.strip() if method.__doc__ else ''
if ':' in method.__doc__:
doc = {'summary': method.__doc__[0:doc.find(' :')].strip()}
params = re.findall(r":param ([^\s]*): (.*)\n", method.__doc__)
if len(params) > 0:
doc['parameters'] = {}
for param in params:
doc['parameters'][param[0]] = param[1].strip()
regex = re.compile(r":returns:(.*)", re.MULTILINE | re.DOTALL)
returns = regex.search(method.__doc__)
if returns and returns.group(0):
doc['return'] = returns.group(0).replace(':returns:', '').replace('\n ', '\n').strip()
if doc != '':
result['help'] = doc
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_dictionary_list; 3, parameters; 3, 4; 3, 5; 4, identifier:dict_list; 5, identifier:sort_key; 6, block; 6, 7; 6, 20; 6, 32; 7, if_statement; 7, 8; 7, 17; 8, boolean_operator:or; 8, 9; 8, 11; 9, not_operator; 9, 10; 10, identifier:dict_list; 11, comparison_operator:==; 11, 12; 11, 16; 12, call; 12, 13; 12, 14; 13, identifier:len; 14, argument_list; 14, 15; 15, identifier:dict_list; 16, integer:0; 17, block; 17, 18; 18, return_statement; 18, 19; 19, identifier:dict_list; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:dict_list; 24, identifier:sort; 25, argument_list; 25, 26; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:key; 28, call; 28, 29; 28, 30; 29, identifier:itemgetter; 30, argument_list; 30, 31; 31, identifier:sort_key; 32, return_statement; 32, 33; 33, identifier:dict_list | def sort_dictionary_list(dict_list, sort_key):
if not dict_list or len(dict_list) == 0:
return dict_list
dict_list.sort(key=itemgetter(sort_key))
return dict_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:_push; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:self; 5, identifier:title; 6, identifier:view; 7, identifier:class_name; 8, identifier:is_class; 9, dictionary_splat_pattern; 9, 10; 10, identifier:kwargs; 11, block; 11, 12; 11, 22; 11, 28; 11, 34; 11, 46; 11, 56; 11, 64; 11, 74; 11, 87; 11, 97; 11, 114; 11, 120; 11, 131; 11, 144; 11, 160; 11, 166; 11, 172; 11, 178; 11, 184; 11, 226; 11, 234; 11, 245; 11, 255; 11, 266; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:set_view_attr; 15, argument_list; 15, 16; 15, 17; 15, 18; 15, 19; 16, identifier:view; 17, string:"title"; 18, identifier:title; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:cls_name; 21, identifier:class_name; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:module_name; 25, attribute; 25, 26; 25, 27; 26, identifier:view; 27, identifier:__module__; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:method_name; 31, attribute; 31, 32; 31, 33; 32, identifier:view; 33, identifier:__name__; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:_endpoint; 37, call; 37, 38; 37, 39; 38, identifier:build_endpoint_route_name; 39, argument_list; 39, 40; 39, 41; 39, 45; 40, identifier:view; 41, conditional_expression:if; 41, 42; 41, 43; 41, 44; 42, string:"index"; 43, identifier:is_class; 44, identifier:method_name; 45, identifier:class_name; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:endpoint; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:kwargs; 52, identifier:pop; 53, argument_list; 53, 54; 53, 55; 54, string:"endpoint"; 55, identifier:_endpoint; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:kwargs; 60, identifier:setdefault; 61, argument_list; 61, 62; 61, 63; 62, string:"endpoint_kwargs"; 63, dictionary; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:order; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:kwargs; 70, identifier:pop; 71, argument_list; 71, 72; 71, 73; 72, string:"order"; 73, integer:0; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:_nav_tags; 77, call; 77, 78; 77, 79; 78, identifier:get_view_attr; 79, argument_list; 79, 80; 79, 81; 79, 82; 79, 84; 80, identifier:view; 81, string:"nav_tags"; 82, list:["default"]; 82, 83; 83, string:"default"; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:cls_name; 86, identifier:class_name; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:tags; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:kwargs; 93, identifier:pop; 94, argument_list; 94, 95; 94, 96; 95, string:"tags"; 96, identifier:_nav_tags; 97, if_statement; 97, 98; 97, 104; 98, not_operator; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:isinstance; 101, argument_list; 101, 102; 101, 103; 102, identifier:tags; 103, identifier:list; 104, block; 104, 105; 104, 109; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:_; 108, identifier:tags; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:tags; 112, list:[_]; 112, 113; 113, identifier:_; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 119; 116, subscript; 116, 117; 116, 118; 117, identifier:kwargs; 118, string:"tags"; 119, identifier:tags; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:visible; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:kwargs; 126, identifier:pop; 127, argument_list; 127, 128; 127, 129; 128, string:"visible"; 129, list:[True]; 129, 130; 130, True; 131, if_statement; 131, 132; 131, 138; 132, not_operator; 132, 133; 133, call; 133, 134; 133, 135; 134, identifier:isinstance; 135, argument_list; 135, 136; 135, 137; 136, identifier:visible; 137, identifier:list; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:visible; 142, list:[visible]; 142, 143; 143, identifier:visible; 144, if_statement; 144, 145; 144, 155; 145, comparison_operator:is; 145, 146; 145, 154; 146, call; 146, 147; 146, 148; 147, identifier:get_view_attr; 148, argument_list; 148, 149; 148, 150; 148, 151; 149, identifier:view; 150, string:"nav_visible"; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:cls_name; 153, identifier:class_name; 154, False; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:visible; 159, False; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:kwargs; 164, string:"view"; 165, identifier:view; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 171; 168, subscript; 168, 169; 168, 170; 169, identifier:kwargs; 170, string:"visible"; 171, identifier:visible; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:kwargs; 176, string:"active"; 177, False; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 183; 180, subscript; 180, 181; 180, 182; 181, identifier:kwargs; 182, string:"key"; 183, identifier:class_name; 184, if_statement; 184, 185; 184, 186; 184, 199; 185, identifier:is_class; 186, block; 186, 187; 186, 193; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 192; 189, subscript; 189, 190; 189, 191; 190, identifier:kwargs; 191, string:"endpoint"; 192, identifier:endpoint; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 198; 195, subscript; 195, 196; 195, 197; 196, identifier:kwargs; 197, string:"has_subnav"; 198, True; 199, else_clause; 199, 200; 200, block; 200, 201; 200, 207; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 206; 203, subscript; 203, 204; 203, 205; 204, identifier:kwargs; 205, string:"has_subnav"; 206, False; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:kwargs; 211, identifier:update; 212, argument_list; 212, 213; 213, dictionary; 213, 214; 213, 217; 213, 220; 213, 223; 214, pair; 214, 215; 214, 216; 215, string:"order"; 216, identifier:order; 217, pair; 217, 218; 217, 219; 218, string:"has_subnav"; 219, False; 220, pair; 220, 221; 220, 222; 221, string:"title"; 222, identifier:title; 223, pair; 223, 224; 223, 225; 224, string:"endpoint"; 225, identifier:endpoint; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 233; 228, subscript; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:self; 231, identifier:_title_map; 232, identifier:endpoint; 233, identifier:title; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:path; 237, binary_operator:%; 237, 238; 237, 239; 238, string:"%s.%s"; 239, tuple; 239, 240; 239, 241; 240, identifier:module_name; 241, conditional_expression:if; 241, 242; 241, 243; 241, 244; 242, identifier:method_name; 243, identifier:is_class; 244, identifier:class_name; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:attach_to; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:kwargs; 251, identifier:pop; 252, argument_list; 252, 253; 252, 254; 253, string:"attach_to"; 254, list:[]; 255, if_statement; 255, 256; 255, 258; 256, not_operator; 256, 257; 257, identifier:attach_to; 258, block; 258, 259; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:attach_to; 263, identifier:append; 264, argument_list; 264, 265; 265, identifier:path; 266, for_statement; 266, 267; 266, 268; 266, 269; 267, identifier:path; 268, identifier:attach_to; 269, block; 269, 270; 269, 303; 270, if_statement; 270, 271; 270, 276; 271, comparison_operator:not; 271, 272; 271, 273; 272, identifier:path; 273, attribute; 273, 274; 273, 275; 274, identifier:self; 275, identifier:MENU; 276, block; 276, 277; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 284; 279, subscript; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:self; 282, identifier:MENU; 283, identifier:path; 284, dictionary; 284, 285; 284, 288; 284, 291; 284, 294; 284, 297; 284, 300; 285, pair; 285, 286; 285, 287; 286, string:"title"; 287, None; 288, pair; 288, 289; 288, 290; 289, string:"endpoint"; 290, None; 291, pair; 291, 292; 291, 293; 292, string:"endpoint_kwargs"; 293, dictionary; 294, pair; 294, 295; 294, 296; 295, string:"order"; 296, None; 297, pair; 297, 298; 297, 299; 298, string:"subnav"; 299, list:[]; 300, pair; 300, 301; 300, 302; 301, string:"kwargs"; 302, dictionary; 303, if_statement; 303, 304; 303, 305; 303, 336; 304, identifier:is_class; 305, block; 305, 306; 305, 316; 305, 326; 306, expression_statement; 306, 307; 307, assignment; 307, 308; 307, 315; 308, subscript; 308, 309; 308, 314; 309, subscript; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:self; 312, identifier:MENU; 313, identifier:path; 314, string:"title"; 315, identifier:title; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 325; 318, subscript; 318, 319; 318, 324; 319, subscript; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:self; 322, identifier:MENU; 323, identifier:path; 324, string:"order"; 325, identifier:order; 326, expression_statement; 326, 327; 327, assignment; 327, 328; 327, 335; 328, subscript; 328, 329; 328, 334; 329, subscript; 329, 330; 329, 333; 330, attribute; 330, 331; 330, 332; 331, identifier:self; 332, identifier:MENU; 333, identifier:path; 334, string:"kwargs"; 335, identifier:kwargs; 336, else_clause; 336, 337; 337, block; 337, 338; 338, expression_statement; 338, 339; 339, call; 339, 340; 339, 349; 340, attribute; 340, 341; 340, 348; 341, subscript; 341, 342; 341, 347; 342, subscript; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:self; 345, identifier:MENU; 346, identifier:path; 347, string:"subnav"; 348, identifier:append; 349, argument_list; 349, 350; 350, identifier:kwargs | def _push(self, title, view, class_name, is_class, **kwargs):
set_view_attr(view, "title", title, cls_name=class_name)
module_name = view.__module__
method_name = view.__name__
_endpoint = build_endpoint_route_name(view, "index" if is_class else method_name, class_name)
endpoint = kwargs.pop("endpoint", _endpoint)
kwargs.setdefault("endpoint_kwargs", {})
order = kwargs.pop("order", 0)
_nav_tags = get_view_attr(view, "nav_tags", ["default"], cls_name=class_name)
tags = kwargs.pop("tags", _nav_tags)
if not isinstance(tags, list):
_ = tags
tags = [_]
kwargs["tags"] = tags
visible = kwargs.pop("visible", [True])
if not isinstance(visible, list):
visible = [visible]
if get_view_attr(view, "nav_visible", cls_name=class_name) is False:
visible = False
kwargs["view"] = view
kwargs["visible"] = visible
kwargs["active"] = False
kwargs["key"] = class_name
if is_class:
kwargs["endpoint"] = endpoint
kwargs["has_subnav"] = True
else:
kwargs["has_subnav"] = False
kwargs.update({
"order": order,
"has_subnav": False,
"title": title,
"endpoint": endpoint,
})
self._title_map[endpoint] = title
path = "%s.%s" % (module_name, method_name if is_class else class_name)
attach_to = kwargs.pop("attach_to", [])
if not attach_to:
attach_to.append(path)
for path in attach_to:
if path not in self.MENU:
self.MENU[path] = {
"title": None,
"endpoint": None,
"endpoint_kwargs": {},
"order": None,
"subnav": [],
"kwargs": {}
}
if is_class:
self.MENU[path]["title"] = title
self.MENU[path]["order"] = order
self.MENU[path]["kwargs"] = kwargs
else:
self.MENU[path]["subnav"].append(kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:render; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 14; 5, 216; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:menu_list; 9, list:[]; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:menu_index; 13, integer:0; 14, for_statement; 14, 15; 14, 18; 14, 30; 15, pattern_list; 15, 16; 15, 17; 16, identifier:_; 17, identifier:menu; 18, call; 18, 19; 18, 29; 19, attribute; 19, 20; 19, 28; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:copy; 23, identifier:deepcopy; 24, argument_list; 24, 25; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:MENU; 28, identifier:items; 29, argument_list; 30, block; 30, 31; 30, 35; 30, 46; 30, 54; 30, 78; 30, 158; 30, 164; 30, 212; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:subnav; 34, list:[]; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 42; 37, subscript; 37, 38; 37, 41; 38, subscript; 38, 39; 38, 40; 39, identifier:menu; 40, string:"kwargs"; 41, string:"_id"; 42, call; 42, 43; 42, 44; 43, identifier:str; 44, argument_list; 44, 45; 45, identifier:menu_index; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 53; 48, subscript; 48, 49; 48, 52; 49, subscript; 49, 50; 49, 51; 50, identifier:menu; 51, string:"kwargs"; 52, string:"active"; 53, False; 54, if_statement; 54, 55; 54, 60; 55, comparison_operator:in; 55, 56; 55, 57; 56, string:"visible"; 57, subscript; 57, 58; 57, 59; 58, identifier:menu; 59, string:"kwargs"; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 68; 63, subscript; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:menu; 66, string:"kwargs"; 67, string:"visible"; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:_test_visibility; 72, argument_list; 72, 73; 73, subscript; 73, 74; 73, 77; 74, subscript; 74, 75; 74, 76; 75, identifier:menu; 76, string:"kwargs"; 77, string:"visible"; 78, for_statement; 78, 79; 78, 80; 78, 83; 79, identifier:s; 80, subscript; 80, 81; 80, 82; 81, identifier:menu; 82, string:"subnav"; 83, block; 83, 84; 83, 102; 83, 125; 83, 138; 83, 142; 83, 151; 84, if_statement; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:s; 87, string:"title"; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 94; 91, subscript; 91, 92; 91, 93; 92, identifier:s; 93, string:"title"; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:_get_title; 98, argument_list; 98, 99; 99, subscript; 99, 100; 99, 101; 100, identifier:s; 101, string:"title"; 102, if_statement; 102, 103; 102, 110; 103, comparison_operator:==; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:s; 106, string:"endpoint"; 107, attribute; 107, 108; 107, 109; 108, identifier:request; 109, identifier:endpoint; 110, block; 110, 111; 110, 117; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:s; 115, string:"active"; 116, True; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 124; 119, subscript; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:menu; 122, string:"kwargs"; 123, string:"active"; 124, True; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:s; 129, string:"visible"; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:_test_visibility; 134, argument_list; 134, 135; 135, subscript; 135, 136; 135, 137; 136, identifier:s; 137, string:"visible"; 138, expression_statement; 138, 139; 139, augmented_assignment:+=; 139, 140; 139, 141; 140, identifier:menu_index; 141, integer:1; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 147; 144, subscript; 144, 145; 144, 146; 145, identifier:s; 146, string:"_id"; 147, call; 147, 148; 147, 149; 148, identifier:str; 149, argument_list; 149, 150; 150, identifier:menu_index; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:subnav; 155, identifier:append; 156, argument_list; 156, 157; 157, identifier:s; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:_kwargs; 161, subscript; 161, 162; 161, 163; 162, identifier:menu; 163, string:"kwargs"; 164, if_statement; 164, 165; 164, 168; 164, 206; 165, subscript; 165, 166; 165, 167; 166, identifier:menu; 167, string:"title"; 168, block; 168, 169; 168, 199; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:_kwargs; 173, identifier:update; 174, argument_list; 174, 175; 175, dictionary; 175, 176; 175, 184; 175, 189; 176, pair; 176, 177; 176, 178; 177, string:"subnav"; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:self; 181, identifier:_sort; 182, argument_list; 182, 183; 183, identifier:subnav; 184, pair; 184, 185; 184, 186; 185, string:"order"; 186, subscript; 186, 187; 186, 188; 187, identifier:menu; 188, string:"order"; 189, pair; 189, 190; 189, 191; 190, string:"title"; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:self; 194, identifier:_get_title; 195, argument_list; 195, 196; 196, subscript; 196, 197; 196, 198; 197, identifier:menu; 198, string:"title"; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:menu_list; 203, identifier:append; 204, argument_list; 204, 205; 205, identifier:_kwargs; 206, else_clause; 206, 207; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, augmented_assignment:+=; 209, 210; 209, 211; 210, identifier:menu_list; 211, identifier:subnav; 212, expression_statement; 212, 213; 213, augmented_assignment:+=; 213, 214; 213, 215; 214, identifier:menu_index; 215, integer:1; 216, return_statement; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:_sort; 221, argument_list; 221, 222; 222, identifier:menu_list | def render(self):
menu_list = []
menu_index = 0
for _, menu in copy.deepcopy(self.MENU).items():
subnav = []
menu["kwargs"]["_id"] = str(menu_index)
menu["kwargs"]["active"] = False
if "visible" in menu["kwargs"]:
menu["kwargs"]["visible"] = self._test_visibility(menu["kwargs"]["visible"])
for s in menu["subnav"]:
if s["title"]:
s["title"] = self._get_title(s["title"])
if s["endpoint"] == request.endpoint:
s["active"] = True
menu["kwargs"]["active"] = True
s["visible"] = self._test_visibility(s["visible"])
menu_index += 1
s["_id"] = str(menu_index)
subnav.append(s)
_kwargs = menu["kwargs"]
if menu["title"]:
_kwargs.update({
"subnav": self._sort(subnav),
"order": menu["order"],
"title": self._get_title(menu["title"])
})
menu_list.append(_kwargs)
else:
menu_list += subnav
menu_index += 1
return self._sort(menu_list) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:add_item; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:self; 5, identifier:url; 6, default_parameter; 6, 7; 6, 8; 7, identifier:title; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:selection; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:jsonp; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:redirect; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:response_info; 20, False; 21, block; 21, 22; 21, 39; 21, 58; 21, 69; 21, 80; 21, 91; 21, 105; 21, 112; 21, 123; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:parameters; 25, dictionary; 25, 26; 25, 31; 25, 36; 26, pair; 26, 27; 26, 28; 27, string:'username'; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:user; 31, pair; 31, 32; 31, 33; 32, string:'password'; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:password; 36, pair; 36, 37; 36, 38; 37, string:'url'; 38, identifier:url; 39, if_statement; 39, 40; 39, 43; 39, 50; 40, comparison_operator:is; 40, 41; 40, 42; 41, identifier:title; 42, None; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:parameters; 48, string:'title'; 49, identifier:title; 50, else_clause; 50, 51; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 57; 54, subscript; 54, 55; 54, 56; 55, identifier:parameters; 56, string:'auto-title'; 57, integer:1; 58, if_statement; 58, 59; 58, 62; 59, comparison_operator:is; 59, 60; 59, 61; 60, identifier:selection; 61, None; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:parameters; 67, string:'selection'; 68, identifier:selection; 69, if_statement; 69, 70; 69, 73; 70, comparison_operator:is; 70, 71; 70, 72; 71, identifier:redirect; 72, None; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:parameters; 78, string:'redirect'; 79, identifier:redirect; 80, if_statement; 80, 81; 80, 84; 81, comparison_operator:is; 81, 82; 81, 83; 82, identifier:jsonp; 83, None; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:parameters; 89, string:'jsonp'; 90, identifier:jsonp; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, pattern_list; 93, 94; 93, 95; 94, identifier:status; 95, identifier:headers; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:_query; 100, argument_list; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:addurl; 104, identifier:parameters; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:is; 106, 107; 106, 108; 107, identifier:jsonp; 108, None; 109, block; 109, 110; 110, return_statement; 110, 111; 111, identifier:status; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:statustxt; 115, subscript; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:add_status_codes; 119, call; 119, 120; 119, 121; 120, identifier:int; 121, argument_list; 121, 122; 122, identifier:status; 123, if_statement; 123, 124; 123, 125; 123, 139; 124, identifier:response_info; 125, block; 125, 126; 126, return_statement; 126, 127; 127, tuple; 127, 128; 127, 132; 127, 133; 127, 136; 128, call; 128, 129; 128, 130; 129, identifier:int; 130, argument_list; 130, 131; 131, identifier:status; 132, identifier:statustxt; 133, subscript; 133, 134; 133, 135; 134, identifier:headers; 135, string:'title'; 136, subscript; 136, 137; 136, 138; 137, identifier:headers; 138, string:'location'; 139, else_clause; 139, 140; 140, block; 140, 141; 141, return_statement; 141, 142; 142, tuple; 142, 143; 142, 147; 143, call; 143, 144; 143, 145; 144, identifier:int; 145, argument_list; 145, 146; 146, identifier:status; 147, identifier:statustxt | def add_item(self, url, title=None, selection=None,
jsonp=None, redirect=None, response_info=False):
parameters = {
'username' : self.user,
'password' : self.password,
'url' : url,
}
if title is not None:
parameters['title'] = title
else:
parameters['auto-title'] = 1
if selection is not None:
parameters['selection'] = selection
if redirect is not None:
parameters['redirect'] = redirect
if jsonp is not None:
parameters['jsonp'] = jsonp
status, headers = self._query(self.addurl, parameters)
if jsonp is not None:
return status
statustxt = self.add_status_codes[int(status)]
if response_info:
return (int(status), statustxt, headers['title'], headers['location'])
else:
return (int(status), statustxt) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_determine_representative_chains; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 12; 5, 18; 5, 150; 5, 171; 5, 177; 6, expression_statement; 6, 7; 7, string:''' Quotient the chains to get equivalence classes of chains. These will be used for the actual mapping.'''; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:equivalence_fiber; 11, dictionary; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:matched_chains; 15, call; 15, 16; 15, 17; 16, identifier:set; 17, argument_list; 18, for_statement; 18, 19; 18, 22; 18, 29; 19, pattern_list; 19, 20; 19, 21; 20, identifier:chain_id; 21, identifier:equivalent_chains; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:identical_sequences; 27, identifier:iteritems; 28, argument_list; 29, block; 29, 30; 29, 37; 29, 43; 29, 91; 29, 95; 29, 128; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:matched_chains; 34, identifier:add; 35, argument_list; 35, 36; 36, identifier:chain_id; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:equivalent_chain_ids; 40, call; 40, 41; 40, 42; 41, identifier:set; 42, argument_list; 43, for_statement; 43, 44; 43, 45; 43, 46; 44, identifier:equivalent_chain; 45, identifier:equivalent_chains; 46, block; 46, 47; 46, 55; 46, 82; 47, assert_statement; 47, 48; 48, parenthesized_expression; 48, 49; 49, comparison_operator:==; 49, 50; 49, 54; 50, call; 50, 51; 50, 52; 51, identifier:len; 52, argument_list; 52, 53; 53, identifier:equivalent_chain; 54, integer:6; 55, assert_statement; 55, 56; 56, parenthesized_expression; 56, 57; 57, boolean_operator:or; 57, 58; 57, 70; 58, parenthesized_expression; 58, 59; 59, comparison_operator:==; 59, 60; 59, 65; 60, subscript; 60, 61; 60, 62; 61, identifier:equivalent_chain; 62, slice; 62, 63; 62, 64; 63, colon; 64, integer:5; 65, binary_operator:%; 65, 66; 65, 67; 66, string:'%s_'; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:pdb_id; 70, parenthesized_expression; 70, 71; 71, comparison_operator:==; 71, 72; 71, 77; 72, subscript; 72, 73; 72, 74; 73, identifier:equivalent_chain; 74, slice; 74, 75; 74, 76; 75, colon; 76, integer:5; 77, binary_operator:%; 77, 78; 77, 79; 78, string:'%s:'; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:pdb_id; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:equivalent_chain_ids; 86, identifier:add; 87, argument_list; 87, 88; 88, subscript; 88, 89; 88, 90; 89, identifier:equivalent_chain; 90, integer:5; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:found; 94, False; 95, for_statement; 95, 96; 95, 97; 95, 98; 96, identifier:equivalent_chain_id; 97, identifier:equivalent_chain_ids; 98, block; 98, 99; 99, if_statement; 99, 100; 99, 106; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:equivalence_fiber; 103, identifier:get; 104, argument_list; 104, 105; 105, identifier:equivalent_chain_id; 106, block; 106, 107; 106, 111; 106, 127; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:found; 110, True; 111, assert_statement; 111, 112; 112, parenthesized_expression; 112, 113; 113, comparison_operator:==; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:equivalence_fiber; 116, identifier:equivalent_chain_id; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:equivalent_chain_ids; 120, identifier:union; 121, argument_list; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:set; 124, argument_list; 124, 125; 125, list:[chain_id]; 125, 126; 126, identifier:chain_id; 127, break_statement; 128, if_statement; 128, 129; 128, 131; 129, not_operator; 129, 130; 130, identifier:found; 131, block; 131, 132; 131, 141; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:equivalence_fiber; 136, identifier:chain_id; 137, call; 137, 138; 137, 139; 138, identifier:set; 139, argument_list; 139, 140; 140, identifier:equivalent_chain_ids; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 148; 143, attribute; 143, 144; 143, 147; 144, subscript; 144, 145; 144, 146; 145, identifier:equivalence_fiber; 146, identifier:chain_id; 147, identifier:add; 148, argument_list; 148, 149; 149, identifier:chain_id; 150, for_statement; 150, 151; 150, 152; 150, 155; 151, identifier:c; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:chains; 155, block; 155, 156; 156, if_statement; 156, 157; 156, 160; 157, comparison_operator:not; 157, 158; 157, 159; 158, identifier:c; 159, identifier:matched_chains; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:equivalence_fiber; 165, identifier:c; 166, call; 166, 167; 166, 168; 167, identifier:set; 168, argument_list; 168, 169; 169, list:[c]; 169, 170; 170, identifier:c; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:equivalence_fiber; 176, identifier:equivalence_fiber; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:self; 181, identifier:representative_chains; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:equivalence_fiber; 185, identifier:keys; 186, argument_list | def _determine_representative_chains(self):
''' Quotient the chains to get equivalence classes of chains. These will be used for the actual mapping.'''
equivalence_fiber = {}
matched_chains = set()
for chain_id, equivalent_chains in self.identical_sequences.iteritems():
matched_chains.add(chain_id)
equivalent_chain_ids = set()
for equivalent_chain in equivalent_chains:
assert(len(equivalent_chain) == 6)
assert((equivalent_chain[:5] == '%s_' % self.pdb_id) or (equivalent_chain[:5] == '%s:' % self.pdb_id))
equivalent_chain_ids.add(equivalent_chain[5])
found = False
for equivalent_chain_id in equivalent_chain_ids:
if equivalence_fiber.get(equivalent_chain_id):
found = True
assert(equivalence_fiber[equivalent_chain_id] == equivalent_chain_ids.union(set([chain_id])))
break
if not found:
equivalence_fiber[chain_id] = set(equivalent_chain_ids)
equivalence_fiber[chain_id].add(chain_id)
for c in self.chains:
if c not in matched_chains:
equivalence_fiber[c] = set([c])
self.equivalence_fiber = equivalence_fiber
self.representative_chains = equivalence_fiber.keys() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:_align_with_substrings; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:chains_to_skip; 7, call; 7, 8; 7, 9; 8, identifier:set; 9, argument_list; 10, block; 10, 11; 10, 13; 10, 186; 10, 195; 10, 204; 10, 332; 11, expression_statement; 11, 12; 12, string:'''Simple substring-based matching'''; 13, for_statement; 13, 14; 13, 15; 13, 18; 14, identifier:c; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:representative_chains; 18, block; 18, 19; 19, if_statement; 19, 20; 19, 23; 20, comparison_operator:not; 20, 21; 20, 22; 21, identifier:c; 22, identifier:chains_to_skip; 23, block; 23, 24; 23, 32; 23, 36; 23, 178; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:fasta_sequence; 27, subscript; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:fasta; 31, identifier:c; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:substring_matches; 35, dictionary; 36, for_statement; 36, 37; 36, 40; 36, 50; 37, pattern_list; 37, 38; 37, 39; 38, identifier:uniparc_id; 39, identifier:uniparc_sequence; 40, call; 40, 41; 40, 42; 41, identifier:sorted; 42, argument_list; 42, 43; 43, call; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:uniparc_sequences; 48, identifier:iteritems; 49, argument_list; 50, block; 50, 51; 50, 58; 50, 67; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:uniparc_sequence; 54, call; 54, 55; 54, 56; 55, identifier:str; 56, argument_list; 56, 57; 57, identifier:uniparc_sequence; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:idx; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:uniparc_sequence; 64, identifier:find; 65, argument_list; 65, 66; 66, identifier:fasta_sequence; 67, if_statement; 67, 68; 67, 72; 67, 79; 67, 143; 68, comparison_operator:!=; 68, 69; 68, 70; 69, identifier:idx; 70, unary_operator:-; 70, 71; 71, integer:1; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 78; 75, subscript; 75, 76; 75, 77; 76, identifier:substring_matches; 77, identifier:uniparc_id; 78, integer:0; 79, elif_clause; 79, 80; 79, 86; 80, comparison_operator:>; 80, 81; 80, 85; 81, call; 81, 82; 81, 83; 82, identifier:len; 83, argument_list; 83, 84; 84, identifier:fasta_sequence; 85, integer:30; 86, block; 86, 87; 86, 102; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:idx; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:uniparc_sequence; 93, identifier:find; 94, argument_list; 94, 95; 95, subscript; 95, 96; 95, 97; 96, identifier:fasta_sequence; 97, slice; 97, 98; 97, 99; 97, 100; 98, integer:5; 99, colon; 100, unary_operator:-; 100, 101; 101, integer:5; 102, if_statement; 102, 103; 102, 107; 102, 114; 103, comparison_operator:!=; 103, 104; 103, 105; 104, identifier:idx; 105, unary_operator:-; 105, 106; 106, integer:1; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:substring_matches; 112, identifier:uniparc_id; 113, integer:5; 114, else_clause; 114, 115; 115, block; 115, 116; 115, 131; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:idx; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:uniparc_sequence; 122, identifier:find; 123, argument_list; 123, 124; 124, subscript; 124, 125; 124, 126; 125, identifier:fasta_sequence; 126, slice; 126, 127; 126, 128; 126, 129; 127, integer:7; 128, colon; 129, unary_operator:-; 129, 130; 130, integer:7; 131, if_statement; 131, 132; 131, 136; 132, comparison_operator:!=; 132, 133; 132, 134; 133, identifier:idx; 134, unary_operator:-; 134, 135; 135, integer:1; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:substring_matches; 141, identifier:uniparc_id; 142, integer:7; 143, elif_clause; 143, 144; 143, 150; 144, comparison_operator:>; 144, 145; 144, 149; 145, call; 145, 146; 145, 147; 146, identifier:len; 147, argument_list; 147, 148; 148, identifier:fasta_sequence; 149, integer:15; 150, block; 150, 151; 150, 166; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:idx; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:uniparc_sequence; 157, identifier:find; 158, argument_list; 158, 159; 159, subscript; 159, 160; 159, 161; 160, identifier:fasta_sequence; 161, slice; 161, 162; 161, 163; 161, 164; 162, integer:3; 163, colon; 164, unary_operator:-; 164, 165; 165, integer:3; 166, if_statement; 166, 167; 166, 171; 167, comparison_operator:!=; 167, 168; 167, 169; 168, identifier:idx; 169, unary_operator:-; 169, 170; 170, integer:1; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:substring_matches; 176, identifier:uniparc_id; 177, integer:3; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 185; 180, subscript; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:substring_matches; 184, identifier:c; 185, identifier:substring_matches; 186, expression_statement; 186, 187; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:colortext; 190, identifier:pcyan; 191, argument_list; 191, 192; 192, binary_operator:*; 192, 193; 192, 194; 193, string:'*'; 194, integer:100; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:pprint; 199, identifier:pprint; 200, argument_list; 200, 201; 201, attribute; 201, 202; 201, 203; 202, identifier:self; 203, identifier:substring_matches; 204, if_statement; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:self; 207, identifier:restrict_to_uniparc_values; 208, block; 208, 209; 209, for_statement; 209, 210; 209, 211; 209, 214; 210, identifier:c; 211, attribute; 211, 212; 211, 213; 212, identifier:self; 213, identifier:representative_chains; 214, block; 214, 215; 215, if_statement; 215, 216; 215, 244; 216, comparison_operator:>; 216, 217; 216, 243; 217, call; 217, 218; 217, 236; 218, attribute; 218, 219; 218, 235; 219, call; 219, 220; 219, 221; 220, identifier:set; 221, argument_list; 221, 222; 222, call; 222, 223; 222, 224; 223, identifier:map; 224, argument_list; 224, 225; 224, 226; 225, identifier:str; 226, call; 226, 227; 226, 234; 227, attribute; 227, 228; 227, 233; 228, subscript; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:self; 231, identifier:substring_matches; 232, identifier:c; 233, identifier:keys; 234, argument_list; 235, identifier:intersection; 236, argument_list; 236, 237; 237, call; 237, 238; 237, 239; 238, identifier:set; 239, argument_list; 239, 240; 240, attribute; 240, 241; 240, 242; 241, identifier:self; 242, identifier:restrict_to_uniparc_values; 243, integer:0; 244, block; 244, 245; 244, 283; 244, 324; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:restricted_matches; 248, call; 248, 249; 248, 250; 249, identifier:dict; 250, generator_expression; 250, 251; 250, 263; 250, 274; 251, tuple; 251, 252; 251, 256; 252, call; 252, 253; 252, 254; 253, identifier:str; 254, argument_list; 254, 255; 255, identifier:k; 256, subscript; 256, 257; 256, 262; 257, subscript; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:self; 260, identifier:substring_matches; 261, identifier:c; 262, identifier:k; 263, for_in_clause; 263, 264; 263, 265; 264, identifier:k; 265, call; 265, 266; 265, 273; 266, attribute; 266, 267; 266, 272; 267, subscript; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:self; 270, identifier:substring_matches; 271, identifier:c; 272, identifier:keys; 273, argument_list; 274, if_clause; 274, 275; 275, comparison_operator:in; 275, 276; 275, 280; 276, call; 276, 277; 276, 278; 277, identifier:str; 278, argument_list; 278, 279; 279, identifier:k; 280, attribute; 280, 281; 280, 282; 281, identifier:self; 282, identifier:restrict_to_uniparc_values; 283, if_statement; 283, 284; 283, 297; 284, comparison_operator:!=; 284, 285; 284, 289; 285, call; 285, 286; 285, 287; 286, identifier:len; 287, argument_list; 287, 288; 288, identifier:restricted_matches; 289, call; 289, 290; 289, 291; 290, identifier:len; 291, argument_list; 291, 292; 292, subscript; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:self; 295, identifier:substring_matches; 296, identifier:c; 297, block; 297, 298; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 301; 300, identifier:removed_matches; 301, call; 301, 302; 301, 303; 302, identifier:sorted; 303, argument_list; 303, 304; 304, call; 304, 305; 304, 319; 305, attribute; 305, 306; 305, 318; 306, call; 306, 307; 306, 308; 307, identifier:set; 308, argument_list; 308, 309; 309, call; 309, 310; 309, 317; 310, attribute; 310, 311; 310, 316; 311, subscript; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:self; 314, identifier:substring_matches; 315, identifier:c; 316, identifier:keys; 317, argument_list; 318, identifier:difference; 319, argument_list; 319, 320; 320, call; 320, 321; 320, 322; 321, identifier:set; 322, argument_list; 322, 323; 323, identifier:restricted_matches; 324, expression_statement; 324, 325; 325, assignment; 325, 326; 325, 331; 326, subscript; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, identifier:self; 329, identifier:substring_matches; 330, identifier:c; 331, identifier:restricted_matches; 332, for_statement; 332, 333; 332, 336; 332, 343; 333, pattern_list; 333, 334; 333, 335; 334, identifier:c_1; 335, identifier:related_chains; 336, call; 336, 337; 336, 342; 337, attribute; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:self; 340, identifier:equivalence_fiber; 341, identifier:iteritems; 342, argument_list; 343, block; 343, 344; 344, for_statement; 344, 345; 344, 346; 344, 347; 345, identifier:c_2; 346, identifier:related_chains; 347, block; 347, 348; 348, expression_statement; 348, 349; 349, assignment; 349, 350; 349, 355; 350, subscript; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:self; 353, identifier:substring_matches; 354, identifier:c_2; 355, subscript; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, identifier:self; 358, identifier:substring_matches; 359, identifier:c_1 | def _align_with_substrings(self, chains_to_skip = set()):
'''Simple substring-based matching'''
for c in self.representative_chains:
if c not in chains_to_skip:
fasta_sequence = self.fasta[c]
substring_matches = {}
for uniparc_id, uniparc_sequence in sorted(self.uniparc_sequences.iteritems()):
uniparc_sequence = str(uniparc_sequence)
idx = uniparc_sequence.find(fasta_sequence)
if idx != -1:
substring_matches[uniparc_id] = 0
elif len(fasta_sequence) > 30:
idx = uniparc_sequence.find(fasta_sequence[5:-5])
if idx != -1:
substring_matches[uniparc_id] = 5
else:
idx = uniparc_sequence.find(fasta_sequence[7:-7])
if idx != -1:
substring_matches[uniparc_id] = 7
elif len(fasta_sequence) > 15:
idx = uniparc_sequence.find(fasta_sequence[3:-3])
if idx != -1:
substring_matches[uniparc_id] = 3
self.substring_matches[c] = substring_matches
colortext.pcyan('*' * 100)
pprint.pprint(self.substring_matches)
if self.restrict_to_uniparc_values:
for c in self.representative_chains:
if set(map(str, self.substring_matches[c].keys())).intersection(set(self.restrict_to_uniparc_values)) > 0:
restricted_matches = dict((str(k), self.substring_matches[c][k]) for k in self.substring_matches[c].keys() if str(k) in self.restrict_to_uniparc_values)
if len(restricted_matches) != len(self.substring_matches[c]):
removed_matches = sorted(set(self.substring_matches[c].keys()).difference(set(restricted_matches)))
self.substring_matches[c] = restricted_matches
for c_1, related_chains in self.equivalence_fiber.iteritems():
for c_2 in related_chains:
self.substring_matches[c_2] = self.substring_matches[c_1] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_chain_mutations; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:pdb_id_1; 6, identifier:chain_1; 7, identifier:pdb_id_2; 8, identifier:chain_2; 9, block; 9, 10; 9, 12; 9, 21; 9, 30; 9, 42; 9, 54; 9, 66; 9, 88; 9, 110; 9, 125; 9, 140; 9, 155; 9, 170; 9, 177; 9, 184; 9, 190; 9, 204; 9, 218; 9, 224; 9, 234; 9, 240; 9, 259; 9, 280; 9, 294; 9, 298; 9, 304; 9, 456; 10, expression_statement; 10, 11; 11, string:'''Returns a list of tuples each containing a SEQRES Mutation object and an ATOM Mutation object representing the
mutations from pdb_id_1, chain_1 to pdb_id_2, chain_2.
SequenceMaps are constructed in this function between the chains based on the alignment.
PDBMutationPair are returned as they are hashable and amenable to Set construction to eliminate duplicates.
'''; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:p1; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:add_pdb; 19, argument_list; 19, 20; 20, identifier:pdb_id_1; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:p2; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:add_pdb; 28, argument_list; 28, 29; 29, identifier:pdb_id_2; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, pattern_list; 32, 33; 32, 34; 33, identifier:sifts_1; 34, identifier:pdb_1; 35, expression_list; 35, 36; 35, 39; 36, subscript; 36, 37; 36, 38; 37, identifier:p1; 38, string:'sifts'; 39, subscript; 39, 40; 39, 41; 40, identifier:p1; 41, string:'pdb'; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, pattern_list; 44, 45; 44, 46; 45, identifier:sifts_2; 46, identifier:pdb_2; 47, expression_list; 47, 48; 47, 51; 48, subscript; 48, 49; 48, 50; 49, identifier:p2; 50, string:'sifts'; 51, subscript; 51, 52; 51, 53; 52, identifier:p2; 53, string:'pdb'; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:seqres_to_atom_sequence_maps_1; 57, call; 57, 58; 57, 63; 58, attribute; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:sifts_1; 61, identifier:seqres_to_atom_sequence_maps; 62, identifier:get; 63, argument_list; 63, 64; 63, 65; 64, identifier:chain_1; 65, dictionary; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 71; 68, pattern_list; 68, 69; 68, 70; 69, identifier:seqres_1; 70, identifier:atom_1; 71, expression_list; 71, 72; 71, 80; 72, call; 72, 73; 72, 78; 73, attribute; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:pdb_1; 76, identifier:seqres_sequences; 77, identifier:get; 78, argument_list; 78, 79; 79, identifier:chain_1; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:pdb_1; 84, identifier:atom_sequences; 85, identifier:get; 86, argument_list; 86, 87; 87, identifier:chain_1; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 93; 90, pattern_list; 90, 91; 90, 92; 91, identifier:seqres_2; 92, identifier:atom_2; 93, expression_list; 93, 94; 93, 102; 94, call; 94, 95; 94, 100; 95, attribute; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:pdb_2; 98, identifier:seqres_sequences; 99, identifier:get; 100, argument_list; 100, 101; 101, identifier:chain_2; 102, call; 102, 103; 102, 108; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:pdb_2; 106, identifier:atom_sequences; 107, identifier:get; 108, argument_list; 108, 109; 109, identifier:chain_2; 110, if_statement; 110, 111; 110, 113; 111, not_operator; 111, 112; 112, identifier:seqres_1; 113, block; 113, 114; 114, raise_statement; 114, 115; 115, call; 115, 116; 115, 117; 116, identifier:Exception; 117, argument_list; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, string:'No SEQRES sequence for chain {0} of {1}.'; 121, identifier:format; 122, argument_list; 122, 123; 122, 124; 123, identifier:chain_1; 124, identifier:pdb_1; 125, if_statement; 125, 126; 125, 128; 126, not_operator; 126, 127; 127, identifier:atom_1; 128, block; 128, 129; 129, raise_statement; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:Exception; 132, argument_list; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, string:'No ATOM sequence for chain {0} of {1}.'; 136, identifier:format; 137, argument_list; 137, 138; 137, 139; 138, identifier:chain_1; 139, identifier:pdb_1; 140, if_statement; 140, 141; 140, 143; 141, not_operator; 141, 142; 142, identifier:seqres_2; 143, block; 143, 144; 144, raise_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:Exception; 147, argument_list; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, string:'No SEQRES sequence for chain {0} of {1}.'; 151, identifier:format; 152, argument_list; 152, 153; 152, 154; 153, identifier:chain_2; 154, identifier:pdb_2; 155, if_statement; 155, 156; 155, 158; 156, not_operator; 156, 157; 157, identifier:atom_2; 158, block; 158, 159; 159, raise_statement; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:Exception; 162, argument_list; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, string:'No ATOM sequence for chain {0} of {1}.'; 166, identifier:format; 167, argument_list; 167, 168; 167, 169; 168, identifier:chain_2; 169, identifier:pdb_2; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:seqres_str_1; 173, call; 173, 174; 173, 175; 174, identifier:str; 175, argument_list; 175, 176; 176, identifier:seqres_1; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:seqres_str_2; 180, call; 180, 181; 180, 182; 181, identifier:str; 182, argument_list; 182, 183; 183, identifier:seqres_2; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:sa; 187, call; 187, 188; 187, 189; 188, identifier:SequenceAligner; 189, argument_list; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:sa; 194, identifier:add_sequence; 195, argument_list; 195, 196; 195, 203; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, string:'{0}_{1}'; 199, identifier:format; 200, argument_list; 200, 201; 200, 202; 201, identifier:pdb_id_1; 202, identifier:chain_1; 203, identifier:seqres_str_1; 204, expression_statement; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:sa; 208, identifier:add_sequence; 209, argument_list; 209, 210; 209, 217; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, string:'{0}_{1}'; 213, identifier:format; 214, argument_list; 214, 215; 214, 216; 215, identifier:pdb_id_2; 216, identifier:chain_2; 217, identifier:seqres_str_2; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:sa; 222, identifier:align; 223, argument_list; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 229; 226, pattern_list; 226, 227; 226, 228; 227, identifier:seqres_residue_mapping; 228, identifier:seqres_match_mapping; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:sa; 232, identifier:get_residue_mapping; 233, argument_list; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:seqres_sequence_map; 237, call; 237, 238; 237, 239; 238, identifier:SequenceMap; 239, argument_list; 240, assert_statement; 240, 241; 241, parenthesized_expression; 241, 242; 242, comparison_operator:==; 242, 243; 242, 251; 243, call; 243, 244; 243, 245; 244, identifier:sorted; 245, argument_list; 245, 246; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:seqres_residue_mapping; 249, identifier:keys; 250, argument_list; 251, call; 251, 252; 251, 253; 252, identifier:sorted; 253, argument_list; 253, 254; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:seqres_match_mapping; 257, identifier:keys; 258, argument_list; 259, for_statement; 259, 260; 259, 263; 259, 268; 260, pattern_list; 260, 261; 260, 262; 261, identifier:k; 262, identifier:v; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:seqres_residue_mapping; 266, identifier:iteritems; 267, argument_list; 268, block; 268, 269; 269, expression_statement; 269, 270; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:seqres_sequence_map; 273, identifier:add; 274, argument_list; 274, 275; 274, 276; 274, 277; 275, identifier:k; 276, identifier:v; 277, subscript; 277, 278; 277, 279; 278, identifier:seqres_match_mapping; 279, identifier:k; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 293; 282, subscript; 282, 283; 282, 290; 283, subscript; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:self; 286, identifier:seqres_sequence_maps; 287, tuple; 287, 288; 287, 289; 288, identifier:pdb_id_1; 289, identifier:chain_1; 290, tuple; 290, 291; 290, 292; 291, identifier:pdb_id_2; 292, identifier:chain_2; 293, identifier:seqres_sequence_map; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:mutations; 297, list:[]; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 301; 300, identifier:clustal_symbols; 301, attribute; 301, 302; 301, 303; 302, identifier:SubstitutionScore; 303, identifier:clustal_symbols; 304, for_statement; 304, 305; 304, 308; 304, 313; 305, pattern_list; 305, 306; 305, 307; 306, identifier:seqres_res_id; 307, identifier:v; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:seqres_match_mapping; 311, identifier:iteritems; 312, argument_list; 313, block; 313, 314; 314, if_statement; 314, 315; 314, 322; 315, comparison_operator:!=; 315, 316; 315, 321; 316, subscript; 316, 317; 316, 318; 317, identifier:clustal_symbols; 318, attribute; 318, 319; 318, 320; 319, identifier:v; 320, identifier:clustal; 321, string:'*'; 322, block; 322, 323; 322, 329; 322, 337; 322, 341; 322, 350; 322, 406; 322, 422; 322, 426; 322, 445; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:seqres_wt_residue; 326, subscript; 326, 327; 326, 328; 327, identifier:seqres_1; 328, identifier:seqres_res_id; 329, expression_statement; 329, 330; 330, assignment; 330, 331; 330, 332; 331, identifier:seqres_mutant_residue; 332, subscript; 332, 333; 332, 334; 333, identifier:seqres_2; 334, subscript; 334, 335; 334, 336; 335, identifier:seqres_residue_mapping; 336, identifier:seqres_res_id; 337, expression_statement; 337, 338; 338, assignment; 338, 339; 338, 340; 339, identifier:atom_res_id; 340, None; 341, expression_statement; 341, 342; 342, assignment; 342, 343; 342, 344; 343, identifier:atom_chain_res_id; 344, call; 344, 345; 344, 348; 345, attribute; 345, 346; 345, 347; 346, identifier:seqres_to_atom_sequence_maps_1; 347, identifier:get; 348, argument_list; 348, 349; 349, identifier:seqres_res_id; 350, try_statement; 350, 351; 350, 392; 351, block; 351, 352; 352, if_statement; 352, 353; 352, 354; 353, identifier:atom_chain_res_id; 354, block; 354, 355; 354, 362; 354, 368; 354, 376; 354, 385; 355, assert_statement; 355, 356; 356, parenthesized_expression; 356, 357; 357, comparison_operator:==; 357, 358; 357, 361; 358, subscript; 358, 359; 358, 360; 359, identifier:atom_chain_res_id; 360, integer:0; 361, identifier:chain_1; 362, expression_statement; 362, 363; 363, assignment; 363, 364; 363, 365; 364, identifier:atom_residue; 365, subscript; 365, 366; 365, 367; 366, identifier:atom_1; 367, identifier:atom_chain_res_id; 368, expression_statement; 368, 369; 369, assignment; 369, 370; 369, 371; 370, identifier:atom_res_id; 371, subscript; 371, 372; 371, 373; 372, identifier:atom_chain_res_id; 373, slice; 373, 374; 373, 375; 374, integer:1; 375, colon; 376, assert_statement; 376, 377; 377, parenthesized_expression; 377, 378; 378, comparison_operator:==; 378, 379; 378, 382; 379, attribute; 379, 380; 379, 381; 380, identifier:atom_residue; 381, identifier:ResidueAA; 382, attribute; 382, 383; 382, 384; 383, identifier:seqres_wt_residue; 384, identifier:ResidueAA; 385, assert_statement; 385, 386; 386, parenthesized_expression; 386, 387; 387, comparison_operator:==; 387, 388; 387, 391; 388, attribute; 388, 389; 388, 390; 389, identifier:atom_residue; 390, identifier:ResidueID; 391, identifier:atom_res_id; 392, except_clause; 392, 393; 393, block; 393, 394; 393, 398; 394, expression_statement; 394, 395; 395, assignment; 395, 396; 395, 397; 396, identifier:atom_res_id; 397, None; 398, if_statement; 398, 399; 398, 404; 399, comparison_operator:!=; 399, 400; 399, 403; 400, attribute; 400, 401; 400, 402; 401, identifier:seqres_wt_residue; 402, identifier:ResidueAA; 403, string:'X'; 404, block; 404, 405; 405, raise_statement; 406, expression_statement; 406, 407; 407, assignment; 407, 408; 407, 409; 408, identifier:seqres_mutation; 409, call; 409, 410; 409, 411; 410, identifier:ChainMutation; 411, argument_list; 411, 412; 411, 415; 411, 416; 411, 419; 412, attribute; 412, 413; 412, 414; 413, identifier:seqres_wt_residue; 414, identifier:ResidueAA; 415, identifier:seqres_res_id; 416, attribute; 416, 417; 416, 418; 417, identifier:seqres_mutant_residue; 418, identifier:ResidueAA; 419, keyword_argument; 419, 420; 419, 421; 420, identifier:Chain; 421, identifier:chain_1; 422, expression_statement; 422, 423; 423, assignment; 423, 424; 423, 425; 424, identifier:atom_mutation; 425, None; 426, if_statement; 426, 427; 426, 428; 427, identifier:atom_res_id; 428, block; 428, 429; 429, expression_statement; 429, 430; 430, assignment; 430, 431; 430, 432; 431, identifier:atom_mutation; 432, call; 432, 433; 432, 434; 433, identifier:ChainMutation; 434, argument_list; 434, 435; 434, 438; 434, 439; 434, 442; 435, attribute; 435, 436; 435, 437; 436, identifier:seqres_wt_residue; 437, identifier:ResidueAA; 438, identifier:atom_res_id; 439, attribute; 439, 440; 439, 441; 440, identifier:seqres_mutant_residue; 441, identifier:ResidueAA; 442, keyword_argument; 442, 443; 442, 444; 443, identifier:Chain; 444, identifier:chain_1; 445, expression_statement; 445, 446; 446, call; 446, 447; 446, 450; 447, attribute; 447, 448; 447, 449; 448, identifier:mutations; 449, identifier:append; 450, argument_list; 450, 451; 451, call; 451, 452; 451, 453; 452, identifier:PDBMutationPair; 453, argument_list; 453, 454; 453, 455; 454, identifier:seqres_mutation; 455, identifier:atom_mutation; 456, return_statement; 456, 457; 457, identifier:mutations | def get_chain_mutations(self, pdb_id_1, chain_1, pdb_id_2, chain_2):
'''Returns a list of tuples each containing a SEQRES Mutation object and an ATOM Mutation object representing the
mutations from pdb_id_1, chain_1 to pdb_id_2, chain_2.
SequenceMaps are constructed in this function between the chains based on the alignment.
PDBMutationPair are returned as they are hashable and amenable to Set construction to eliminate duplicates.
'''
p1 = self.add_pdb(pdb_id_1)
p2 = self.add_pdb(pdb_id_2)
sifts_1, pdb_1 = p1['sifts'], p1['pdb']
sifts_2, pdb_2 = p2['sifts'], p2['pdb']
seqres_to_atom_sequence_maps_1 = sifts_1.seqres_to_atom_sequence_maps.get(chain_1, {})
seqres_1, atom_1 = pdb_1.seqres_sequences.get(chain_1), pdb_1.atom_sequences.get(chain_1)
seqres_2, atom_2 = pdb_2.seqres_sequences.get(chain_2), pdb_2.atom_sequences.get(chain_2)
if not seqres_1: raise Exception('No SEQRES sequence for chain {0} of {1}.'.format(chain_1, pdb_1))
if not atom_1: raise Exception('No ATOM sequence for chain {0} of {1}.'.format(chain_1, pdb_1))
if not seqres_2: raise Exception('No SEQRES sequence for chain {0} of {1}.'.format(chain_2, pdb_2))
if not atom_2: raise Exception('No ATOM sequence for chain {0} of {1}.'.format(chain_2, pdb_2))
seqres_str_1 = str(seqres_1)
seqres_str_2 = str(seqres_2)
sa = SequenceAligner()
sa.add_sequence('{0}_{1}'.format(pdb_id_1, chain_1), seqres_str_1)
sa.add_sequence('{0}_{1}'.format(pdb_id_2, chain_2), seqres_str_2)
sa.align()
seqres_residue_mapping, seqres_match_mapping = sa.get_residue_mapping()
seqres_sequence_map = SequenceMap()
assert(sorted(seqres_residue_mapping.keys()) == sorted(seqres_match_mapping.keys()))
for k, v in seqres_residue_mapping.iteritems():
seqres_sequence_map.add(k, v, seqres_match_mapping[k])
self.seqres_sequence_maps[(pdb_id_1, chain_1)][(pdb_id_2, chain_2)] = seqres_sequence_map
mutations = []
clustal_symbols = SubstitutionScore.clustal_symbols
for seqres_res_id, v in seqres_match_mapping.iteritems():
if clustal_symbols[v.clustal] != '*':
seqres_wt_residue = seqres_1[seqres_res_id]
seqres_mutant_residue = seqres_2[seqres_residue_mapping[seqres_res_id]]
atom_res_id = None
atom_chain_res_id = seqres_to_atom_sequence_maps_1.get(seqres_res_id)
try:
if atom_chain_res_id:
assert(atom_chain_res_id[0] == chain_1)
atom_residue = atom_1[atom_chain_res_id]
atom_res_id = atom_chain_res_id[1:]
assert(atom_residue.ResidueAA == seqres_wt_residue.ResidueAA)
assert(atom_residue.ResidueID == atom_res_id)
except:
atom_res_id = None
if seqres_wt_residue.ResidueAA != 'X':
raise
seqres_mutation = ChainMutation(seqres_wt_residue.ResidueAA, seqres_res_id,seqres_mutant_residue.ResidueAA, Chain = chain_1)
atom_mutation = None
if atom_res_id:
atom_mutation = ChainMutation(seqres_wt_residue.ResidueAA, atom_res_id, seqres_mutant_residue.ResidueAA, Chain = chain_1)
mutations.append(PDBMutationPair(seqres_mutation, atom_mutation))
return mutations |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:make; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:apps; 6, block; 6, 7; 6, 368; 7, for_statement; 7, 8; 7, 11; 7, 33; 8, tuple_pattern; 8, 9; 8, 10; 9, identifier:appname; 10, identifier:app; 11, call; 11, 12; 11, 13; 12, identifier:sorted; 13, argument_list; 13, 14; 13, 19; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:apps; 17, identifier:items; 18, argument_list; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:key; 21, lambda; 21, 22; 21, 24; 22, lambda_parameters; 22, 23; 23, identifier:x; 24, tuple; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, subscript; 26, 27; 26, 28; 27, identifier:x; 28, integer:1; 29, identifier:priority; 30, subscript; 30, 31; 30, 32; 31, identifier:x; 32, integer:0; 33, block; 33, 34; 33, 42; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:logger; 38, identifier:info; 39, argument_list; 39, 40; 39, 41; 40, string:'Getting report results from %r'; 41, identifier:appname; 42, for_statement; 42, 43; 42, 44; 42, 47; 43, identifier:report_data; 44, attribute; 44, 45; 44, 46; 45, identifier:app; 46, identifier:report_data; 47, block; 47, 48; 47, 58; 47, 354; 48, if_statement; 48, 49; 48, 56; 49, comparison_operator:!=; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:report_data; 52, identifier:subreport; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:name; 56, block; 56, 57; 57, continue_statement; 58, if_statement; 58, 59; 58, 64; 58, 188; 58, 271; 59, comparison_operator:==; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:report_data; 62, identifier:function; 63, string:'total'; 64, block; 64, 65; 65, for_statement; 65, 66; 65, 67; 65, 68; 66, identifier:opt; 67, identifier:report_data; 68, block; 68, 69; 68, 78; 68, 87; 68, 96; 68, 105; 68, 119; 68, 133; 68, 139; 68, 174; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:match; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:report_data; 75, identifier:parse_report_data; 76, argument_list; 76, 77; 77, identifier:opt; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:cond; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:match; 84, identifier:group; 85, argument_list; 85, 86; 86, string:'condition'; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:valfld; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:match; 93, identifier:group; 94, argument_list; 94, 95; 95, string:'valfld'; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:unit; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:match; 102, identifier:group; 103, argument_list; 103, 104; 104, string:'unit'; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:itemtitle; 108, call; 108, 109; 108, 117; 109, attribute; 109, 110; 109, 116; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:match; 113, identifier:group; 114, argument_list; 114, 115; 115, string:'fields'; 116, identifier:strip; 117, argument_list; 117, 118; 118, string:'"'; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:total; 122, call; 122, 123; 122, 130; 123, attribute; 123, 124; 123, 129; 124, subscript; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:report_data; 127, identifier:rules; 128, identifier:opt; 129, identifier:total_events; 130, argument_list; 130, 131; 130, 132; 131, identifier:cond; 132, identifier:valfld; 133, if_statement; 133, 134; 133, 137; 134, comparison_operator:==; 134, 135; 134, 136; 135, identifier:total; 136, integer:0; 137, block; 137, 138; 138, continue_statement; 139, if_statement; 139, 140; 139, 143; 139, 165; 140, comparison_operator:is; 140, 141; 140, 142; 141, identifier:unit; 142, None; 143, block; 143, 144; 143, 155; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 149; 146, pattern_list; 146, 147; 146, 148; 147, identifier:total; 148, identifier:unit; 149, call; 149, 150; 149, 151; 150, identifier:get_value_unit; 151, argument_list; 151, 152; 151, 153; 151, 154; 152, identifier:total; 153, identifier:unit; 154, string:'T'; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:total; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, string:'{0} {1}'; 161, identifier:format; 162, argument_list; 162, 163; 162, 164; 163, identifier:total; 164, identifier:unit; 165, else_clause; 165, 166; 166, block; 166, 167; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:total; 170, call; 170, 171; 170, 172; 171, identifier:str; 172, argument_list; 172, 173; 173, identifier:total; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 181; 176, attribute; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:report_data; 179, identifier:results; 180, identifier:append; 181, argument_list; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:tuple; 184, argument_list; 184, 185; 185, list:[total, itemtitle]; 185, 186; 185, 187; 186, identifier:total; 187, identifier:itemtitle; 188, elif_clause; 188, 189; 188, 194; 189, comparison_operator:==; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:report_data; 192, identifier:function; 193, string:'top'; 194, block; 194, 195; 194, 204; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:k; 198, call; 198, 199; 198, 200; 199, identifier:int; 200, argument_list; 200, 201; 201, attribute; 201, 202; 201, 203; 202, identifier:report_data; 203, identifier:topnum; 204, for_statement; 204, 205; 204, 206; 204, 207; 205, identifier:opt; 206, identifier:report_data; 207, block; 207, 208; 207, 217; 207, 226; 207, 235; 207, 246; 207, 262; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:match; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:report_data; 214, identifier:parse_report_data; 215, argument_list; 215, 216; 216, identifier:opt; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:valfld; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:match; 223, identifier:group; 224, argument_list; 224, 225; 225, string:'valfld'; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:field; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:match; 232, identifier:group; 233, argument_list; 233, 234; 234, string:'fields'; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:usemax; 238, comparison_operator:is; 238, 239; 238, 245; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:match; 242, identifier:group; 243, argument_list; 243, 244; 244, string:'add2res'; 245, None; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:toplist; 249, call; 249, 250; 249, 257; 250, attribute; 250, 251; 250, 256; 251, subscript; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:report_data; 254, identifier:rules; 255, identifier:opt; 256, identifier:top_events; 257, argument_list; 257, 258; 257, 259; 257, 260; 257, 261; 258, identifier:k; 259, identifier:valfld; 260, identifier:usemax; 261, identifier:field; 262, expression_statement; 262, 263; 263, call; 263, 264; 263, 269; 264, attribute; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:report_data; 267, identifier:results; 268, identifier:extend; 269, argument_list; 269, 270; 270, identifier:toplist; 271, elif_clause; 271, 272; 271, 277; 272, comparison_operator:==; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:report_data; 275, identifier:function; 276, string:'table'; 277, block; 277, 278; 277, 293; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:cols; 281, call; 281, 282; 281, 283; 282, identifier:len; 283, argument_list; 283, 284; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:re; 287, identifier:split; 288, argument_list; 288, 289; 288, 290; 289, string:'\s*,\s*'; 290, attribute; 290, 291; 290, 292; 291, identifier:report_data; 292, identifier:headers; 293, for_statement; 293, 294; 293, 295; 293, 296; 294, identifier:opt; 295, identifier:report_data; 296, block; 296, 297; 296, 306; 296, 315; 296, 330; 296, 345; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:match; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:report_data; 303, identifier:parse_report_data; 304, argument_list; 304, 305; 305, identifier:opt; 306, expression_statement; 306, 307; 307, assignment; 307, 308; 307, 309; 308, identifier:cond; 309, call; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:match; 312, identifier:group; 313, argument_list; 313, 314; 314, string:'condition'; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 318; 317, identifier:fields; 318, call; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:re; 321, identifier:split; 322, argument_list; 322, 323; 322, 324; 323, string:'\s*,\s*'; 324, call; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:match; 327, identifier:group; 328, argument_list; 328, 329; 329, string:'fields'; 330, expression_statement; 330, 331; 331, assignment; 331, 332; 331, 333; 332, identifier:tablelist; 333, call; 333, 334; 333, 341; 334, attribute; 334, 335; 334, 340; 335, subscript; 335, 336; 335, 339; 336, attribute; 336, 337; 336, 338; 337, identifier:report_data; 338, identifier:rules; 339, identifier:opt; 340, identifier:list_events; 341, argument_list; 341, 342; 341, 343; 341, 344; 342, identifier:cond; 343, identifier:cols; 344, identifier:fields; 345, expression_statement; 345, 346; 346, call; 346, 347; 346, 352; 347, attribute; 347, 348; 347, 351; 348, attribute; 348, 349; 348, 350; 349, identifier:report_data; 350, identifier:results; 351, identifier:extend; 352, argument_list; 352, 353; 353, identifier:tablelist; 354, if_statement; 354, 355; 354, 358; 355, attribute; 355, 356; 355, 357; 356, identifier:report_data; 357, identifier:results; 358, block; 358, 359; 359, expression_statement; 359, 360; 360, call; 360, 361; 360, 366; 361, attribute; 361, 362; 361, 365; 362, attribute; 362, 363; 362, 364; 363, identifier:self; 364, identifier:report_data; 365, identifier:append; 366, argument_list; 366, 367; 367, identifier:report_data; 368, for_statement; 368, 369; 368, 370; 368, 373; 369, identifier:report_data; 370, attribute; 370, 371; 370, 372; 371, identifier:self; 372, identifier:report_data; 373, block; 373, 374; 374, if_statement; 374, 375; 374, 380; 375, comparison_operator:==; 375, 376; 375, 379; 376, attribute; 376, 377; 376, 378; 377, identifier:report_data; 378, identifier:function; 379, string:'top'; 380, block; 380, 381; 380, 403; 380, 407; 380, 435; 381, expression_statement; 381, 382; 382, assignment; 382, 383; 382, 386; 383, attribute; 383, 384; 383, 385; 384, identifier:report_data; 385, identifier:results; 386, call; 386, 387; 386, 388; 387, identifier:sorted; 388, argument_list; 388, 389; 388, 392; 388, 400; 389, attribute; 389, 390; 389, 391; 390, identifier:report_data; 391, identifier:results; 392, keyword_argument; 392, 393; 392, 394; 393, identifier:key; 394, lambda; 394, 395; 394, 397; 395, lambda_parameters; 395, 396; 396, identifier:x; 397, subscript; 397, 398; 397, 399; 398, identifier:x; 399, integer:0; 400, keyword_argument; 400, 401; 400, 402; 401, identifier:reverse; 402, True; 403, expression_statement; 403, 404; 404, assignment; 404, 405; 404, 406; 405, identifier:unit; 406, None; 407, for_statement; 407, 408; 407, 409; 407, 410; 408, identifier:opt; 409, identifier:report_data; 410, block; 410, 411; 410, 420; 410, 429; 411, expression_statement; 411, 412; 412, assignment; 412, 413; 412, 414; 413, identifier:match; 414, call; 414, 415; 414, 418; 415, attribute; 415, 416; 415, 417; 416, identifier:report_data; 417, identifier:parse_report_data; 418, argument_list; 418, 419; 419, identifier:opt; 420, expression_statement; 420, 421; 421, assignment; 421, 422; 421, 423; 422, identifier:unit; 423, call; 423, 424; 423, 427; 424, attribute; 424, 425; 424, 426; 425, identifier:match; 426, identifier:group; 427, argument_list; 427, 428; 428, string:'unit'; 429, if_statement; 429, 430; 429, 433; 430, comparison_operator:is; 430, 431; 430, 432; 431, identifier:unit; 432, None; 433, block; 433, 434; 434, break_statement; 435, for_statement; 435, 436; 435, 437; 435, 440; 436, identifier:res; 437, attribute; 437, 438; 437, 439; 438, identifier:report_data; 439, identifier:results; 440, block; 440, 441; 441, if_statement; 441, 442; 441, 445; 441, 471; 442, comparison_operator:is; 442, 443; 442, 444; 443, identifier:unit; 444, None; 445, block; 445, 446; 445, 459; 446, expression_statement; 446, 447; 447, assignment; 447, 448; 447, 451; 448, pattern_list; 448, 449; 448, 450; 449, identifier:v; 450, identifier:u; 451, call; 451, 452; 451, 453; 452, identifier:get_value_unit; 453, argument_list; 453, 454; 453, 457; 453, 458; 454, subscript; 454, 455; 454, 456; 455, identifier:res; 456, integer:0; 457, identifier:unit; 458, string:'T'; 459, expression_statement; 459, 460; 460, assignment; 460, 461; 460, 464; 461, subscript; 461, 462; 461, 463; 462, identifier:res; 463, integer:0; 464, call; 464, 465; 464, 468; 465, attribute; 465, 466; 465, 467; 466, string:'{0} {1}'; 467, identifier:format; 468, argument_list; 468, 469; 468, 470; 469, identifier:v; 470, identifier:u; 471, else_clause; 471, 472; 472, block; 472, 473; 473, expression_statement; 473, 474; 474, assignment; 474, 475; 474, 478; 475, subscript; 475, 476; 475, 477; 476, identifier:res; 477, integer:0; 478, call; 478, 479; 478, 480; 479, identifier:str; 480, argument_list; 480, 481; 481, subscript; 481, 482; 481, 483; 482, identifier:res; 483, integer:0 | def make(self, apps):
for (appname, app) in sorted(apps.items(), key=lambda x: (x[1].priority, x[0])):
logger.info('Getting report results from %r', appname)
for report_data in app.report_data:
if report_data.subreport != self.name:
continue
if report_data.function == 'total':
for opt in report_data:
match = report_data.parse_report_data(opt)
cond = match.group('condition')
valfld = match.group('valfld')
unit = match.group('unit')
itemtitle = match.group('fields').strip('"')
total = report_data.rules[opt].total_events(cond, valfld)
if total == 0:
continue
if unit is not None:
total, unit = get_value_unit(total, unit, 'T')
total = '{0} {1}'.format(total, unit)
else:
total = str(total)
report_data.results.append(tuple([total, itemtitle]))
elif report_data.function == 'top':
k = int(report_data.topnum)
for opt in report_data:
match = report_data.parse_report_data(opt)
valfld = match.group('valfld')
field = match.group('fields')
usemax = match.group('add2res') is None
toplist = report_data.rules[opt].top_events(k, valfld, usemax, field)
report_data.results.extend(toplist)
elif report_data.function == 'table':
cols = len(re.split('\s*,\s*', report_data.headers))
for opt in report_data:
match = report_data.parse_report_data(opt)
cond = match.group('condition')
fields = re.split('\s*,\s*', match.group('fields'))
tablelist = report_data.rules[opt].list_events(cond, cols, fields)
report_data.results.extend(tablelist)
if report_data.results:
self.report_data.append(report_data)
for report_data in self.report_data:
if report_data.function == 'top':
report_data.results = sorted(report_data.results, key=lambda x: x[0], reverse=True)
unit = None
for opt in report_data:
match = report_data.parse_report_data(opt)
unit = match.group('unit')
if unit is not None:
break
for res in report_data.results:
if unit is not None:
v, u = get_value_unit(res[0], unit, 'T')
res[0] = '{0} {1}'.format(v, u)
else:
res[0] = str(res[0]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_report_parts; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:apps; 6, identifier:formats; 7, block; 7, 8; 7, 41; 7, 48; 7, 139; 7, 143; 7, 179; 7, 212; 7, 221; 7, 225; 7, 300; 8, for_statement; 8, 9; 8, 10; 8, 11; 9, identifier:fmt; 10, identifier:formats; 11, block; 11, 12; 11, 27; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:width; 15, conditional_expression:if; 15, 16; 15, 17; 15, 20; 16, integer:100; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:fmt; 19, None; 20, subscript; 20, 21; 20, 26; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:tui; 24, identifier:get_terminal_size; 25, argument_list; 26, integer:0; 27, for_statement; 27, 28; 27, 29; 27, 32; 28, identifier:sr; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:subreports; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:sr; 37, identifier:make_format; 38, argument_list; 38, 39; 38, 40; 39, identifier:fmt; 40, identifier:width; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:logger; 45, identifier:debug; 46, argument_list; 46, 47; 47, string:'Build a map for arguments and run\'s statistics ...'; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:value_mapping; 51, dictionary; 51, 52; 51, 57; 51, 78; 51, 92; 51, 106; 51, 136; 52, pair; 52, 53; 52, 54; 53, string:'title'; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:title; 57, pair; 57, 58; 57, 59; 58, string:'patterns'; 59, boolean_operator:or; 59, 60; 59, 77; 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, 70; 66, call; 66, 67; 66, 68; 67, identifier:repr; 68, argument_list; 68, 69; 69, identifier:pattern; 70, for_in_clause; 70, 71; 70, 72; 71, identifier:pattern; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:args; 76, identifier:patterns; 77, None; 78, pair; 78, 79; 78, 80; 79, string:'pattern_files'; 80, boolean_operator:or; 80, 81; 80, 91; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, string:', '; 84, identifier:join; 85, argument_list; 85, 86; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:args; 90, identifier:pattern_files; 91, None; 92, pair; 92, 93; 92, 94; 93, string:'hosts'; 94, boolean_operator:or; 94, 95; 94, 105; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, string:', '; 98, identifier:join; 99, argument_list; 99, 100; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:args; 104, identifier:hosts; 105, None; 106, pair; 106, 107; 106, 108; 107, string:'apps'; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, string:u', '; 111, identifier:join; 112, argument_list; 112, 113; 113, list_comprehension; 113, 114; 113, 123; 113, 130; 114, binary_operator:%; 114, 115; 114, 116; 115, string:u'%s(%d)'; 116, tuple; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:app; 119, identifier:name; 120, attribute; 120, 121; 120, 122; 121, identifier:app; 122, identifier:matches; 123, for_in_clause; 123, 124; 123, 125; 124, identifier:app; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:apps; 128, identifier:values; 129, argument_list; 130, if_clause; 130, 131; 131, comparison_operator:>; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:app; 134, identifier:matches; 135, integer:0; 136, pair; 136, 137; 136, 138; 137, string:'version'; 138, identifier:__version__; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:filters; 142, list:[]; 143, for_statement; 143, 144; 143, 145; 143, 150; 144, identifier:flt; 145, attribute; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:args; 149, identifier:filters; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:filters; 155, identifier:append; 156, argument_list; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, string:' AND '; 160, identifier:join; 161, argument_list; 161, 162; 162, list_comprehension; 162, 163; 162, 170; 163, binary_operator:%; 163, 164; 163, 165; 164, string:'%s=%r'; 165, tuple; 165, 166; 165, 167; 166, identifier:k; 167, attribute; 167, 168; 167, 169; 168, identifier:v; 169, identifier:pattern; 170, for_in_clause; 170, 171; 170, 174; 171, pattern_list; 171, 172; 171, 173; 172, identifier:k; 173, identifier:v; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:flt; 177, identifier:items; 178, argument_list; 179, if_statement; 179, 180; 179, 181; 179, 199; 180, identifier:filters; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 187; 184, subscript; 184, 185; 184, 186; 185, identifier:value_mapping; 186, string:'filters'; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, string:' OR '; 190, identifier:join; 191, argument_list; 191, 192; 192, list_comprehension; 192, 193; 192, 196; 193, binary_operator:%; 193, 194; 193, 195; 194, string:'(%s)'; 195, identifier:item; 196, for_in_clause; 196, 197; 196, 198; 197, identifier:item; 198, identifier:filters; 199, else_clause; 199, 200; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 206; 203, subscript; 203, 204; 203, 205; 204, identifier:value_mapping; 205, string:'filters'; 206, conditional_expression:if; 206, 207; 206, 210; 206, 211; 207, subscript; 207, 208; 207, 209; 208, identifier:filters; 209, integer:0; 210, identifier:filters; 211, None; 212, expression_statement; 212, 213; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:value_mapping; 216, identifier:update; 217, argument_list; 217, 218; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:stats; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:report; 224, list:[]; 225, for_statement; 225, 226; 225, 227; 225, 228; 226, identifier:fmt; 227, identifier:formats; 228, block; 228, 229; 229, if_statement; 229, 230; 229, 233; 229, 253; 229, 277; 230, comparison_operator:==; 230, 231; 230, 232; 231, identifier:fmt; 232, string:'text'; 233, block; 233, 234; 233, 241; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:logger; 238, identifier:info; 239, argument_list; 239, 240; 240, string:'appends a text page report'; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:report; 245, identifier:append; 246, argument_list; 246, 247; 247, call; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:self; 250, identifier:make_text_page; 251, argument_list; 251, 252; 252, identifier:value_mapping; 253, elif_clause; 253, 254; 253, 257; 254, comparison_operator:==; 254, 255; 254, 256; 255, identifier:fmt; 256, string:'html'; 257, block; 257, 258; 257, 265; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:logger; 262, identifier:info; 263, argument_list; 263, 264; 264, string:'appends a html page report'; 265, expression_statement; 265, 266; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:report; 269, identifier:append; 270, argument_list; 270, 271; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:self; 274, identifier:make_html_page; 275, argument_list; 275, 276; 276, identifier:value_mapping; 277, elif_clause; 277, 278; 277, 281; 278, comparison_operator:==; 278, 279; 278, 280; 279, identifier:fmt; 280, string:'csv'; 281, block; 281, 282; 281, 289; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:logger; 286, identifier:info; 287, argument_list; 287, 288; 288, string:'extends with a list of csv subreports'; 289, expression_statement; 289, 290; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:report; 293, identifier:extend; 294, argument_list; 294, 295; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:self; 298, identifier:make_csv_tables; 299, argument_list; 300, return_statement; 300, 301; 301, identifier:report | def get_report_parts(self, apps, formats):
for fmt in formats:
width = 100 if fmt is not None else tui.get_terminal_size()[0]
for sr in self.subreports:
sr.make_format(fmt, width)
logger.debug('Build a map for arguments and run\'s statistics ...')
value_mapping = {
'title': self.title,
'patterns': ', '.join([repr(pattern) for pattern in self.args.patterns]) or None,
'pattern_files': ', '.join(self.args.pattern_files) or None,
'hosts': ', '.join(self.args.hosts) or None,
'apps': u', '.join([
u'%s(%d)' % (app.name, app.matches) for app in apps.values() if app.matches > 0
]),
'version': __version__
}
filters = []
for flt in self.args.filters:
filters.append(' AND '.join(['%s=%r' % (k, v.pattern) for k, v in flt.items()]))
if filters:
value_mapping['filters'] = ' OR '.join(['(%s)' % item for item in filters])
else:
value_mapping['filters'] = filters[0] if filters else None
value_mapping.update(self.stats)
report = []
for fmt in formats:
if fmt == 'text':
logger.info('appends a text page report')
report.append(self.make_text_page(value_mapping))
elif fmt == 'html':
logger.info('appends a html page report')
report.append(self.make_html_page(value_mapping))
elif fmt == 'csv':
logger.info('extends with a list of csv subreports')
report.extend(self.make_csv_tables())
return report |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_convert; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:chain_id; 6, identifier:residue_id; 7, identifier:from_scheme; 8, identifier:to_scheme; 9, block; 9, 10; 9, 12; 9, 50; 9, 105; 9, 160; 9, 198; 10, expression_statement; 10, 11; 11, string:'''The actual 'private' conversion function.'''; 12, if_statement; 12, 13; 12, 16; 13, comparison_operator:==; 13, 14; 13, 15; 14, identifier:from_scheme; 15, string:'rosetta'; 16, block; 16, 17; 16, 31; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:atom_id; 20, subscript; 20, 21; 20, 30; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:rosetta_to_atom_sequence_maps; 26, identifier:get; 27, argument_list; 27, 28; 27, 29; 28, identifier:chain_id; 29, dictionary; 30, identifier:residue_id; 31, if_statement; 31, 32; 31, 35; 31, 38; 32, comparison_operator:==; 32, 33; 32, 34; 33, identifier:to_scheme; 34, string:'atom'; 35, block; 35, 36; 36, return_statement; 36, 37; 37, identifier:atom_id; 38, else_clause; 38, 39; 39, block; 39, 40; 40, return_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:_convert; 45, argument_list; 45, 46; 45, 47; 45, 48; 45, 49; 46, identifier:chain_id; 47, identifier:atom_id; 48, string:'atom'; 49, identifier:to_scheme; 50, if_statement; 50, 51; 50, 54; 51, comparison_operator:==; 51, 52; 51, 53; 52, identifier:from_scheme; 53, string:'atom'; 54, block; 54, 55; 55, if_statement; 55, 56; 55, 59; 55, 72; 56, comparison_operator:==; 56, 57; 56, 58; 57, identifier:to_scheme; 58, string:'rosetta'; 59, block; 59, 60; 60, return_statement; 60, 61; 61, subscript; 61, 62; 61, 71; 62, call; 62, 63; 62, 68; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:atom_to_rosetta_sequence_maps; 67, identifier:get; 68, argument_list; 68, 69; 68, 70; 69, identifier:chain_id; 70, dictionary; 71, identifier:residue_id; 72, else_clause; 72, 73; 73, block; 73, 74; 73, 88; 73, 95; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:seqres_id; 77, subscript; 77, 78; 77, 87; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:atom_to_seqres_sequence_maps; 83, identifier:get; 84, argument_list; 84, 85; 84, 86; 85, identifier:chain_id; 86, dictionary; 87, identifier:residue_id; 88, if_statement; 88, 89; 88, 92; 89, comparison_operator:==; 89, 90; 89, 91; 90, identifier:to_scheme; 91, string:'seqres'; 92, block; 92, 93; 93, return_statement; 93, 94; 94, identifier:seqres_id; 95, return_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:convert; 100, argument_list; 100, 101; 100, 102; 100, 103; 100, 104; 101, identifier:chain_id; 102, identifier:seqres_id; 103, string:'seqres'; 104, identifier:to_scheme; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:==; 106, 107; 106, 108; 107, identifier:from_scheme; 108, string:'seqres'; 109, block; 109, 110; 110, if_statement; 110, 111; 110, 114; 110, 127; 111, comparison_operator:==; 111, 112; 111, 113; 112, identifier:to_scheme; 113, string:'uniparc'; 114, block; 114, 115; 115, return_statement; 115, 116; 116, subscript; 116, 117; 116, 126; 117, call; 117, 118; 117, 123; 118, attribute; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:seqres_to_uniparc_sequence_maps; 122, identifier:get; 123, argument_list; 123, 124; 123, 125; 124, identifier:chain_id; 125, dictionary; 126, identifier:residue_id; 127, else_clause; 127, 128; 128, block; 128, 129; 128, 143; 128, 150; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:atom_id; 132, subscript; 132, 133; 132, 142; 133, call; 133, 134; 133, 139; 134, attribute; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:seqres_to_atom_sequence_maps; 138, identifier:get; 139, argument_list; 139, 140; 139, 141; 140, identifier:chain_id; 141, dictionary; 142, identifier:residue_id; 143, if_statement; 143, 144; 143, 147; 144, comparison_operator:==; 144, 145; 144, 146; 145, identifier:to_scheme; 146, string:'atom'; 147, block; 147, 148; 148, return_statement; 148, 149; 149, identifier:atom_id; 150, return_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:convert; 155, argument_list; 155, 156; 155, 157; 155, 158; 155, 159; 156, identifier:chain_id; 157, identifier:atom_id; 158, string:'atom'; 159, identifier:to_scheme; 160, if_statement; 160, 161; 160, 164; 161, comparison_operator:==; 161, 162; 161, 163; 162, identifier:from_scheme; 163, string:'uniparc'; 164, block; 164, 165; 164, 179; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:seqres_id; 168, subscript; 168, 169; 168, 178; 169, call; 169, 170; 169, 175; 170, attribute; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:uniparc_to_seqres_sequence_maps; 174, identifier:get; 175, argument_list; 175, 176; 175, 177; 176, identifier:chain_id; 177, dictionary; 178, identifier:residue_id; 179, if_statement; 179, 180; 179, 183; 179, 186; 180, comparison_operator:==; 180, 181; 180, 182; 181, identifier:to_scheme; 182, string:'seqres'; 183, block; 183, 184; 184, return_statement; 184, 185; 185, identifier:seqres_id; 186, else_clause; 186, 187; 187, block; 187, 188; 188, return_statement; 188, 189; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:self; 192, identifier:_convert; 193, argument_list; 193, 194; 193, 195; 193, 196; 193, 197; 194, identifier:chain_id; 195, identifier:seqres_id; 196, string:'seqres'; 197, identifier:to_scheme; 198, raise_statement; 198, 199; 199, call; 199, 200; 199, 201; 200, identifier:Exception; 201, argument_list; 201, 202; 202, string:"We should never reach this line." | def _convert(self, chain_id, residue_id, from_scheme, to_scheme):
'''The actual 'private' conversion function.'''
if from_scheme == 'rosetta':
atom_id = self.rosetta_to_atom_sequence_maps.get(chain_id, {})[residue_id]
if to_scheme == 'atom':
return atom_id
else:
return self._convert(chain_id, atom_id, 'atom', to_scheme)
if from_scheme == 'atom':
if to_scheme == 'rosetta':
return self.atom_to_rosetta_sequence_maps.get(chain_id, {})[residue_id]
else:
seqres_id = self.atom_to_seqres_sequence_maps.get(chain_id, {})[residue_id]
if to_scheme == 'seqres':
return seqres_id
return self.convert(chain_id, seqres_id, 'seqres', to_scheme)
if from_scheme == 'seqres':
if to_scheme == 'uniparc':
return self.seqres_to_uniparc_sequence_maps.get(chain_id, {})[residue_id]
else:
atom_id = self.seqres_to_atom_sequence_maps.get(chain_id, {})[residue_id]
if to_scheme == 'atom':
return atom_id
return self.convert(chain_id, atom_id, 'atom', to_scheme)
if from_scheme == 'uniparc':
seqres_id = self.uniparc_to_seqres_sequence_maps.get(chain_id, {})[residue_id]
if to_scheme == 'seqres':
return seqres_id
else:
return self._convert(chain_id, seqres_id, 'seqres', to_scheme)
raise Exception("We should never reach this line.") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_create_sequences; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 40; 5, 71; 5, 86; 5, 96; 5, 106; 5, 149; 5, 153; 5, 259; 5, 336; 6, expression_statement; 6, 7; 7, string:'''Get all of the Sequences - Rosetta, ATOM, SEQRES, FASTA, UniParc.'''; 8, try_statement; 8, 9; 8, 31; 9, block; 9, 10; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 17; 12, attribute; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:pdb; 16, identifier:construct_pdb_to_rosetta_residue_map; 17, argument_list; 17, 18; 17, 21; 17, 26; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:rosetta_scripts_path; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:rosetta_database_path; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:rosetta_database_path; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:cache_dir; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:cache_dir; 31, except_clause; 31, 32; 31, 33; 32, identifier:PDBMissingMainchainAtomsException; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:pdb_to_rosetta_residue_map_error; 39, True; 40, if_statement; 40, 41; 40, 46; 40, 57; 41, comparison_operator:not; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:pdb_id; 45, identifier:do_not_use_the_sequence_aligner; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:uniparc_sequences; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:PDB_UniParc_SA; 56, identifier:uniparc_sequences; 57, else_clause; 57, 58; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:uniparc_sequences; 64, call; 64, 65; 64, 70; 65, attribute; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:sifts; 69, identifier:get_uniparc_sequences; 70, argument_list; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:fasta_sequences; 76, call; 76, 77; 76, 82; 77, attribute; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:FASTA; 81, identifier:get_sequences; 82, argument_list; 82, 83; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:pdb_id; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:seqres_sequences; 91, attribute; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:pdb; 95, identifier:seqres_sequences; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:atom_sequences; 101, attribute; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:pdb; 105, identifier:atom_sequences; 106, if_statement; 106, 107; 106, 110; 106, 137; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:pdb_to_rosetta_residue_map_error; 110, block; 110, 111; 110, 117; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:rosetta_sequences; 116, dictionary; 117, for_statement; 117, 118; 117, 119; 117, 126; 118, identifier:c; 119, call; 119, 120; 119, 125; 120, attribute; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:atom_sequences; 124, identifier:keys; 125, argument_list; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 134; 129, subscript; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:rosetta_sequences; 133, identifier:c; 134, call; 134, 135; 134, 136; 135, identifier:Sequence; 136, argument_list; 137, else_clause; 137, 138; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:rosetta_sequences; 144, attribute; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:pdb; 148, identifier:rosetta_sequences; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:uniparc_pdb_chain_mapping; 152, dictionary; 153, if_statement; 153, 154; 153, 159; 153, 216; 154, comparison_operator:not; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:pdb_id; 158, identifier:do_not_use_the_sequence_aligner; 159, block; 159, 160; 160, for_statement; 160, 161; 160, 164; 160, 173; 161, pattern_list; 161, 162; 161, 163; 162, identifier:pdb_chain_id; 163, identifier:matches; 164, call; 164, 165; 164, 172; 165, attribute; 165, 166; 165, 171; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:self; 169, identifier:PDB_UniParc_SA; 170, identifier:clustal_matches; 171, identifier:iteritems; 172, argument_list; 173, block; 173, 174; 174, if_statement; 174, 175; 174, 176; 175, identifier:matches; 176, block; 176, 177; 176, 187; 176, 195; 176, 207; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:uniparc_chain_id; 180, subscript; 180, 181; 180, 186; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:matches; 184, identifier:keys; 185, argument_list; 186, integer:0; 187, assert_statement; 187, 188; 188, parenthesized_expression; 188, 189; 189, comparison_operator:==; 189, 190; 189, 194; 190, call; 190, 191; 190, 192; 191, identifier:len; 192, argument_list; 192, 193; 193, identifier:matches; 194, integer:1; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 200; 197, subscript; 197, 198; 197, 199; 198, identifier:uniparc_pdb_chain_mapping; 199, identifier:uniparc_chain_id; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:uniparc_pdb_chain_mapping; 203, identifier:get; 204, argument_list; 204, 205; 204, 206; 205, identifier:uniparc_chain_id; 206, list:[]; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 214; 209, attribute; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:uniparc_pdb_chain_mapping; 212, identifier:uniparc_chain_id; 213, identifier:append; 214, argument_list; 214, 215; 215, identifier:pdb_chain_id; 216, else_clause; 216, 217; 217, block; 217, 218; 218, for_statement; 218, 219; 218, 222; 218, 233; 219, pattern_list; 219, 220; 219, 221; 220, identifier:pdb_chain_id; 221, identifier:uniparc_chain_ids; 222, call; 222, 223; 222, 232; 223, attribute; 223, 224; 223, 231; 224, call; 224, 225; 224, 230; 225, attribute; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:self; 228, identifier:sifts; 229, identifier:get_pdb_chain_to_uniparc_id_map; 230, argument_list; 231, identifier:iteritems; 232, argument_list; 233, block; 233, 234; 234, for_statement; 234, 235; 234, 236; 234, 237; 235, identifier:uniparc_chain_id; 236, identifier:uniparc_chain_ids; 237, block; 237, 238; 237, 250; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 243; 240, subscript; 240, 241; 240, 242; 241, identifier:uniparc_pdb_chain_mapping; 242, identifier:uniparc_chain_id; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:uniparc_pdb_chain_mapping; 246, identifier:get; 247, argument_list; 247, 248; 247, 249; 248, identifier:uniparc_chain_id; 249, list:[]; 250, expression_statement; 250, 251; 251, call; 251, 252; 251, 257; 252, attribute; 252, 253; 252, 256; 253, subscript; 253, 254; 253, 255; 254, identifier:uniparc_pdb_chain_mapping; 255, identifier:uniparc_chain_id; 256, identifier:append; 257, argument_list; 257, 258; 258, identifier:pdb_chain_id; 259, for_statement; 259, 260; 259, 263; 259, 268; 260, pattern_list; 260, 261; 260, 262; 261, identifier:uniparc_chain_id; 262, identifier:pdb_chain_ids; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:uniparc_pdb_chain_mapping; 266, identifier:iteritems; 267, argument_list; 268, block; 268, 269; 268, 286; 268, 294; 268, 302; 268, 313; 268, 324; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:sequence_type; 272, call; 272, 273; 272, 274; 273, identifier:set; 274, argument_list; 274, 275; 275, list_comprehension; 275, 276; 275, 283; 276, attribute; 276, 277; 276, 282; 277, subscript; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:self; 280, identifier:seqres_sequences; 281, identifier:p; 282, identifier:sequence_type; 283, for_in_clause; 283, 284; 283, 285; 284, identifier:p; 285, identifier:pdb_chain_ids; 286, assert_statement; 286, 287; 287, parenthesized_expression; 287, 288; 288, comparison_operator:==; 288, 289; 288, 293; 289, call; 289, 290; 289, 291; 290, identifier:len; 291, argument_list; 291, 292; 292, identifier:sequence_type; 293, integer:1; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:sequence_type; 297, call; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:sequence_type; 300, identifier:pop; 301, argument_list; 302, assert_statement; 302, 303; 303, parenthesized_expression; 303, 304; 304, comparison_operator:==; 304, 305; 304, 312; 305, attribute; 305, 306; 305, 311; 306, subscript; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:self; 309, identifier:uniparc_sequences; 310, identifier:uniparc_chain_id; 311, identifier:sequence_type; 312, None; 313, expression_statement; 313, 314; 314, call; 314, 315; 314, 322; 315, attribute; 315, 316; 315, 321; 316, subscript; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:self; 319, identifier:uniparc_sequences; 320, identifier:uniparc_chain_id; 321, identifier:set_type; 322, argument_list; 322, 323; 323, identifier:sequence_type; 324, for_statement; 324, 325; 324, 326; 324, 327; 325, identifier:p; 326, identifier:pdb_chain_ids; 327, block; 327, 328; 328, expression_statement; 328, 329; 329, assignment; 329, 330; 329, 335; 330, subscript; 330, 331; 330, 334; 331, attribute; 331, 332; 331, 333; 332, identifier:self; 333, identifier:pdb_chain_to_uniparc_chain_mapping; 334, identifier:p; 335, identifier:uniparc_chain_id; 336, for_statement; 336, 337; 336, 340; 336, 347; 337, pattern_list; 337, 338; 337, 339; 338, identifier:chain_id; 339, identifier:sequence; 340, call; 340, 341; 340, 346; 341, attribute; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, identifier:self; 344, identifier:seqres_sequences; 345, identifier:iteritems; 346, argument_list; 347, block; 347, 348; 348, expression_statement; 348, 349; 349, call; 349, 350; 349, 357; 350, attribute; 350, 351; 350, 356; 351, subscript; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:self; 354, identifier:fasta_sequences; 355, identifier:chain_id; 356, identifier:set_type; 357, argument_list; 357, 358; 358, attribute; 358, 359; 358, 360; 359, identifier:sequence; 360, identifier:sequence_type | def _create_sequences(self):
'''Get all of the Sequences - Rosetta, ATOM, SEQRES, FASTA, UniParc.'''
try:
self.pdb.construct_pdb_to_rosetta_residue_map(self.rosetta_scripts_path, rosetta_database_path = self.rosetta_database_path, cache_dir = self.cache_dir)
except PDBMissingMainchainAtomsException:
self.pdb_to_rosetta_residue_map_error = True
if self.pdb_id not in do_not_use_the_sequence_aligner:
self.uniparc_sequences = self.PDB_UniParc_SA.uniparc_sequences
else:
self.uniparc_sequences = self.sifts.get_uniparc_sequences()
self.fasta_sequences = self.FASTA.get_sequences(self.pdb_id)
self.seqres_sequences = self.pdb.seqres_sequences
self.atom_sequences = self.pdb.atom_sequences
if self.pdb_to_rosetta_residue_map_error:
self.rosetta_sequences = {}
for c in self.atom_sequences.keys():
self.rosetta_sequences[c] = Sequence()
else:
self.rosetta_sequences = self.pdb.rosetta_sequences
uniparc_pdb_chain_mapping = {}
if self.pdb_id not in do_not_use_the_sequence_aligner:
for pdb_chain_id, matches in self.PDB_UniParc_SA.clustal_matches.iteritems():
if matches:
uniparc_chain_id = matches.keys()[0]
assert(len(matches) == 1)
uniparc_pdb_chain_mapping[uniparc_chain_id] = uniparc_pdb_chain_mapping.get(uniparc_chain_id, [])
uniparc_pdb_chain_mapping[uniparc_chain_id].append(pdb_chain_id)
else:
for pdb_chain_id, uniparc_chain_ids in self.sifts.get_pdb_chain_to_uniparc_id_map().iteritems():
for uniparc_chain_id in uniparc_chain_ids:
uniparc_pdb_chain_mapping[uniparc_chain_id] = uniparc_pdb_chain_mapping.get(uniparc_chain_id, [])
uniparc_pdb_chain_mapping[uniparc_chain_id].append(pdb_chain_id)
for uniparc_chain_id, pdb_chain_ids in uniparc_pdb_chain_mapping.iteritems():
sequence_type = set([self.seqres_sequences[p].sequence_type for p in pdb_chain_ids])
assert(len(sequence_type) == 1)
sequence_type = sequence_type.pop()
assert(self.uniparc_sequences[uniparc_chain_id].sequence_type == None)
self.uniparc_sequences[uniparc_chain_id].set_type(sequence_type)
for p in pdb_chain_ids:
self.pdb_chain_to_uniparc_chain_mapping[p] = uniparc_chain_id
for chain_id, sequence in self.seqres_sequences.iteritems():
self.fasta_sequences[chain_id].set_type(sequence.sequence_type) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:search_update_index; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 17; 5, 35; 5, 43; 5, 104; 5, 262; 5, 274; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:doc_id; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:search_get_document_id; 13, argument_list; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:key; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:fields; 20, list_comprehension; 20, 21; 20, 28; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:search; 24, identifier:AtomField; 25, argument_list; 25, 26; 25, 27; 26, string:'class_name'; 27, identifier:name; 28, for_in_clause; 28, 29; 28, 30; 29, identifier:name; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:search_get_class_names; 34, argument_list; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:index; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:search_get_index; 42, argument_list; 43, if_statement; 43, 44; 43, 49; 43, 96; 44, comparison_operator:is; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:searchable_fields; 48, None; 49, block; 49, 50; 49, 54; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:searchable_fields; 53, list:[]; 54, for_statement; 54, 55; 54, 58; 54, 65; 55, pattern_list; 55, 56; 55, 57; 56, identifier:field; 57, identifier:prop; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_properties; 63, identifier:items; 64, argument_list; 65, block; 65, 66; 65, 72; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:==; 67, 68; 67, 69; 68, identifier:field; 69, string:'class'; 70, block; 70, 71; 71, continue_statement; 72, for_statement; 72, 73; 72, 76; 72, 81; 73, pattern_list; 73, 74; 73, 75; 74, identifier:class_; 75, identifier:field_type; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:SEARCHABLE_PROPERTY_TYPES; 79, identifier:items; 80, argument_list; 81, block; 81, 82; 82, if_statement; 82, 83; 82, 88; 83, call; 83, 84; 83, 85; 84, identifier:isinstance; 85, argument_list; 85, 86; 85, 87; 86, identifier:prop; 87, identifier:class_; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:searchable_fields; 93, identifier:append; 94, argument_list; 94, 95; 95, identifier:field; 96, else_clause; 96, 97; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:searchable_fields; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:searchable_fields; 104, for_statement; 104, 105; 104, 106; 104, 110; 105, identifier:f; 106, call; 106, 107; 106, 108; 107, identifier:set; 108, argument_list; 108, 109; 109, identifier:searchable_fields; 110, block; 110, 111; 110, 119; 110, 127; 110, 131; 110, 135; 110, 235; 110, 250; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:prop; 114, subscript; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:_properties; 118, identifier:f; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:value; 122, call; 122, 123; 122, 124; 123, identifier:getattr; 124, argument_list; 124, 125; 124, 126; 125, identifier:self; 126, identifier:f; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:field; 130, None; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:field_found; 134, False; 135, for_statement; 135, 136; 135, 139; 135, 144; 136, pattern_list; 136, 137; 136, 138; 137, identifier:class_; 138, identifier:field_type; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:SEARCHABLE_PROPERTY_TYPES; 142, identifier:items; 143, argument_list; 144, block; 144, 145; 145, if_statement; 145, 146; 145, 151; 146, call; 146, 147; 146, 148; 147, identifier:isinstance; 148, argument_list; 148, 149; 148, 150; 149, identifier:prop; 150, identifier:class_; 151, block; 151, 152; 151, 156; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:field_found; 155, True; 156, if_statement; 156, 157; 156, 160; 157, comparison_operator:is; 157, 158; 157, 159; 158, identifier:value; 159, None; 160, block; 160, 161; 161, if_statement; 161, 162; 161, 179; 161, 196; 161, 221; 162, boolean_operator:or; 162, 163; 162, 174; 163, boolean_operator:or; 163, 164; 163, 169; 164, call; 164, 165; 164, 166; 165, identifier:isinstance; 166, argument_list; 166, 167; 166, 168; 167, identifier:value; 168, identifier:list; 169, call; 169, 170; 169, 171; 170, identifier:isinstance; 171, argument_list; 171, 172; 171, 173; 172, identifier:value; 173, identifier:tuple; 174, call; 174, 175; 174, 176; 175, identifier:isinstance; 176, argument_list; 176, 177; 176, 178; 177, identifier:value; 178, identifier:set; 179, block; 179, 180; 180, for_statement; 180, 181; 180, 182; 180, 183; 181, identifier:v; 182, identifier:value; 183, block; 183, 184; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:field; 187, call; 187, 188; 187, 189; 188, identifier:field_type; 189, argument_list; 189, 190; 189, 193; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:name; 192, identifier:f; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:value; 195, identifier:v; 196, elif_clause; 196, 197; 196, 204; 197, call; 197, 198; 197, 199; 198, identifier:isinstance; 199, argument_list; 199, 200; 199, 201; 200, identifier:value; 201, attribute; 201, 202; 201, 203; 202, identifier:ndb; 203, identifier:Key; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:field; 208, call; 208, 209; 208, 210; 209, identifier:field_type; 210, argument_list; 210, 211; 210, 214; 211, keyword_argument; 211, 212; 211, 213; 212, identifier:name; 213, identifier:f; 214, keyword_argument; 214, 215; 214, 216; 215, identifier:value; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:value; 219, identifier:urlsafe; 220, argument_list; 221, else_clause; 221, 222; 222, block; 222, 223; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:field; 226, call; 226, 227; 226, 228; 227, identifier:field_type; 228, argument_list; 228, 229; 228, 232; 229, keyword_argument; 229, 230; 229, 231; 230, identifier:name; 231, identifier:f; 232, keyword_argument; 232, 233; 232, 234; 233, identifier:value; 234, identifier:value; 235, if_statement; 235, 236; 235, 238; 236, not_operator; 236, 237; 237, identifier:field_found; 238, block; 238, 239; 239, raise_statement; 239, 240; 240, call; 240, 241; 240, 242; 241, identifier:ValueError; 242, argument_list; 242, 243; 243, binary_operator:%; 243, 244; 243, 245; 244, string:'Cannot find field type for %r on %r'; 245, tuple; 245, 246; 245, 247; 246, identifier:prop; 247, attribute; 247, 248; 247, 249; 248, identifier:self; 249, identifier:__class__; 250, if_statement; 250, 251; 250, 254; 251, comparison_operator:is; 251, 252; 251, 253; 252, identifier:field; 253, None; 254, block; 254, 255; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:fields; 259, identifier:append; 260, argument_list; 260, 261; 261, identifier:field; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:document; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:search; 268, identifier:Document; 269, argument_list; 269, 270; 269, 271; 270, identifier:doc_id; 271, keyword_argument; 271, 272; 271, 273; 272, identifier:fields; 273, identifier:fields; 274, expression_statement; 274, 275; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:index; 278, identifier:put; 279, argument_list; 279, 280; 280, identifier:document | def search_update_index(self):
doc_id = self.search_get_document_id(self.key)
fields = [search.AtomField('class_name', name) for name in self.search_get_class_names()]
index = self.search_get_index()
if self.searchable_fields is None:
searchable_fields = []
for field, prop in self._properties.items():
if field == 'class':
continue
for class_, field_type in SEARCHABLE_PROPERTY_TYPES.items():
if isinstance(prop, class_):
searchable_fields.append(field)
else:
searchable_fields = self.searchable_fields
for f in set(searchable_fields):
prop = self._properties[f]
value = getattr(self, f)
field = None
field_found = False
for class_, field_type in SEARCHABLE_PROPERTY_TYPES.items():
if isinstance(prop, class_):
field_found = True
if value is not None:
if isinstance(value, list) or isinstance(value, tuple) or isinstance(value, set):
for v in value:
field = field_type(name=f, value=v)
elif isinstance(value, ndb.Key):
field = field_type(name=f, value=value.urlsafe())
else:
field = field_type(name=f, value=value)
if not field_found:
raise ValueError('Cannot find field type for %r on %r' % (prop, self.__class__))
if field is not None:
fields.append(field)
document = search.Document(doc_id, fields=fields)
index.put(document) |
0, module; 0, 1; 0, 64; 0, 73; 0, 86; 0, 103; 0, 126; 0, 136; 0, 194; 0, 225; 0, 242; 0, 255; 1, function_definition; 1, 2; 1, 3; 1, 20; 1, 33; 2, function_name:index_siblings; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:pid; 5, default_parameter; 5, 6; 5, 7; 6, identifier:include_pid; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:children; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:neighbors_eager; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:eager; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:with_deposits; 19, True; 20, ERROR; 20, 21; 21, assert_statement; 21, 22; 21, 27; 21, 28; 21, 30; 22, not_operator; 22, 23; 23, parenthesized_expression; 23, 24; 24, boolean_operator:and; 24, 25; 24, 26; 25, identifier:neighbors_eager; 26, identifier:eager; 27, line_continuation:\; 28, ERROR; 28, 29; 29, identifier:if; 30, comparison_operator:is; 30, 31; 30, 32; 31, identifier:children; 32, None; 33, block; 33, 34; 33, 49; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:parent_pid; 37, call; 37, 38; 37, 48; 38, attribute; 38, 39; 38, 47; 39, attribute; 39, 40; 39, 46; 40, call; 40, 41; 40, 42; 41, identifier:PIDNodeVersioning; 42, argument_list; 42, 43; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:pid; 45, identifier:pid; 46, identifier:parents; 47, identifier:first; 48, argument_list; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:children; 52, call; 52, 53; 52, 63; 53, attribute; 53, 54; 53, 62; 54, attribute; 54, 55; 54, 61; 55, call; 55, 56; 55, 57; 56, identifier:PIDNodeVersioning; 57, argument_list; 57, 58; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:pid; 60, identifier:parent_pid; 61, identifier:children; 62, identifier:all; 63, argument_list; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:objid; 67, call; 67, 68; 67, 69; 68, identifier:str; 69, argument_list; 69, 70; 70, attribute; 70, 71; 70, 72; 71, identifier:pid; 72, identifier:object_uuid; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:children; 76, list_comprehension; 76, 77; 76, 83; 77, call; 77, 78; 77, 79; 78, identifier:str; 79, argument_list; 79, 80; 80, attribute; 80, 81; 80, 82; 81, identifier:p; 82, identifier:object_uuid; 83, for_in_clause; 83, 84; 83, 85; 84, identifier:p; 85, identifier:children; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:idx; 89, conditional_expression:if; 89, 90; 89, 96; 89, 99; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:children; 93, identifier:index; 94, argument_list; 94, 95; 95, identifier:objid; 96, comparison_operator:in; 96, 97; 96, 98; 97, identifier:objid; 98, identifier:children; 99, call; 99, 100; 99, 101; 100, identifier:len; 101, argument_list; 101, 102; 102, identifier:children; 103, if_statement; 103, 104; 103, 105; 103, 116; 104, identifier:include_pid; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:left; 109, subscript; 109, 110; 109, 111; 110, identifier:children; 111, slice; 111, 112; 111, 113; 112, colon; 113, binary_operator:+; 113, 114; 113, 115; 114, identifier:idx; 115, integer:1; 116, else_clause; 116, 117; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:left; 121, subscript; 121, 122; 121, 123; 122, identifier:children; 123, slice; 123, 124; 123, 125; 124, colon; 125, identifier:idx; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:right; 129, subscript; 129, 130; 129, 131; 130, identifier:children; 131, slice; 131, 132; 131, 135; 132, binary_operator:+; 132, 133; 132, 134; 133, identifier:idx; 134, integer:1; 135, colon; 136, if_statement; 136, 137; 136, 138; 136, 149; 136, 182; 137, identifier:eager; 138, block; 138, 139; 138, 145; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:eager_uuids; 142, binary_operator:+; 142, 143; 142, 144; 143, identifier:left; 144, identifier:right; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:bulk_uuids; 148, list:[]; 149, elif_clause; 149, 150; 149, 151; 150, identifier:neighbors_eager; 151, block; 151, 152; 151, 167; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:eager_uuids; 155, binary_operator:+; 155, 156; 155, 162; 156, subscript; 156, 157; 156, 158; 157, identifier:left; 158, slice; 158, 159; 158, 161; 159, unary_operator:-; 159, 160; 160, integer:1; 161, colon; 162, subscript; 162, 163; 162, 164; 163, identifier:right; 164, slice; 164, 165; 164, 166; 165, colon; 166, integer:1; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:bulk_uuids; 170, binary_operator:+; 170, 171; 170, 177; 171, subscript; 171, 172; 171, 173; 172, identifier:left; 173, slice; 173, 174; 173, 175; 174, colon; 175, unary_operator:-; 175, 176; 176, integer:1; 177, subscript; 177, 178; 177, 179; 178, identifier:right; 179, slice; 179, 180; 179, 181; 180, integer:1; 181, colon; 182, else_clause; 182, 183; 183, block; 183, 184; 183, 188; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:eager_uuids; 187, list:[]; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:bulk_uuids; 191, binary_operator:+; 191, 192; 191, 193; 192, identifier:left; 193, identifier:right; 194, function_definition; 194, 195; 194, 196; 194, 198; 195, function_name:get_dep_uuids; 196, parameters; 196, 197; 197, identifier:rec_uuids; 198, block; 198, 199; 199, return_statement; 199, 200; 200, list_comprehension; 200, 201; 200, 222; 201, call; 201, 202; 201, 203; 202, identifier:str; 203, argument_list; 203, 204; 204, attribute; 204, 205; 204, 221; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:PersistentIdentifier; 208, identifier:get; 209, argument_list; 209, 210; 209, 211; 210, string:'depid'; 211, subscript; 211, 212; 211, 220; 212, subscript; 212, 213; 212, 219; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:Record; 216, identifier:get_record; 217, argument_list; 217, 218; 218, identifier:id_; 219, string:'_deposit'; 220, string:'id'; 221, identifier:object_uuid; 222, for_in_clause; 222, 223; 222, 224; 223, identifier:id_; 224, identifier:rec_uuids; 225, if_statement; 225, 226; 225, 227; 226, identifier:with_deposits; 227, block; 227, 228; 227, 235; 228, expression_statement; 228, 229; 229, augmented_assignment:+=; 229, 230; 229, 231; 230, identifier:eager_uuids; 231, call; 231, 232; 231, 233; 232, identifier:get_dep_uuids; 233, argument_list; 233, 234; 234, identifier:eager_uuids; 235, expression_statement; 235, 236; 236, augmented_assignment:+=; 236, 237; 236, 238; 237, identifier:bulk_uuids; 238, call; 238, 239; 238, 240; 239, identifier:get_dep_uuids; 240, argument_list; 240, 241; 241, identifier:bulk_uuids; 242, for_statement; 242, 243; 242, 244; 242, 245; 243, identifier:id_; 244, identifier:eager_uuids; 245, block; 245, 246; 246, expression_statement; 246, 247; 247, call; 247, 248; 247, 253; 248, attribute; 248, 249; 248, 252; 249, call; 249, 250; 249, 251; 250, identifier:RecordIndexer; 251, argument_list; 252, identifier:index_by_id; 253, argument_list; 253, 254; 254, identifier:id_; 255, if_statement; 255, 256; 255, 257; 255, 268; 256, identifier:bulk_uuids; 257, ERROR; 257, 258; 258, block; 258, 259; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 266; 261, attribute; 261, 262; 261, 265; 262, call; 262, 263; 262, 264; 263, identifier:RecordIndexer; 264, argument_list; 265, identifier:bulk_index; 266, argument_list; 266, 267; 267, identifier:bulk_uuids; 268, block: | def index_siblings(pid, include_pid=False, children=None,
neighbors_eager=False, eager=False, with_deposits=True):
assert not (neighbors_eager and eager), \
if children is None:
parent_pid = PIDNodeVersioning(pid=pid).parents.first()
children = PIDNodeVersioning(pid=parent_pid).children.all()
objid = str(pid.object_uuid)
children = [str(p.object_uuid) for p in children]
idx = children.index(objid) if objid in children else len(children)
if include_pid:
left = children[:idx + 1]
else:
left = children[:idx]
right = children[idx + 1:]
if eager:
eager_uuids = left + right
bulk_uuids = []
elif neighbors_eager:
eager_uuids = left[-1:] + right[:1]
bulk_uuids = left[:-1] + right[1:]
else:
eager_uuids = []
bulk_uuids = left + right
def get_dep_uuids(rec_uuids):
return [str(PersistentIdentifier.get(
'depid',
Record.get_record(id_)['_deposit']['id']).object_uuid)
for id_ in rec_uuids]
if with_deposits:
eager_uuids += get_dep_uuids(eager_uuids)
bulk_uuids += get_dep_uuids(bulk_uuids)
for id_ in eager_uuids:
RecordIndexer().index_by_id(id_)
if bulk_uuids:
RecordIndexer().bulk_index(bulk_uuids) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:iter_paths; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:pathnames; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:mapfunc; 10, None; 11, block; 11, 12; 11, 20; 11, 40; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:pathnames; 15, boolean_operator:or; 15, 16; 15, 17; 16, identifier:pathnames; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_pathnames; 20, if_statement; 20, 21; 20, 27; 20, 33; 21, boolean_operator:and; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:recursive; 25, not_operator; 25, 26; 26, identifier:pathnames; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:pathnames; 31, list:['.']; 31, 32; 32, string:'.'; 33, elif_clause; 33, 34; 33, 36; 34, not_operator; 34, 35; 35, identifier:pathnames; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, yield; 38, 39; 39, list:[]; 40, if_statement; 40, 41; 40, 44; 40, 155; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:mapfunc; 43, None; 44, block; 44, 45; 45, for_statement; 45, 46; 45, 47; 45, 52; 46, identifier:mapped_paths; 47, call; 47, 48; 47, 49; 48, identifier:map; 49, argument_list; 49, 50; 49, 51; 50, identifier:mapfunc; 51, identifier:pathnames; 52, block; 52, 53; 53, for_statement; 53, 54; 53, 55; 53, 56; 54, identifier:path; 55, identifier:mapped_paths; 56, block; 56, 57; 57, if_statement; 57, 58; 57, 80; 57, 121; 58, boolean_operator:and; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:recursive; 62, parenthesized_expression; 62, 63; 63, boolean_operator:or; 63, 64; 63, 72; 64, call; 64, 65; 64, 70; 65, attribute; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:os; 68, identifier:path; 69, identifier:isdir; 70, argument_list; 70, 71; 71, identifier:path; 72, call; 72, 73; 72, 78; 73, attribute; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:os; 76, identifier:path; 77, identifier:islink; 78, argument_list; 78, 79; 79, identifier:path; 80, block; 80, 81; 81, for_statement; 81, 82; 81, 83; 81, 94; 82, identifier:t; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:os; 86, identifier:walk; 87, argument_list; 87, 88; 87, 89; 88, identifier:path; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:followlinks; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:follow_symlinks; 94, block; 94, 95; 95, for_statement; 95, 96; 95, 99; 95, 115; 96, pattern_list; 96, 97; 96, 98; 97, identifier:filename; 98, identifier:values; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:iglob; 103, argument_list; 103, 104; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:os; 108, identifier:path; 109, identifier:join; 110, argument_list; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:t; 113, integer:0; 114, string:'*'; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, yield; 117, 118; 118, expression_list; 118, 119; 118, 120; 119, identifier:filename; 120, identifier:values; 121, else_clause; 121, 122; 122, block; 122, 123; 122, 127; 122, 147; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:empty_glob; 126, True; 127, for_statement; 127, 128; 127, 131; 127, 137; 128, pattern_list; 128, 129; 128, 130; 129, identifier:filename; 130, identifier:values; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:iglob; 135, argument_list; 135, 136; 136, identifier:path; 137, block; 137, 138; 137, 143; 138, expression_statement; 138, 139; 139, yield; 139, 140; 140, expression_list; 140, 141; 140, 142; 141, identifier:filename; 142, identifier:values; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:empty_glob; 146, False; 147, if_statement; 147, 148; 147, 149; 148, identifier:empty_glob; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, yield; 151, 152; 152, expression_list; 152, 153; 152, 154; 153, identifier:path; 154, None; 155, else_clause; 155, 156; 156, block; 156, 157; 157, for_statement; 157, 158; 157, 159; 157, 160; 158, identifier:path; 159, identifier:pathnames; 160, block; 160, 161; 161, if_statement; 161, 162; 161, 184; 161, 225; 162, boolean_operator:and; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:recursive; 166, parenthesized_expression; 166, 167; 167, boolean_operator:or; 167, 168; 167, 176; 168, call; 168, 169; 168, 174; 169, attribute; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:os; 172, identifier:path; 173, identifier:isdir; 174, argument_list; 174, 175; 175, identifier:path; 176, call; 176, 177; 176, 182; 177, attribute; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:os; 180, identifier:path; 181, identifier:islink; 182, argument_list; 182, 183; 183, identifier:path; 184, block; 184, 185; 185, for_statement; 185, 186; 185, 187; 185, 198; 186, identifier:t; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:os; 190, identifier:walk; 191, argument_list; 191, 192; 191, 193; 192, identifier:path; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:followlinks; 195, attribute; 195, 196; 195, 197; 196, identifier:self; 197, identifier:follow_symlinks; 198, block; 198, 199; 199, for_statement; 199, 200; 199, 203; 199, 219; 200, pattern_list; 200, 201; 200, 202; 201, identifier:filename; 202, identifier:values; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:self; 206, identifier:iglob; 207, argument_list; 207, 208; 208, call; 208, 209; 208, 214; 209, attribute; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:os; 212, identifier:path; 213, identifier:join; 214, argument_list; 214, 215; 214, 218; 215, subscript; 215, 216; 215, 217; 216, identifier:t; 217, integer:0; 218, string:'*'; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, yield; 221, 222; 222, expression_list; 222, 223; 222, 224; 223, identifier:filename; 224, identifier:values; 225, else_clause; 225, 226; 226, block; 226, 227; 226, 231; 226, 251; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:empty_glob; 230, True; 231, for_statement; 231, 232; 231, 235; 231, 241; 232, pattern_list; 232, 233; 232, 234; 233, identifier:filename; 234, identifier:values; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:self; 238, identifier:iglob; 239, argument_list; 239, 240; 240, identifier:path; 241, block; 241, 242; 241, 247; 242, expression_statement; 242, 243; 243, yield; 243, 244; 244, expression_list; 244, 245; 244, 246; 245, identifier:filename; 246, identifier:values; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:empty_glob; 250, False; 251, if_statement; 251, 252; 251, 253; 252, identifier:empty_glob; 253, block; 253, 254; 254, expression_statement; 254, 255; 255, yield; 255, 256; 256, expression_list; 256, 257; 256, 258; 257, identifier:path; 258, None | def iter_paths(self, pathnames=None, mapfunc=None):
pathnames = pathnames or self._pathnames
if self.recursive and not pathnames:
pathnames = ['.']
elif not pathnames:
yield []
if mapfunc is not None:
for mapped_paths in map(mapfunc, pathnames):
for path in mapped_paths:
if self.recursive and (os.path.isdir(path) or os.path.islink(path)):
for t in os.walk(path, followlinks=self.follow_symlinks):
for filename, values in self.iglob(os.path.join(t[0], '*')):
yield filename, values
else:
empty_glob = True
for filename, values in self.iglob(path):
yield filename, values
empty_glob = False
if empty_glob:
yield path, None
else:
for path in pathnames:
if self.recursive and (os.path.isdir(path) or os.path.islink(path)):
for t in os.walk(path, followlinks=self.follow_symlinks):
for filename, values in self.iglob(os.path.join(t[0], '*')):
yield filename, values
else:
empty_glob = True
for filename, values in self.iglob(path):
yield filename, values
empty_glob = False
if empty_glob:
yield path, None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:process; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 4, identifier:source; 5, identifier:target; 6, identifier:rdfsonly; 7, default_parameter; 7, 8; 7, 9; 8, identifier:base; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:logger; 12, identifier:logging; 13, block; 13, 14; 13, 16; 13, 294; 14, expression_statement; 14, 15; 15, string:'''
Prepare a statement into a triple ready for rdflib graph
'''; 16, for_statement; 16, 17; 16, 18; 16, 23; 17, identifier:link; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:source; 21, identifier:match; 22, argument_list; 23, block; 23, 24; 23, 35; 23, 46; 23, 57; 23, 68; 23, 131; 23, 176; 23, 228; 23, 235; 23, 249; 23, 266; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 30; 26, pattern_list; 26, 27; 26, 28; 26, 29; 27, identifier:s; 28, identifier:p; 29, identifier:o; 30, subscript; 30, 31; 30, 32; 31, identifier:link; 32, slice; 32, 33; 32, 34; 33, colon; 34, integer:3; 35, if_statement; 35, 36; 35, 44; 36, comparison_operator:==; 36, 37; 36, 38; 37, identifier:s; 38, binary_operator:+; 38, 39; 38, 43; 39, parenthesized_expression; 39, 40; 40, boolean_operator:or; 40, 41; 40, 42; 41, identifier:base; 42, string:''; 43, string:'@docheader'; 44, block; 44, 45; 45, continue_statement; 46, if_statement; 46, 47; 46, 50; 47, comparison_operator:in; 47, 48; 47, 49; 48, identifier:p; 49, identifier:RESOURCE_MAPPING; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:p; 54, subscript; 54, 55; 54, 56; 55, identifier:RESOURCE_MAPPING; 56, identifier:p; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:in; 58, 59; 58, 60; 59, identifier:o; 60, identifier:RESOURCE_MAPPING; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:o; 65, subscript; 65, 66; 65, 67; 66, identifier:RESOURCE_MAPPING; 67, identifier:o; 68, if_statement; 68, 69; 68, 74; 69, comparison_operator:==; 69, 70; 69, 71; 70, identifier:p; 71, binary_operator:+; 71, 72; 71, 73; 72, identifier:VERSA_BASEIRI; 73, string:'refines'; 74, block; 74, 75; 74, 88; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:tlinks; 78, call; 78, 79; 78, 80; 79, identifier:list; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:source; 84, identifier:match; 85, argument_list; 85, 86; 85, 87; 86, identifier:s; 87, identifier:TYPE_REL; 88, if_statement; 88, 89; 88, 90; 89, identifier:tlinks; 90, block; 90, 91; 91, if_statement; 91, 92; 91, 101; 91, 111; 92, comparison_operator:==; 92, 93; 92, 98; 93, subscript; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:tlinks; 96, integer:0; 97, identifier:TARGET; 98, binary_operator:+; 98, 99; 98, 100; 99, identifier:VERSA_BASEIRI; 100, string:'Resource'; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:p; 105, call; 105, 106; 105, 107; 106, identifier:I; 107, argument_list; 107, 108; 108, binary_operator:+; 108, 109; 108, 110; 109, identifier:RDFS_NAMESPACE; 110, string:'subClassOf'; 111, elif_clause; 111, 112; 111, 121; 112, comparison_operator:==; 112, 113; 112, 118; 113, subscript; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:tlinks; 116, integer:0; 117, identifier:TARGET; 118, binary_operator:+; 118, 119; 118, 120; 119, identifier:VERSA_BASEIRI; 120, string:'Property'; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:p; 125, call; 125, 126; 125, 127; 126, identifier:I; 127, argument_list; 127, 128; 128, binary_operator:+; 128, 129; 128, 130; 129, identifier:RDFS_NAMESPACE; 130, string:'subPropertyOf'; 131, if_statement; 131, 132; 131, 137; 132, comparison_operator:==; 132, 133; 132, 134; 133, identifier:p; 134, binary_operator:+; 134, 135; 134, 136; 135, identifier:VERSA_BASEIRI; 136, string:'properties'; 137, block; 137, 138; 137, 154; 137, 175; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:suri; 141, conditional_expression:if; 141, 142; 141, 152; 141, 153; 142, call; 142, 143; 142, 144; 143, identifier:I; 144, argument_list; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:iri; 148, identifier:absolutize; 149, argument_list; 149, 150; 149, 151; 150, identifier:s; 151, identifier:base; 152, identifier:base; 153, identifier:s; 154, expression_statement; 154, 155; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:target; 158, identifier:add; 159, argument_list; 159, 160; 160, tuple; 160, 161; 160, 165; 160, 171; 161, call; 161, 162; 161, 163; 162, identifier:URIRef; 163, argument_list; 163, 164; 164, identifier:o; 165, call; 165, 166; 165, 167; 166, identifier:URIRef; 167, argument_list; 167, 168; 168, binary_operator:+; 168, 169; 168, 170; 169, identifier:RDFS_NAMESPACE; 170, string:'domain'; 171, call; 171, 172; 171, 173; 172, identifier:URIRef; 173, argument_list; 173, 174; 174, identifier:suri; 175, continue_statement; 176, if_statement; 176, 177; 176, 182; 177, comparison_operator:==; 177, 178; 177, 179; 178, identifier:p; 179, binary_operator:+; 179, 180; 179, 181; 180, identifier:VERSA_BASEIRI; 181, string:'value'; 182, block; 182, 183; 183, if_statement; 183, 184; 183, 189; 184, comparison_operator:not; 184, 185; 184, 186; 185, identifier:o; 186, list:['Literal', 'IRI']; 186, 187; 186, 188; 187, string:'Literal'; 188, string:'IRI'; 189, block; 189, 190; 189, 206; 189, 227; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:ouri; 193, conditional_expression:if; 193, 194; 193, 204; 193, 205; 194, call; 194, 195; 194, 196; 195, identifier:I; 196, argument_list; 196, 197; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:iri; 200, identifier:absolutize; 201, argument_list; 201, 202; 201, 203; 202, identifier:o; 203, identifier:base; 204, identifier:base; 205, identifier:o; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:target; 210, identifier:add; 211, argument_list; 211, 212; 212, tuple; 212, 213; 212, 217; 212, 223; 213, call; 213, 214; 213, 215; 214, identifier:URIRef; 215, argument_list; 215, 216; 216, identifier:s; 217, call; 217, 218; 217, 219; 218, identifier:URIRef; 219, argument_list; 219, 220; 220, binary_operator:+; 220, 221; 220, 222; 221, identifier:RDFS_NAMESPACE; 222, string:'range'; 223, call; 223, 224; 223, 225; 224, identifier:URIRef; 225, argument_list; 225, 226; 226, identifier:ouri; 227, continue_statement; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:s; 231, call; 231, 232; 231, 233; 232, identifier:URIRef; 233, argument_list; 233, 234; 234, identifier:s; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:p; 238, conditional_expression:if; 238, 239; 238, 242; 238, 245; 239, attribute; 239, 240; 239, 241; 240, identifier:RDF; 241, identifier:type; 242, comparison_operator:==; 242, 243; 242, 244; 243, identifier:p; 244, identifier:TYPE_REL; 245, call; 245, 246; 245, 247; 246, identifier:URIRef; 247, argument_list; 247, 248; 248, identifier:p; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:o; 252, conditional_expression:if; 252, 253; 252, 257; 252, 262; 253, call; 253, 254; 253, 255; 254, identifier:URIRef; 255, argument_list; 255, 256; 256, identifier:o; 257, call; 257, 258; 257, 259; 258, identifier:isinstance; 259, argument_list; 259, 260; 259, 261; 260, identifier:o; 261, identifier:I; 262, call; 262, 263; 262, 264; 263, identifier:Literal; 264, argument_list; 264, 265; 265, identifier:o; 266, if_statement; 266, 267; 266, 283; 267, boolean_operator:or; 267, 268; 267, 277; 268, boolean_operator:or; 268, 269; 268, 271; 269, not_operator; 269, 270; 270, identifier:rdfsonly; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:p; 274, identifier:startswith; 275, argument_list; 275, 276; 276, identifier:RDF_NAMESPACE; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:p; 280, identifier:startswith; 281, argument_list; 281, 282; 282, identifier:RDFS_NAMESPACE; 283, block; 283, 284; 284, expression_statement; 284, 285; 285, call; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:target; 288, identifier:add; 289, argument_list; 289, 290; 290, tuple; 290, 291; 290, 292; 290, 293; 291, identifier:s; 292, identifier:p; 293, identifier:o; 294, return_statement | def process(source, target, rdfsonly, base=None, logger=logging):
'''
Prepare a statement into a triple ready for rdflib graph
'''
for link in source.match():
s, p, o = link[:3]
if s == (base or '') + '@docheader': continue
if p in RESOURCE_MAPPING: p = RESOURCE_MAPPING[p]
if o in RESOURCE_MAPPING: o = RESOURCE_MAPPING[o]
if p == VERSA_BASEIRI + 'refines':
tlinks = list(source.match(s, TYPE_REL))
if tlinks:
if tlinks[0][TARGET] == VERSA_BASEIRI + 'Resource':
p = I(RDFS_NAMESPACE + 'subClassOf')
elif tlinks[0][TARGET] == VERSA_BASEIRI + 'Property':
p = I(RDFS_NAMESPACE + 'subPropertyOf')
if p == VERSA_BASEIRI + 'properties':
suri = I(iri.absolutize(s, base)) if base else s
target.add((URIRef(o), URIRef(RDFS_NAMESPACE + 'domain'), URIRef(suri)))
continue
if p == VERSA_BASEIRI + 'value':
if o not in ['Literal', 'IRI']:
ouri = I(iri.absolutize(o, base)) if base else o
target.add((URIRef(s), URIRef(RDFS_NAMESPACE + 'range'), URIRef(ouri)))
continue
s = URIRef(s)
p = RDF.type if p == TYPE_REL else URIRef(p)
o = URIRef(o) if isinstance(o, I) else Literal(o)
if not rdfsonly or p.startswith(RDF_NAMESPACE) or p.startswith(RDFS_NAMESPACE):
target.add((s, p, o))
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:show_more; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 11; 3, 14; 4, identifier:request; 5, identifier:post_process_fun; 6, identifier:get_fun; 7, identifier:object_class; 8, default_parameter; 8, 9; 8, 10; 9, identifier:should_cache; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:template; 13, string:'common_json.html'; 14, default_parameter; 14, 15; 14, 16; 15, identifier:to_json_kwargs; 16, None; 17, block; 17, 18; 17, 48; 17, 78; 17, 87; 17, 93; 17, 112; 17, 127; 18, if_statement; 18, 19; 18, 27; 19, boolean_operator:and; 19, 20; 19, 22; 20, not_operator; 20, 21; 21, identifier:should_cache; 22, comparison_operator:in; 22, 23; 22, 24; 23, string:'json_orderby'; 24, attribute; 24, 25; 24, 26; 25, identifier:request; 26, identifier:GET; 27, block; 27, 28; 28, return_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:render_json; 31, argument_list; 31, 32; 31, 33; 31, 37; 31, 40; 31, 45; 32, identifier:request; 33, dictionary; 33, 34; 34, pair; 34, 35; 34, 36; 35, string:'error'; 36, string:"Can't order the result according to the JSON field, because the caching for this type of object is turned off. See the documentation."; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:template; 39, string:'questions_json.html'; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:help_text; 42, attribute; 42, 43; 42, 44; 43, identifier:show_more; 44, identifier:__doc__; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:status; 47, integer:501; 48, if_statement; 48, 49; 48, 57; 49, boolean_operator:and; 49, 50; 49, 52; 50, not_operator; 50, 51; 51, identifier:should_cache; 52, comparison_operator:in; 52, 53; 52, 54; 53, string:'all'; 54, attribute; 54, 55; 54, 56; 55, identifier:request; 56, identifier:GET; 57, block; 57, 58; 58, return_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:render_json; 61, argument_list; 61, 62; 61, 63; 61, 67; 61, 70; 61, 75; 62, identifier:request; 63, dictionary; 63, 64; 64, pair; 64, 65; 64, 66; 65, string:'error'; 66, string:"Can't get all objects, because the caching for this type of object is turned off. See the documentation."; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:template; 69, string:'questions_json.html'; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:help_text; 72, attribute; 72, 73; 72, 74; 73, identifier:show_more; 74, identifier:__doc__; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:status; 77, integer:501; 78, if_statement; 78, 79; 78, 82; 79, comparison_operator:is; 79, 80; 79, 81; 80, identifier:to_json_kwargs; 81, None; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:to_json_kwargs; 86, dictionary; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:time_start; 90, call; 90, 91; 90, 92; 91, identifier:time_lib; 92, argument_list; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:limit; 96, call; 96, 97; 96, 98; 97, identifier:min; 98, argument_list; 98, 99; 98, 111; 99, call; 99, 100; 99, 101; 100, identifier:int; 101, argument_list; 101, 102; 102, call; 102, 103; 102, 108; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:request; 106, identifier:GET; 107, identifier:get; 108, argument_list; 108, 109; 108, 110; 109, string:'limit'; 110, integer:10; 111, integer:100; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:page; 115, call; 115, 116; 115, 117; 116, identifier:int; 117, argument_list; 117, 118; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:request; 122, identifier:GET; 123, identifier:get; 124, argument_list; 124, 125; 124, 126; 125, string:'page'; 126, integer:0; 127, try_statement; 127, 128; 127, 409; 128, block; 128, 129; 128, 137; 128, 172; 128, 201; 128, 231; 128, 240; 128, 296; 128, 309; 128, 317; 128, 395; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:objs; 132, call; 132, 133; 132, 134; 133, identifier:get_fun; 134, argument_list; 134, 135; 134, 136; 135, identifier:request; 136, identifier:object_class; 137, if_statement; 137, 138; 137, 143; 138, comparison_operator:in; 138, 139; 138, 140; 139, string:'db_orderby'; 140, attribute; 140, 141; 140, 142; 141, identifier:request; 142, identifier:GET; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:objs; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:objs; 150, identifier:order_by; 151, argument_list; 151, 152; 152, binary_operator:+; 152, 153; 152, 162; 153, parenthesized_expression; 153, 154; 154, conditional_expression:if; 154, 155; 154, 156; 154, 161; 155, string:'-'; 156, comparison_operator:in; 156, 157; 156, 158; 157, string:'desc'; 158, attribute; 158, 159; 158, 160; 159, identifier:request; 160, identifier:GET; 161, string:''; 162, call; 162, 163; 162, 170; 163, attribute; 163, 164; 163, 169; 164, subscript; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:request; 167, identifier:GET; 168, string:'db_orderby'; 169, identifier:strip; 170, argument_list; 170, 171; 171, string:'/'; 172, if_statement; 172, 173; 172, 184; 173, boolean_operator:and; 173, 174; 173, 179; 174, comparison_operator:not; 174, 175; 174, 176; 175, string:'all'; 176, attribute; 176, 177; 176, 178; 177, identifier:request; 178, identifier:GET; 179, comparison_operator:not; 179, 180; 179, 181; 180, string:'json_orderby'; 181, attribute; 181, 182; 181, 183; 182, identifier:request; 183, identifier:GET; 184, block; 184, 185; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:objs; 188, subscript; 188, 189; 188, 190; 189, identifier:objs; 190, slice; 190, 191; 190, 194; 190, 195; 191, binary_operator:*; 191, 192; 191, 193; 192, identifier:page; 193, identifier:limit; 194, colon; 195, binary_operator:*; 195, 196; 195, 200; 196, parenthesized_expression; 196, 197; 197, binary_operator:+; 197, 198; 197, 199; 198, identifier:page; 199, integer:1; 200, identifier:limit; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:cache_key; 204, binary_operator:%; 204, 205; 204, 206; 205, string:'proso_common_sql_json_%s'; 206, call; 206, 207; 206, 230; 207, attribute; 207, 208; 207, 229; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:hashlib; 211, identifier:sha1; 212, argument_list; 212, 213; 213, call; 213, 214; 213, 228; 214, attribute; 214, 215; 214, 227; 215, parenthesized_expression; 215, 216; 216, binary_operator:+; 216, 217; 216, 223; 217, call; 217, 218; 217, 219; 218, identifier:str; 219, argument_list; 219, 220; 220, attribute; 220, 221; 220, 222; 221, identifier:objs; 222, identifier:query; 223, call; 223, 224; 223, 225; 224, identifier:str; 225, argument_list; 225, 226; 226, identifier:to_json_kwargs; 227, identifier:encode; 228, argument_list; 229, identifier:hexdigest; 230, argument_list; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:cached; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:cache; 237, identifier:get; 238, argument_list; 238, 239; 239, identifier:cache_key; 240, if_statement; 240, 241; 240, 244; 240, 254; 241, boolean_operator:and; 241, 242; 241, 243; 242, identifier:should_cache; 243, identifier:cached; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:list_objs; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:json_lib; 251, identifier:loads; 252, argument_list; 252, 253; 253, identifier:cached; 254, else_clause; 254, 255; 255, block; 255, 256; 255, 273; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 258, identifier:list_objs; 259, list_comprehension; 259, 260; 259, 267; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:x; 263, identifier:to_json; 264, argument_list; 264, 265; 265, dictionary_splat; 265, 266; 266, identifier:to_json_kwargs; 267, for_in_clause; 267, 268; 267, 269; 268, identifier:x; 269, call; 269, 270; 269, 271; 270, identifier:list; 271, argument_list; 271, 272; 272, identifier:objs; 273, if_statement; 273, 274; 273, 275; 274, identifier:should_cache; 275, block; 275, 276; 276, expression_statement; 276, 277; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:cache; 280, identifier:set; 281, argument_list; 281, 282; 281, 283; 281, 289; 282, identifier:cache_key; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:json_lib; 286, identifier:dumps; 287, argument_list; 287, 288; 288, identifier:list_objs; 289, binary_operator:*; 289, 290; 289, 295; 290, binary_operator:*; 290, 291; 290, 294; 291, binary_operator:*; 291, 292; 291, 293; 292, integer:60; 293, integer:60; 294, integer:24; 295, integer:30; 296, expression_statement; 296, 297; 297, call; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:LOGGER; 300, identifier:debug; 301, argument_list; 301, 302; 301, 303; 302, string:'loading objects in show_more view took %s seconds'; 303, parenthesized_expression; 303, 304; 304, binary_operator:-; 304, 305; 304, 308; 305, call; 305, 306; 305, 307; 306, identifier:time_lib; 307, argument_list; 308, identifier:time_start; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 312; 311, identifier:json; 312, call; 312, 313; 312, 314; 313, identifier:post_process_fun; 314, argument_list; 314, 315; 314, 316; 315, identifier:request; 316, identifier:list_objs; 317, if_statement; 317, 318; 317, 323; 318, comparison_operator:in; 318, 319; 318, 320; 319, string:'json_orderby'; 320, attribute; 320, 321; 320, 322; 321, identifier:request; 322, identifier:GET; 323, block; 323, 324; 323, 330; 323, 359; 323, 382; 324, expression_statement; 324, 325; 325, assignment; 325, 326; 325, 327; 326, identifier:time_before_json_sort; 327, call; 327, 328; 327, 329; 328, identifier:time_lib; 329, argument_list; 330, expression_statement; 330, 331; 331, call; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:json; 334, identifier:sort; 335, argument_list; 335, 336; 336, keyword_argument; 336, 337; 336, 338; 337, identifier:key; 338, lambda; 338, 339; 338, 341; 339, lambda_parameters; 339, 340; 340, identifier:x; 341, binary_operator:*; 341, 342; 341, 352; 342, parenthesized_expression; 342, 343; 343, conditional_expression:if; 343, 344; 343, 346; 343, 351; 344, unary_operator:-; 344, 345; 345, integer:1; 346, comparison_operator:in; 346, 347; 346, 348; 347, string:'desc'; 348, attribute; 348, 349; 348, 350; 349, identifier:request; 350, identifier:GET; 351, integer:1; 352, subscript; 352, 353; 352, 354; 353, identifier:x; 354, subscript; 354, 355; 354, 358; 355, attribute; 355, 356; 355, 357; 356, identifier:request; 357, identifier:GET; 358, string:'json_orderby'; 359, if_statement; 359, 360; 359, 365; 360, comparison_operator:not; 360, 361; 360, 362; 361, string:'all'; 362, attribute; 362, 363; 362, 364; 363, identifier:request; 364, identifier:GET; 365, block; 365, 366; 366, expression_statement; 366, 367; 367, assignment; 367, 368; 367, 369; 368, identifier:json; 369, subscript; 369, 370; 369, 371; 370, identifier:json; 371, slice; 371, 372; 371, 375; 371, 376; 372, binary_operator:*; 372, 373; 372, 374; 373, identifier:page; 374, identifier:limit; 375, colon; 376, binary_operator:*; 376, 377; 376, 381; 377, parenthesized_expression; 377, 378; 378, binary_operator:+; 378, 379; 378, 380; 379, identifier:page; 380, integer:1; 381, identifier:limit; 382, expression_statement; 382, 383; 383, call; 383, 384; 383, 387; 384, attribute; 384, 385; 384, 386; 385, identifier:LOGGER; 386, identifier:debug; 387, argument_list; 387, 388; 387, 389; 388, string:'sorting objects according to JSON field took %s seconds'; 389, parenthesized_expression; 389, 390; 390, binary_operator:-; 390, 391; 390, 394; 391, call; 391, 392; 391, 393; 392, identifier:time_lib; 393, argument_list; 394, identifier:time_before_json_sort; 395, return_statement; 395, 396; 396, call; 396, 397; 396, 398; 397, identifier:render_json; 398, argument_list; 398, 399; 398, 400; 398, 401; 398, 404; 399, identifier:request; 400, identifier:json; 401, keyword_argument; 401, 402; 401, 403; 402, identifier:template; 403, identifier:template; 404, keyword_argument; 404, 405; 404, 406; 405, identifier:help_text; 406, attribute; 406, 407; 406, 408; 407, identifier:show_more; 408, identifier:__doc__; 409, except_clause; 409, 410; 409, 411; 410, identifier:EmptyResultSet; 411, block; 411, 412; 412, return_statement; 412, 413; 413, call; 413, 414; 413, 415; 414, identifier:render_json; 415, argument_list; 415, 416; 415, 417; 415, 418; 415, 421; 416, identifier:request; 417, list:[]; 418, keyword_argument; 418, 419; 418, 420; 419, identifier:template; 420, identifier:template; 421, keyword_argument; 421, 422; 421, 423; 422, identifier:help_text; 423, attribute; 423, 424; 423, 425; 424, identifier:show_more; 425, identifier:__doc__ | def show_more(request, post_process_fun, get_fun, object_class, should_cache=True, template='common_json.html', to_json_kwargs=None):
if not should_cache and 'json_orderby' in request.GET:
return render_json(request, {
'error': "Can't order the result according to the JSON field, because the caching for this type of object is turned off. See the documentation."
},
template='questions_json.html', help_text=show_more.__doc__, status=501)
if not should_cache and 'all' in request.GET:
return render_json(request, {
'error': "Can't get all objects, because the caching for this type of object is turned off. See the documentation."
},
template='questions_json.html', help_text=show_more.__doc__, status=501)
if to_json_kwargs is None:
to_json_kwargs = {}
time_start = time_lib()
limit = min(int(request.GET.get('limit', 10)), 100)
page = int(request.GET.get('page', 0))
try:
objs = get_fun(request, object_class)
if 'db_orderby' in request.GET:
objs = objs.order_by(('-' if 'desc' in request.GET else '') + request.GET['db_orderby'].strip('/'))
if 'all' not in request.GET and 'json_orderby' not in request.GET:
objs = objs[page * limit:(page + 1) * limit]
cache_key = 'proso_common_sql_json_%s' % hashlib.sha1((str(objs.query) + str(to_json_kwargs)).encode()).hexdigest()
cached = cache.get(cache_key)
if should_cache and cached:
list_objs = json_lib.loads(cached)
else:
list_objs = [x.to_json(**to_json_kwargs) for x in list(objs)]
if should_cache:
cache.set(cache_key, json_lib.dumps(list_objs), 60 * 60 * 24 * 30)
LOGGER.debug('loading objects in show_more view took %s seconds', (time_lib() - time_start))
json = post_process_fun(request, list_objs)
if 'json_orderby' in request.GET:
time_before_json_sort = time_lib()
json.sort(key=lambda x: (-1 if 'desc' in request.GET else 1) * x[request.GET['json_orderby']])
if 'all' not in request.GET:
json = json[page * limit:(page + 1) * limit]
LOGGER.debug('sorting objects according to JSON field took %s seconds', (time_lib() - time_before_json_sort))
return render_json(request, json, template=template, help_text=show_more.__doc__)
except EmptyResultSet:
return render_json(request, [], template=template, help_text=show_more.__doc__) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 28; 2, function_name:cache_control; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 4, default_parameter; 4, 5; 4, 6; 5, identifier:max_age; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:private; 9, False; 10, default_parameter; 10, 11; 10, 12; 11, identifier:public; 12, False; 13, default_parameter; 13, 14; 13, 15; 14, identifier:s_maxage; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:must_revalidate; 18, False; 19, default_parameter; 19, 20; 19, 21; 20, identifier:proxy_revalidate; 21, False; 22, default_parameter; 22, 23; 22, 24; 23, identifier:no_cache; 24, False; 25, default_parameter; 25, 26; 25, 27; 26, identifier:no_store; 27, False; 28, block; 28, 29; 28, 42; 28, 59; 28, 76; 28, 80; 28, 90; 28, 100; 28, 114; 28, 128; 28, 138; 28, 148; 28, 158; 28, 168; 29, if_statement; 29, 30; 29, 36; 30, call; 30, 31; 30, 32; 31, identifier:all; 32, argument_list; 32, 33; 33, list:[private, public]; 33, 34; 33, 35; 34, identifier:private; 35, identifier:public; 36, block; 36, 37; 37, raise_statement; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:ValueError; 40, argument_list; 40, 41; 41, string:"'private' and 'public' are mutually exclusive"; 42, if_statement; 42, 43; 42, 48; 43, call; 43, 44; 43, 45; 44, identifier:isinstance; 45, argument_list; 45, 46; 45, 47; 46, identifier:max_age; 47, identifier:timedelta; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:max_age; 52, call; 52, 53; 52, 54; 53, identifier:int; 54, argument_list; 54, 55; 55, call; 55, 56; 55, 57; 56, identifier:total_seconds; 57, argument_list; 57, 58; 58, identifier:max_age; 59, if_statement; 59, 60; 59, 65; 60, call; 60, 61; 60, 62; 61, identifier:isinstance; 62, argument_list; 62, 63; 62, 64; 63, identifier:s_maxage; 64, identifier:timedelta; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:s_maxage; 69, call; 69, 70; 69, 71; 70, identifier:int; 71, argument_list; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:total_seconds; 74, argument_list; 74, 75; 75, identifier:s_maxage; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:directives; 79, list:[]; 80, if_statement; 80, 81; 80, 82; 81, identifier:public; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:directives; 87, identifier:append; 88, argument_list; 88, 89; 89, string:'public'; 90, if_statement; 90, 91; 90, 92; 91, identifier:private; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:directives; 97, identifier:append; 98, argument_list; 98, 99; 99, string:'private'; 100, if_statement; 100, 101; 100, 104; 101, comparison_operator:is; 101, 102; 101, 103; 102, identifier:max_age; 103, None; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:directives; 109, identifier:append; 110, argument_list; 110, 111; 111, binary_operator:%; 111, 112; 111, 113; 112, string:'max-age=%d'; 113, identifier:max_age; 114, if_statement; 114, 115; 114, 118; 115, comparison_operator:is; 115, 116; 115, 117; 116, identifier:s_maxage; 117, None; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:directives; 123, identifier:append; 124, argument_list; 124, 125; 125, binary_operator:%; 125, 126; 125, 127; 126, string:'s-maxage=%d'; 127, identifier:s_maxage; 128, if_statement; 128, 129; 128, 130; 129, identifier:no_cache; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:directives; 135, identifier:append; 136, argument_list; 136, 137; 137, string:'no-cache'; 138, if_statement; 138, 139; 138, 140; 139, identifier:no_store; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:directives; 145, identifier:append; 146, argument_list; 146, 147; 147, string:'no-store'; 148, if_statement; 148, 149; 148, 150; 149, identifier:must_revalidate; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:directives; 155, identifier:append; 156, argument_list; 156, 157; 157, string:'must-revalidate'; 158, if_statement; 158, 159; 158, 160; 159, identifier:proxy_revalidate; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:directives; 165, identifier:append; 166, argument_list; 166, 167; 167, string:'proxy-revalidate'; 168, return_statement; 168, 169; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, string:', '; 172, identifier:join; 173, argument_list; 173, 174; 174, identifier:directives | def cache_control(max_age=None, private=False, public=False, s_maxage=None,
must_revalidate=False, proxy_revalidate=False, no_cache=False,
no_store=False):
if all([private, public]):
raise ValueError("'private' and 'public' are mutually exclusive")
if isinstance(max_age, timedelta):
max_age = int(total_seconds(max_age))
if isinstance(s_maxage, timedelta):
s_maxage = int(total_seconds(s_maxage))
directives = []
if public: directives.append('public')
if private: directives.append('private')
if max_age is not None: directives.append('max-age=%d' % max_age)
if s_maxage is not None: directives.append('s-maxage=%d' % s_maxage)
if no_cache: directives.append('no-cache')
if no_store: directives.append('no-store')
if must_revalidate: directives.append('must-revalidate')
if proxy_revalidate: directives.append('proxy-revalidate')
return ', '.join(directives) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:plot_places; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 15; 5, 25; 5, 29; 5, 33; 5, 90; 5, 133; 5, 149; 5, 159; 5, 169; 5, 212; 6, expression_statement; 6, 7; 7, string:'''Plot places where the agent has been and generated a spirograph.
'''; 8, import_from_statement; 8, 9; 8, 11; 9, dotted_name; 9, 10; 10, identifier:matplotlib; 11, aliased_import; 11, 12; 11, 14; 12, dotted_name; 12, 13; 13, identifier:pyplot; 14, identifier:plt; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 20; 17, pattern_list; 17, 18; 17, 19; 18, identifier:fig; 19, identifier:ax; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:plt; 23, identifier:subplots; 24, argument_list; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:x; 28, list:[]; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:y; 32, list:[]; 33, if_statement; 33, 34; 33, 42; 34, comparison_operator:>; 34, 35; 34, 41; 35, call; 35, 36; 35, 37; 36, identifier:len; 37, argument_list; 37, 38; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:arg_history; 41, integer:1; 42, block; 42, 43; 42, 47; 42, 51; 42, 75; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:xs; 46, list:[]; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:ys; 50, list:[]; 51, for_statement; 51, 52; 51, 53; 51, 56; 52, identifier:p; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:arg_history; 56, block; 56, 57; 56, 66; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:xs; 61, identifier:append; 62, argument_list; 62, 63; 63, subscript; 63, 64; 63, 65; 64, identifier:p; 65, integer:0; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:ys; 70, identifier:append; 71, argument_list; 71, 72; 72, subscript; 72, 73; 72, 74; 73, identifier:p; 74, integer:1; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:ax; 79, identifier:plot; 80, argument_list; 80, 81; 80, 82; 80, 83; 81, identifier:xs; 82, identifier:ys; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:color; 85, tuple; 85, 86; 85, 87; 85, 88; 85, 89; 86, float:0.0; 87, float:0.0; 88, float:1.0; 89, float:0.1; 90, for_statement; 90, 91; 90, 92; 90, 95; 91, identifier:a; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:A; 95, block; 95, 96; 96, if_statement; 96, 97; 96, 102; 97, comparison_operator:==; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:a; 100, identifier:self_criticism; 101, string:'pass'; 102, block; 102, 103; 102, 115; 102, 124; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:args; 106, subscript; 106, 107; 106, 114; 107, subscript; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:a; 110, identifier:framings; 111, attribute; 111, 112; 111, 113; 112, identifier:a; 113, identifier:creator; 114, string:'args'; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:x; 119, identifier:append; 120, argument_list; 120, 121; 121, subscript; 121, 122; 121, 123; 122, identifier:args; 123, integer:0; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:y; 128, identifier:append; 129, argument_list; 129, 130; 130, subscript; 130, 131; 130, 132; 131, identifier:args; 132, integer:1; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:sc; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:ax; 139, identifier:scatter; 140, argument_list; 140, 141; 140, 142; 140, 143; 140, 146; 141, identifier:x; 142, identifier:y; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:marker; 145, string:"x"; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:color; 148, string:'red'; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:ax; 153, identifier:set_xlim; 154, argument_list; 154, 155; 155, list:[-200, 200]; 155, 156; 155, 158; 156, unary_operator:-; 156, 157; 157, integer:200; 158, integer:200; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:ax; 163, identifier:set_ylim; 164, argument_list; 164, 165; 165, list:[-200, 200]; 165, 166; 165, 168; 166, unary_operator:-; 166, 167; 167, integer:200; 168, integer:200; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:agent_vars; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, string:"{}_{}_{}{}_last={}_stmem=list{}_veto={}_sc={}_jump={}_sw={}_mr={}_maxN"; 175, identifier:format; 176, argument_list; 176, 177; 176, 180; 176, 183; 176, 186; 176, 189; 176, 192; 176, 197; 176, 200; 176, 203; 176, 206; 176, 209; 177, attribute; 177, 178; 177, 179; 178, identifier:self; 179, identifier:name; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:age; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:env_learning_method; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:env_learning_amount; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:env_learn_on_add; 192, attribute; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:self; 195, identifier:stmem; 196, identifier:length; 197, attribute; 197, 198; 197, 199; 198, identifier:self; 199, identifier:_novelty_threshold; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:_own_threshold; 203, attribute; 203, 204; 203, 205; 204, identifier:self; 205, identifier:jump; 206, attribute; 206, 207; 206, 208; 207, identifier:self; 208, identifier:search_width; 209, attribute; 209, 210; 209, 211; 210, identifier:self; 211, identifier:move_radius; 212, if_statement; 212, 213; 212, 218; 212, 390; 213, comparison_operator:is; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:logger; 217, None; 218, block; 218, 219; 218, 240; 218, 247; 218, 253; 218, 274; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:imname; 222, call; 222, 223; 222, 228; 223, attribute; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:os; 226, identifier:path; 227, identifier:join; 228, argument_list; 228, 229; 228, 234; 229, attribute; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:self; 232, identifier:logger; 233, identifier:folder; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, string:'{}.png'; 237, identifier:format; 238, argument_list; 238, 239; 239, identifier:agent_vars; 240, expression_statement; 240, 241; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:plt; 244, identifier:savefig; 245, argument_list; 245, 246; 246, identifier:imname; 247, expression_statement; 247, 248; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:plt; 251, identifier:close; 252, argument_list; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:fname; 256, call; 256, 257; 256, 262; 257, attribute; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:os; 260, identifier:path; 261, identifier:join; 262, argument_list; 262, 263; 262, 268; 263, attribute; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:self; 266, identifier:logger; 267, identifier:folder; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, string:'{}.txt'; 271, identifier:format; 272, argument_list; 272, 273; 273, identifier:agent_vars; 274, with_statement; 274, 275; 274, 285; 275, with_clause; 275, 276; 276, with_item; 276, 277; 277, as_pattern; 277, 278; 277, 283; 278, call; 278, 279; 278, 280; 279, identifier:open; 280, argument_list; 280, 281; 280, 282; 281, identifier:fname; 282, string:"w"; 283, as_pattern_target; 283, 284; 284, identifier:f; 285, block; 285, 286; 285, 305; 285, 312; 285, 331; 285, 338; 285, 357; 285, 364; 285, 383; 286, expression_statement; 286, 287; 287, call; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:f; 290, identifier:write; 291, argument_list; 291, 292; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, string:" "; 295, identifier:join; 296, argument_list; 296, 297; 297, list_comprehension; 297, 298; 297, 302; 298, call; 298, 299; 298, 300; 299, identifier:str; 300, argument_list; 300, 301; 301, identifier:e; 302, for_in_clause; 302, 303; 302, 304; 303, identifier:e; 304, identifier:xs; 305, expression_statement; 305, 306; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:f; 309, identifier:write; 310, argument_list; 310, 311; 311, string:"\n"; 312, expression_statement; 312, 313; 313, call; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:f; 316, identifier:write; 317, argument_list; 317, 318; 318, call; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, string:" "; 321, identifier:join; 322, argument_list; 322, 323; 323, list_comprehension; 323, 324; 323, 328; 324, call; 324, 325; 324, 326; 325, identifier:str; 326, argument_list; 326, 327; 327, identifier:e; 328, for_in_clause; 328, 329; 328, 330; 329, identifier:e; 330, identifier:ys; 331, expression_statement; 331, 332; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:f; 335, identifier:write; 336, argument_list; 336, 337; 337, string:"\n"; 338, expression_statement; 338, 339; 339, call; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, identifier:f; 342, identifier:write; 343, argument_list; 343, 344; 344, call; 344, 345; 344, 348; 345, attribute; 345, 346; 345, 347; 346, string:" "; 347, identifier:join; 348, argument_list; 348, 349; 349, list_comprehension; 349, 350; 349, 354; 350, call; 350, 351; 350, 352; 351, identifier:str; 352, argument_list; 352, 353; 353, identifier:e; 354, for_in_clause; 354, 355; 354, 356; 355, identifier:e; 356, identifier:x; 357, expression_statement; 357, 358; 358, call; 358, 359; 358, 362; 359, attribute; 359, 360; 359, 361; 360, identifier:f; 361, identifier:write; 362, argument_list; 362, 363; 363, string:"\n"; 364, expression_statement; 364, 365; 365, call; 365, 366; 365, 369; 366, attribute; 366, 367; 366, 368; 367, identifier:f; 368, identifier:write; 369, argument_list; 369, 370; 370, call; 370, 371; 370, 374; 371, attribute; 371, 372; 371, 373; 372, string:" "; 373, identifier:join; 374, argument_list; 374, 375; 375, list_comprehension; 375, 376; 375, 380; 376, call; 376, 377; 376, 378; 377, identifier:str; 378, argument_list; 378, 379; 379, identifier:e; 380, for_in_clause; 380, 381; 380, 382; 381, identifier:e; 382, identifier:y; 383, expression_statement; 383, 384; 384, call; 384, 385; 384, 388; 385, attribute; 385, 386; 385, 387; 386, identifier:f; 387, identifier:write; 388, argument_list; 388, 389; 389, string:"\n"; 390, else_clause; 390, 391; 391, block; 391, 392; 392, expression_statement; 392, 393; 393, call; 393, 394; 393, 397; 394, attribute; 394, 395; 394, 396; 395, identifier:plt; 396, identifier:show; 397, argument_list | def plot_places(self):
'''Plot places where the agent has been and generated a spirograph.
'''
from matplotlib import pyplot as plt
fig, ax = plt.subplots()
x = []
y = []
if len(self.arg_history) > 1:
xs = []
ys = []
for p in self.arg_history:
xs.append(p[0])
ys.append(p[1])
ax.plot(xs, ys, color=(0.0, 0.0, 1.0, 0.1))
for a in self.A:
if a.self_criticism == 'pass':
args = a.framings[a.creator]['args']
x.append(args[0])
y.append(args[1])
sc = ax.scatter(x, y, marker="x", color='red')
ax.set_xlim([-200, 200])
ax.set_ylim([-200, 200])
agent_vars = "{}_{}_{}{}_last={}_stmem=list{}_veto={}_sc={}_jump={}_sw={}_mr={}_maxN".format(
self.name, self.age, self.env_learning_method, self.env_learning_amount, self.env_learn_on_add,
self.stmem.length, self._novelty_threshold, self._own_threshold,
self.jump, self.search_width, self.move_radius)
if self.logger is not None:
imname = os.path.join(self.logger.folder, '{}.png'.format(agent_vars))
plt.savefig(imname)
plt.close()
fname = os.path.join(self.logger.folder, '{}.txt'.format(agent_vars))
with open(fname, "w") as f:
f.write(" ".join([str(e) for e in xs]))
f.write("\n")
f.write(" ".join([str(e) for e in ys]))
f.write("\n")
f.write(" ".join([str(e) for e in x]))
f.write("\n")
f.write(" ".join([str(e) for e in y]))
f.write("\n")
else:
plt.show() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:df; 3, parameters; 3, 4; 4, default_parameter; 4, 5; 4, 6; 5, identifier:unit; 6, string:'GB'; 7, block; 7, 8; 7, 10; 7, 14; 7, 25; 7, 32; 7, 38; 7, 56; 7, 66; 7, 75; 7, 101; 7, 112; 7, 130; 7, 317; 8, expression_statement; 8, 9; 9, string:'''A wrapper for the df shell command.'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:details; 13, dictionary; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:headers; 17, list:['Filesystem', 'Type', 'Size', 'Used', 'Available', 'Capacity', 'MountedOn']; 17, 18; 17, 19; 17, 20; 17, 21; 17, 22; 17, 23; 17, 24; 18, string:'Filesystem'; 19, string:'Type'; 20, string:'Size'; 21, string:'Used'; 22, string:'Available'; 23, string:'Capacity'; 24, string:'MountedOn'; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:n; 28, call; 28, 29; 28, 30; 29, identifier:len; 30, argument_list; 30, 31; 31, identifier:headers; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:unit; 35, subscript; 35, 36; 35, 37; 36, identifier:df_conversions; 37, identifier:unit; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:p; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:subprocess; 44, identifier:Popen; 45, argument_list; 45, 46; 45, 51; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:args; 48, list:['df', '-TP']; 48, 49; 48, 50; 49, string:'df'; 50, string:'-TP'; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:stdout; 53, attribute; 53, 54; 53, 55; 54, identifier:subprocess; 55, identifier:PIPE; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 61; 58, pattern_list; 58, 59; 58, 60; 59, identifier:stdout; 60, identifier:stderr; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:p; 64, identifier:communicate; 65, argument_list; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:lines; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:stdout; 72, identifier:split; 73, argument_list; 73, 74; 74, string:"\n"; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:lines; 79, integer:0; 80, call; 80, 81; 80, 98; 81, attribute; 81, 82; 81, 97; 82, call; 82, 83; 82, 94; 83, attribute; 83, 84; 83, 93; 84, call; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:lines; 88, integer:0; 89, identifier:replace; 90, argument_list; 90, 91; 90, 92; 91, string:"Mounted on"; 92, string:"MountedOn"; 93, identifier:replace; 94, argument_list; 94, 95; 94, 96; 95, string:"1K-blocks"; 96, string:"Size"; 97, identifier:replace; 98, argument_list; 98, 99; 98, 100; 99, string:"1024-blocks"; 100, string:"Size"; 101, assert_statement; 101, 102; 102, parenthesized_expression; 102, 103; 103, comparison_operator:==; 103, 104; 103, 111; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:lines; 108, integer:0; 109, identifier:split; 110, argument_list; 111, identifier:headers; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:lines; 115, list_comprehension; 115, 116; 115, 121; 115, 124; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:l; 119, identifier:strip; 120, argument_list; 121, for_in_clause; 121, 122; 121, 123; 122, identifier:l; 123, identifier:lines; 124, if_clause; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:l; 128, identifier:strip; 129, argument_list; 130, for_statement; 130, 131; 130, 132; 130, 137; 131, identifier:line; 132, subscript; 132, 133; 132, 134; 133, identifier:lines; 134, slice; 134, 135; 134, 136; 135, integer:1; 136, colon; 137, block; 137, 138; 137, 146; 137, 154; 137, 162; 137, 166; 137, 187; 137, 200; 137, 210; 137, 218; 137, 231; 137, 244; 137, 259; 137, 309; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:tokens; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:line; 144, identifier:split; 145, argument_list; 146, if_statement; 146, 147; 146, 152; 147, comparison_operator:==; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:tokens; 150, integer:0; 151, string:'none'; 152, block; 152, 153; 153, continue_statement; 154, assert_statement; 154, 155; 155, parenthesized_expression; 155, 156; 156, comparison_operator:==; 156, 157; 156, 161; 157, call; 157, 158; 157, 159; 158, identifier:len; 159, argument_list; 159, 160; 160, identifier:tokens; 161, identifier:n; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:d; 165, dictionary; 166, for_statement; 166, 167; 166, 168; 166, 176; 167, identifier:x; 168, call; 168, 169; 168, 170; 169, identifier:range; 170, argument_list; 170, 171; 170, 172; 171, integer:1; 172, call; 172, 173; 172, 174; 173, identifier:len; 174, argument_list; 174, 175; 175, identifier:headers; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 184; 179, subscript; 179, 180; 179, 181; 180, identifier:d; 181, subscript; 181, 182; 181, 183; 182, identifier:headers; 183, identifier:x; 184, subscript; 184, 185; 184, 186; 185, identifier:tokens; 186, identifier:x; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 192; 189, subscript; 189, 190; 189, 191; 190, identifier:d; 191, string:'Size'; 192, binary_operator:/; 192, 193; 192, 199; 193, call; 193, 194; 193, 195; 194, identifier:float; 195, argument_list; 195, 196; 196, subscript; 196, 197; 196, 198; 197, identifier:d; 198, string:'Size'; 199, identifier:unit; 200, assert_statement; 200, 201; 201, parenthesized_expression; 201, 202; 202, call; 202, 203; 202, 208; 203, attribute; 203, 204; 203, 207; 204, subscript; 204, 205; 204, 206; 205, identifier:d; 206, string:'Capacity'; 207, identifier:endswith; 208, argument_list; 208, 209; 209, string:"%"; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 215; 212, subscript; 212, 213; 212, 214; 213, identifier:d; 214, string:'Use%'; 215, subscript; 215, 216; 215, 217; 216, identifier:d; 217, string:'Capacity'; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:d; 222, string:'Used'; 223, binary_operator:/; 223, 224; 223, 230; 224, call; 224, 225; 224, 226; 225, identifier:float; 226, argument_list; 226, 227; 227, subscript; 227, 228; 227, 229; 228, identifier:d; 229, string:'Used'; 230, identifier:unit; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 236; 233, subscript; 233, 234; 233, 235; 234, identifier:d; 235, string:'Available'; 236, binary_operator:/; 236, 237; 236, 243; 237, call; 237, 238; 237, 239; 238, identifier:float; 239, argument_list; 239, 240; 240, subscript; 240, 241; 240, 242; 241, identifier:d; 242, string:'Available'; 243, identifier:unit; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 249; 246, subscript; 246, 247; 246, 248; 247, identifier:d; 248, string:'Using'; 249, binary_operator:*; 249, 250; 249, 251; 250, integer:100; 251, parenthesized_expression; 251, 252; 252, binary_operator:/; 252, 253; 252, 256; 253, subscript; 253, 254; 253, 255; 254, identifier:d; 255, string:'Used'; 256, subscript; 256, 257; 256, 258; 257, identifier:d; 258, string:'Size'; 259, if_statement; 259, 260; 259, 268; 259, 276; 260, call; 260, 261; 260, 266; 261, attribute; 261, 262; 261, 265; 262, subscript; 262, 263; 262, 264; 263, identifier:d; 264, string:'Type'; 265, identifier:startswith; 266, argument_list; 266, 267; 267, string:'ext'; 268, block; 268, 269; 268, 270; 269, pass_statement; 270, expression_statement; 270, 271; 271, augmented_assignment:+=; 271, 272; 271, 275; 272, subscript; 272, 273; 272, 274; 273, identifier:d; 274, string:'Using'; 275, integer:5; 276, else_clause; 276, 277; 277, block; 277, 278; 277, 285; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:ext3_filesystems; 281, list:['ganon:', 'kortemmelab:', 'albana:']; 281, 282; 281, 283; 281, 284; 282, string:'ganon:'; 283, string:'kortemmelab:'; 284, string:'albana:'; 285, for_statement; 285, 286; 285, 287; 285, 288; 286, identifier:e3fs; 287, identifier:ext3_filesystems; 288, block; 288, 289; 289, if_statement; 289, 290; 289, 301; 290, comparison_operator:!=; 290, 291; 290, 299; 291, call; 291, 292; 291, 297; 292, attribute; 292, 293; 292, 296; 293, subscript; 293, 294; 293, 295; 294, identifier:tokens; 295, integer:0; 296, identifier:find; 297, argument_list; 297, 298; 298, identifier:e3fs; 299, unary_operator:-; 299, 300; 300, integer:1; 301, block; 301, 302; 301, 308; 302, expression_statement; 302, 303; 303, augmented_assignment:+=; 303, 304; 303, 307; 304, subscript; 304, 305; 304, 306; 305, identifier:d; 306, string:'Using'; 307, integer:5; 308, break_statement; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 316; 311, subscript; 311, 312; 311, 313; 312, identifier:details; 313, subscript; 313, 314; 313, 315; 314, identifier:tokens; 315, integer:0; 316, identifier:d; 317, return_statement; 317, 318; 318, identifier:details | def df(unit = 'GB'):
'''A wrapper for the df shell command.'''
details = {}
headers = ['Filesystem', 'Type', 'Size', 'Used', 'Available', 'Capacity', 'MountedOn']
n = len(headers)
unit = df_conversions[unit]
p = subprocess.Popen(args = ['df', '-TP'], stdout = subprocess.PIPE)
stdout, stderr = p.communicate()
lines = stdout.split("\n")
lines[0] = lines[0].replace("Mounted on", "MountedOn").replace("1K-blocks", "Size").replace("1024-blocks", "Size")
assert(lines[0].split() == headers)
lines = [l.strip() for l in lines if l.strip()]
for line in lines[1:]:
tokens = line.split()
if tokens[0] == 'none':
continue
assert(len(tokens) == n)
d = {}
for x in range(1, len(headers)):
d[headers[x]] = tokens[x]
d['Size'] = float(d['Size']) / unit
assert(d['Capacity'].endswith("%"))
d['Use%'] = d['Capacity']
d['Used'] = float(d['Used']) / unit
d['Available'] = float(d['Available']) / unit
d['Using'] = 100*(d['Used']/d['Size'])
if d['Type'].startswith('ext'):
pass
d['Using'] += 5
else:
ext3_filesystems = ['ganon:', 'kortemmelab:', 'albana:']
for e3fs in ext3_filesystems:
if tokens[0].find(e3fs) != -1:
d['Using'] += 5
break
details[tokens[0]] = d
return details |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:vote_mean; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:candidates; 5, identifier:votes; 6, identifier:n_winners; 7, block; 7, 8; 7, 21; 7, 45; 7, 67; 7, 78; 7, 95; 7, 110; 7, 114; 7, 143; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:sums; 11, dictionary_comprehension; 11, 12; 11, 18; 12, pair; 12, 13; 12, 17; 13, call; 13, 14; 13, 15; 14, identifier:str; 15, argument_list; 15, 16; 16, identifier:candidate; 17, list:[]; 18, for_in_clause; 18, 19; 18, 20; 19, identifier:candidate; 20, identifier:candidates; 21, for_statement; 21, 22; 21, 23; 21, 24; 22, identifier:vote; 23, identifier:votes; 24, block; 24, 25; 25, for_statement; 25, 26; 25, 27; 25, 28; 26, identifier:v; 27, identifier:vote; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 41; 31, attribute; 31, 32; 31, 40; 32, subscript; 32, 33; 32, 34; 33, identifier:sums; 34, call; 34, 35; 34, 36; 35, identifier:str; 36, argument_list; 36, 37; 37, subscript; 37, 38; 37, 39; 38, identifier:v; 39, integer:0; 40, identifier:append; 41, argument_list; 41, 42; 42, subscript; 42, 43; 42, 44; 43, identifier:v; 44, integer:1; 45, for_statement; 45, 46; 45, 47; 45, 48; 46, identifier:s; 47, identifier:sums; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 54; 51, subscript; 51, 52; 51, 53; 52, identifier:sums; 53, identifier:s; 54, binary_operator:/; 54, 55; 54, 61; 55, call; 55, 56; 55, 57; 56, identifier:sum; 57, argument_list; 57, 58; 58, subscript; 58, 59; 58, 60; 59, identifier:sums; 60, identifier:s; 61, call; 61, 62; 61, 63; 62, identifier:len; 63, argument_list; 63, 64; 64, subscript; 64, 65; 64, 66; 65, identifier:sums; 66, identifier:s; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:ordering; 70, call; 70, 71; 70, 72; 71, identifier:list; 72, argument_list; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:sums; 76, identifier:items; 77, argument_list; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:ordering; 82, identifier:sort; 83, argument_list; 83, 84; 83, 92; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:key; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:operator; 89, identifier:itemgetter; 90, argument_list; 90, 91; 91, integer:1; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:reverse; 94, True; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:best; 98, subscript; 98, 99; 98, 100; 99, identifier:ordering; 100, slice; 100, 101; 100, 102; 101, colon; 102, call; 102, 103; 102, 104; 103, identifier:min; 104, argument_list; 104, 105; 104, 106; 105, identifier:n_winners; 106, call; 106, 107; 106, 108; 107, identifier:len; 108, argument_list; 108, 109; 109, identifier:ordering; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:d; 113, list:[]; 114, for_statement; 114, 115; 114, 116; 114, 117; 115, identifier:e; 116, identifier:best; 117, block; 117, 118; 118, for_statement; 118, 119; 118, 120; 118, 121; 119, identifier:c; 120, identifier:candidates; 121, block; 121, 122; 122, if_statement; 122, 123; 122, 131; 123, comparison_operator:==; 123, 124; 123, 128; 124, call; 124, 125; 124, 126; 125, identifier:str; 126, argument_list; 126, 127; 127, identifier:c; 128, subscript; 128, 129; 128, 130; 129, identifier:e; 130, integer:0; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:d; 136, identifier:append; 137, argument_list; 137, 138; 138, tuple; 138, 139; 138, 140; 139, identifier:c; 140, subscript; 140, 141; 140, 142; 141, identifier:e; 142, integer:1; 143, return_statement; 143, 144; 144, identifier:d | def vote_mean(candidates, votes, n_winners):
sums = {str(candidate): [] for candidate in candidates}
for vote in votes:
for v in vote:
sums[str(v[0])].append(v[1])
for s in sums:
sums[s] = sum(sums[s]) / len(sums[s])
ordering = list(sums.items())
ordering.sort(key=operator.itemgetter(1), reverse=True)
best = ordering[:min(n_winners, len(ordering))]
d = []
for e in best:
for c in candidates:
if str(c) == e[0]:
d.append((c, e[1]))
return d |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:vote; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:candidates; 6, block; 6, 7; 6, 24; 6, 41; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:ranks; 10, list_comprehension; 10, 11; 10, 21; 11, tuple; 11, 12; 11, 13; 12, identifier:c; 13, subscript; 13, 14; 13, 20; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:evaluate; 18, argument_list; 18, 19; 19, identifier:c; 20, integer:0; 21, for_in_clause; 21, 22; 21, 23; 22, identifier:c; 23, identifier:candidates; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:ranks; 28, identifier:sort; 29, argument_list; 29, 30; 29, 38; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:key; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:operator; 35, identifier:itemgetter; 36, argument_list; 36, 37; 37, integer:1; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:reverse; 40, True; 41, return_statement; 41, 42; 42, identifier:ranks | def vote(self, candidates):
ranks = [(c, self.evaluate(c)[0]) for c in candidates]
ranks.sort(key=operator.itemgetter(1), reverse=True)
return ranks |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:gather_votes; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:candidates; 6, block; 6, 7; 6, 11; 6, 38; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:votes; 10, list:[]; 11, for_statement; 11, 12; 11, 13; 11, 21; 12, identifier:a; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:get_agents; 17, argument_list; 17, 18; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:addr; 20, False; 21, block; 21, 22; 21, 31; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:vote; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:a; 28, identifier:vote; 29, argument_list; 29, 30; 30, identifier:candidates; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:votes; 35, identifier:append; 36, argument_list; 36, 37; 37, identifier:vote; 38, return_statement; 38, 39; 39, identifier:votes | def gather_votes(self, candidates):
votes = []
for a in self.get_agents(addr=False):
vote = a.vote(candidates)
votes.append(vote)
return votes |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:install_dependencies; 3, parameters; 3, 4; 4, default_parameter; 4, 5; 4, 6; 5, identifier:feature; 6, None; 7, block; 7, 8; 7, 11; 7, 19; 7, 29; 7, 49; 7, 106; 7, 116; 7, 128; 7, 159; 7, 168; 7, 176; 7, 191; 7, 207; 7, 344; 8, import_statement; 8, 9; 9, dotted_name; 9, 10; 10, identifier:subprocess; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:echo; 14, argument_list; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:green; 17, argument_list; 17, 18; 18, string:'\nInstall dependencies:'; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:echo; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:green; 25, argument_list; 25, 26; 26, binary_operator:*; 26, 27; 26, 28; 27, string:'-'; 28, integer:40; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:req_path; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:os; 36, identifier:path; 37, identifier:realpath; 38, argument_list; 38, 39; 39, binary_operator:+; 39, 40; 39, 48; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:os; 44, identifier:path; 45, identifier:dirname; 46, argument_list; 46, 47; 47, identifier:__file__; 48, string:'/../_requirements'; 49, if_statement; 49, 50; 49, 52; 50, not_operator; 50, 51; 51, identifier:feature; 52, block; 52, 53; 52, 61; 52, 101; 52, 105; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:echo; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:yellow; 59, argument_list; 59, 60; 60, string:'Please specify a feature to install. \n'; 61, for_statement; 61, 62; 61, 65; 61, 74; 62, pattern_list; 62, 63; 62, 64; 63, identifier:index; 64, identifier:item; 65, call; 65, 66; 65, 67; 66, identifier:enumerate; 67, argument_list; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:os; 71, identifier:listdir; 72, argument_list; 72, 73; 73, identifier:req_path; 74, block; 74, 75; 74, 85; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:item; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:item; 81, identifier:replace; 82, argument_list; 82, 83; 82, 84; 83, string:'.txt'; 84, string:''; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:echo; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:green; 91, argument_list; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, string:'{}. {}'; 95, identifier:format; 96, argument_list; 96, 97; 96, 100; 97, binary_operator:+; 97, 98; 97, 99; 98, identifier:index; 99, integer:1; 100, identifier:item; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 104; 103, identifier:echo; 104, argument_list; 105, return_statement; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:feature_file; 109, binary_operator:+; 109, 110; 109, 115; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:feature; 113, identifier:lower; 114, argument_list; 115, string:'.txt'; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:feature_reqs; 119, call; 119, 120; 119, 125; 120, attribute; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:os; 123, identifier:path; 124, identifier:join; 125, argument_list; 125, 126; 125, 127; 126, identifier:req_path; 127, identifier:feature_file; 128, if_statement; 128, 129; 128, 138; 129, not_operator; 129, 130; 130, call; 130, 131; 130, 136; 131, attribute; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:os; 134, identifier:path; 135, identifier:isfile; 136, argument_list; 136, 137; 137, identifier:feature_reqs; 138, block; 138, 139; 138, 143; 138, 158; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:msg; 142, string:'Unable to locate feature requirements file [{}]'; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 146; 145, identifier:echo; 146, argument_list; 146, 147; 147, binary_operator:+; 147, 148; 147, 157; 148, call; 148, 149; 148, 150; 149, identifier:red; 150, argument_list; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:msg; 154, identifier:format; 155, argument_list; 155, 156; 156, identifier:feature_file; 157, string:'\n'; 158, return_statement; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:msg; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, string:'Now installing dependencies for "{}" feature...'; 165, identifier:format; 166, argument_list; 166, 167; 167, identifier:feature; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:echo; 171, argument_list; 171, 172; 172, call; 172, 173; 172, 174; 173, identifier:yellow; 174, argument_list; 174, 175; 175, identifier:msg; 176, expression_statement; 176, 177; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:subprocess; 180, identifier:check_call; 181, argument_list; 181, 182; 182, list:[
sys.executable, '-m', 'pip', 'install', '-r', feature_reqs]; 182, 183; 182, 186; 182, 187; 182, 188; 182, 189; 182, 190; 183, attribute; 183, 184; 183, 185; 184, identifier:sys; 185, identifier:executable; 186, string:'-m'; 187, string:'pip'; 188, string:'install'; 189, string:'-r'; 190, identifier:feature_reqs; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:reqs; 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, 206; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:os; 204, identifier:getcwd; 205, argument_list; 206, string:'requirements.txt'; 207, if_statement; 207, 208; 207, 216; 208, call; 208, 209; 208, 214; 209, attribute; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:os; 212, identifier:path; 213, identifier:exists; 214, argument_list; 214, 215; 215, identifier:reqs; 216, block; 216, 217; 216, 253; 216, 258; 216, 325; 217, with_statement; 217, 218; 217, 227; 218, with_clause; 218, 219; 219, with_item; 219, 220; 220, as_pattern; 220, 221; 220, 225; 221, call; 221, 222; 221, 223; 222, identifier:open; 223, argument_list; 223, 224; 224, identifier:reqs; 225, as_pattern_target; 225, 226; 226, identifier:file; 227, block; 227, 228; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:existing; 231, list_comprehension; 231, 232; 231, 244; 231, 251; 232, subscript; 232, 233; 232, 243; 233, call; 233, 234; 233, 241; 234, attribute; 234, 235; 234, 240; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:x; 238, identifier:strip; 239, argument_list; 240, identifier:split; 241, argument_list; 241, 242; 242, string:'=='; 243, integer:0; 244, for_in_clause; 244, 245; 244, 246; 245, identifier:x; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:file; 249, identifier:readlines; 250, argument_list; 251, if_clause; 251, 252; 252, identifier:x; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:lines; 256, list:['\n']; 256, 257; 257, string:'\n'; 258, with_statement; 258, 259; 258, 268; 259, with_clause; 259, 260; 260, with_item; 260, 261; 261, as_pattern; 261, 262; 261, 266; 262, call; 262, 263; 262, 264; 263, identifier:open; 264, argument_list; 264, 265; 265, identifier:feature_reqs; 266, as_pattern_target; 266, 267; 267, identifier:file; 268, block; 268, 269; 268, 277; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:incoming; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:file; 275, identifier:readlines; 276, argument_list; 277, for_statement; 277, 278; 277, 279; 277, 280; 278, identifier:line; 279, identifier:incoming; 280, block; 280, 281; 281, if_statement; 281, 282; 281, 292; 281, 317; 282, boolean_operator:or; 282, 283; 282, 289; 283, not_operator; 283, 284; 284, parenthesized_expression; 284, 285; 285, call; 285, 286; 285, 287; 286, identifier:len; 287, argument_list; 287, 288; 288, identifier:line; 289, attribute; 289, 290; 289, 291; 290, identifier:line; 291, identifier:startswith; 292, ERROR; 292, 293; 292, 301; 292, 302; 292, 314; 293, ERROR; 293, 294; 293, 300; 294, call; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:lines; 297, identifier:append; 298, argument_list; 298, 299; 299, identifier:line; 300, identifier:continue; 301, identifier:package; 302, subscript; 302, 303; 302, 313; 303, call; 303, 304; 303, 311; 304, attribute; 304, 305; 304, 310; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:line; 308, identifier:strip; 309, argument_list; 310, identifier:split; 311, argument_list; 311, 312; 312, string:'=='; 313, integer:0; 314, comparison_operator:not; 314, 315; 314, 316; 315, identifier:package; 316, identifier:existing; 317, block; 317, 318; 318, expression_statement; 318, 319; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:lines; 322, identifier:append; 323, argument_list; 323, 324; 324, identifier:line; 325, with_statement; 325, 326; 325, 336; 326, with_clause; 326, 327; 327, with_item; 327, 328; 328, as_pattern; 328, 329; 328, 334; 329, call; 329, 330; 329, 331; 330, identifier:open; 331, argument_list; 331, 332; 331, 333; 332, identifier:reqs; 333, string:'a'; 334, as_pattern_target; 334, 335; 335, identifier:file; 336, block; 336, 337; 337, expression_statement; 337, 338; 338, call; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, identifier:file; 341, identifier:writelines; 342, argument_list; 342, 343; 343, identifier:lines; 344, expression_statement; 344, 345; 345, call; 345, 346; 345, 347; 346, identifier:echo; 347, argument_list; 347, 348; 348, call; 348, 349; 348, 350; 349, identifier:green; 350, argument_list; 350, 351; 351, string:'DONE\n' | def install_dependencies(feature=None):
import subprocess
echo(green('\nInstall dependencies:'))
echo(green('-' * 40))
req_path = os.path.realpath(os.path.dirname(__file__) + '/../_requirements')
if not feature:
echo(yellow('Please specify a feature to install. \n'))
for index, item in enumerate(os.listdir(req_path)):
item = item.replace('.txt', '')
echo(green('{}. {}'.format(index + 1, item)))
echo()
return
feature_file = feature.lower() + '.txt'
feature_reqs = os.path.join(req_path, feature_file)
if not os.path.isfile(feature_reqs):
msg = 'Unable to locate feature requirements file [{}]'
echo(red(msg.format(feature_file)) + '\n')
return
msg = 'Now installing dependencies for "{}" feature...'.format(feature)
echo(yellow(msg))
subprocess.check_call([
sys.executable, '-m', 'pip', 'install', '-r', feature_reqs]
)
reqs = os.path.join(os.getcwd(), 'requirements.txt')
if os.path.exists(reqs):
with open(reqs) as file:
existing = [x.strip().split('==')[0] for x in file.readlines() if x]
lines = ['\n']
with open(feature_reqs) as file:
incoming = file.readlines()
for line in incoming:
if not(len(line)) or line.startswith('
lines.append(line)
continue
package = line.strip().split('==')[0]
if package not in existing:
lines.append(line)
with open(reqs, 'a') as file:
file.writelines(lines)
echo(green('DONE\n')) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:resolve_handler; 3, parameters; 3, 4; 3, 5; 4, identifier:request; 5, identifier:view_handlers; 6, block; 6, 7; 6, 11; 6, 50; 6, 57; 6, 63; 6, 69; 6, 135; 6, 141; 6, 147; 6, 176; 6, 199; 6, 205; 6, 222; 6, 233; 6, 250; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:view; 10, None; 11, if_statement; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:request; 14, identifier:_context; 15, block; 15, 16; 15, 29; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:route_name; 19, attribute; 19, 20; 19, 28; 20, attribute; 20, 21; 20, 27; 21, subscript; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:request; 24, identifier:_context; 25, unary_operator:-; 25, 26; 26, integer:1; 27, identifier:route; 28, identifier:name; 29, if_statement; 29, 30; 29, 35; 30, boolean_operator:and; 30, 31; 30, 32; 31, identifier:route_name; 32, comparison_operator:in; 32, 33; 32, 34; 33, identifier:VIEW_SEPARATOR; 34, identifier:route_name; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:view; 39, boolean_operator:or; 39, 40; 39, 49; 40, subscript; 40, 41; 40, 48; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:route_name; 44, identifier:split; 45, argument_list; 45, 46; 45, 47; 46, identifier:VIEW_SEPARATOR; 47, integer:1; 48, integer:1; 49, None; 50, if_statement; 50, 51; 50, 54; 51, comparison_operator:not; 51, 52; 51, 53; 52, identifier:view; 53, identifier:view_handlers; 54, block; 54, 55; 55, raise_statement; 55, 56; 56, identifier:NotFound; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:method_handlers; 60, subscript; 60, 61; 60, 62; 61, identifier:view_handlers; 62, identifier:view; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:verb; 66, attribute; 66, 67; 66, 68; 67, identifier:request; 68, identifier:method; 69, if_statement; 69, 70; 69, 73; 70, comparison_operator:not; 70, 71; 70, 72; 71, identifier:verb; 72, identifier:method_handlers; 73, block; 73, 74; 74, if_statement; 74, 75; 74, 82; 74, 87; 75, boolean_operator:and; 75, 76; 75, 79; 76, comparison_operator:==; 76, 77; 76, 78; 77, identifier:verb; 78, string:'HEAD'; 79, comparison_operator:in; 79, 80; 79, 81; 80, string:'GET'; 81, identifier:method_handlers; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:verb; 86, string:'GET'; 87, else_clause; 87, 88; 88, block; 88, 89; 88, 100; 88, 116; 88, 128; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:allowed_methods; 92, call; 92, 93; 92, 94; 93, identifier:set; 94, argument_list; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:method_handlers; 98, identifier:keys; 99, argument_list; 100, if_statement; 100, 101; 100, 108; 101, boolean_operator:and; 101, 102; 101, 105; 102, comparison_operator:not; 102, 103; 102, 104; 103, string:'HEAD'; 104, identifier:allowed_methods; 105, comparison_operator:in; 105, 106; 105, 107; 106, string:'GET'; 107, identifier:allowed_methods; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:allowed_methods; 113, identifier:add; 114, argument_list; 114, 115; 115, string:'HEAD'; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:allow; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, string:', '; 122, identifier:join; 123, argument_list; 123, 124; 124, call; 124, 125; 124, 126; 125, identifier:sorted; 126, argument_list; 126, 127; 127, identifier:allowed_methods; 128, raise_statement; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:MethodNotAllowed; 131, argument_list; 131, 132; 132, keyword_argument; 132, 133; 132, 134; 133, identifier:allow; 134, identifier:allow; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:handlers; 138, subscript; 138, 139; 138, 140; 139, identifier:method_handlers; 140, identifier:verb; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:vary; 144, call; 144, 145; 144, 146; 145, identifier:set; 146, argument_list; 147, if_statement; 147, 148; 147, 168; 148, comparison_operator:>; 148, 149; 148, 167; 149, call; 149, 150; 149, 151; 150, identifier:len; 151, argument_list; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:set; 154, generator_expression; 154, 155; 154, 158; 154, 161; 155, attribute; 155, 156; 155, 157; 156, identifier:h; 157, identifier:provides; 158, for_in_clause; 158, 159; 158, 160; 159, identifier:h; 160, identifier:handlers; 161, if_clause; 161, 162; 162, comparison_operator:is; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:h; 165, identifier:provides; 166, None; 167, integer:1; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:vary; 173, identifier:add; 174, argument_list; 174, 175; 175, string:'Accept'; 176, if_statement; 176, 177; 176, 191; 177, comparison_operator:>; 177, 178; 177, 190; 178, call; 178, 179; 178, 180; 179, identifier:len; 180, argument_list; 180, 181; 181, call; 181, 182; 181, 183; 182, identifier:set; 183, generator_expression; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:h; 186, identifier:accepts; 187, for_in_clause; 187, 188; 187, 189; 188, identifier:h; 189, identifier:handlers; 190, integer:1; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:vary; 196, identifier:add; 197, argument_list; 197, 198; 198, string:'Content-Type'; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:content_type; 202, attribute; 202, 203; 202, 204; 203, identifier:request; 204, identifier:content_type; 205, if_statement; 205, 206; 205, 207; 206, identifier:content_type; 207, block; 207, 208; 207, 216; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:handlers; 211, call; 211, 212; 211, 213; 212, identifier:negotiate_content_type; 213, argument_list; 213, 214; 213, 215; 214, identifier:content_type; 215, identifier:handlers; 216, if_statement; 216, 217; 216, 219; 217, not_operator; 217, 218; 218, identifier:handlers; 219, block; 219, 220; 220, raise_statement; 220, 221; 221, identifier:UnsupportedMediaType; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:accept; 225, call; 225, 226; 225, 231; 226, attribute; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:request; 229, identifier:headers; 230, identifier:get; 231, argument_list; 231, 232; 232, string:'Accept'; 233, if_statement; 233, 234; 233, 235; 234, identifier:accept; 235, block; 235, 236; 235, 244; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:handlers; 239, call; 239, 240; 239, 241; 240, identifier:negotiate_accept; 241, argument_list; 241, 242; 241, 243; 242, identifier:accept; 243, identifier:handlers; 244, if_statement; 244, 245; 244, 247; 245, not_operator; 245, 246; 246, identifier:handlers; 247, block; 247, 248; 248, raise_statement; 248, 249; 249, identifier:NotAcceptable; 250, return_statement; 250, 251; 251, expression_list; 251, 252; 251, 255; 252, subscript; 252, 253; 252, 254; 253, identifier:handlers; 254, integer:0; 255, identifier:vary | def resolve_handler(request, view_handlers):
view = None
if request._context:
route_name = request._context[-1].route.name
if route_name and VIEW_SEPARATOR in route_name:
view = route_name.split(VIEW_SEPARATOR, 1)[1] or None
if view not in view_handlers:
raise NotFound
method_handlers = view_handlers[view]
verb = request.method
if verb not in method_handlers:
if verb == 'HEAD' and 'GET' in method_handlers:
verb = 'GET'
else:
allowed_methods = set(method_handlers.keys())
if 'HEAD' not in allowed_methods and 'GET' in allowed_methods:
allowed_methods.add('HEAD')
allow = ', '.join(sorted(allowed_methods))
raise MethodNotAllowed(allow=allow)
handlers = method_handlers[verb]
vary = set()
if len(set(h.provides for h in handlers if h.provides is not None)) > 1:
vary.add('Accept')
if len(set(h.accepts for h in handlers)) > 1:
vary.add('Content-Type')
content_type = request.content_type
if content_type:
handlers = negotiate_content_type(content_type, handlers)
if not handlers:
raise UnsupportedMediaType
accept = request.headers.get('Accept')
if accept:
handlers = negotiate_accept(accept, handlers)
if not handlers:
raise NotAcceptable
return handlers[0], vary |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:url_for; 3, parameters; 3, 4; 3, 6; 4, list_splat_pattern; 4, 5; 5, identifier:args; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kw; 8, block; 8, 9; 8, 30; 8, 40; 8, 50; 8, 62; 8, 109; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 15; 11, pattern_list; 11, 12; 11, 13; 11, 14; 12, identifier:self; 13, identifier:target; 14, identifier:args; 15, expression_list; 15, 16; 15, 19; 15, 22; 16, subscript; 16, 17; 16, 18; 17, identifier:args; 18, integer:0; 19, subscript; 19, 20; 19, 21; 20, identifier:args; 21, integer:1; 22, call; 22, 23; 22, 24; 23, identifier:list; 24, argument_list; 24, 25; 25, subscript; 25, 26; 25, 27; 26, identifier:args; 27, slice; 27, 28; 27, 29; 28, integer:2; 29, colon; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:query; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:kw; 36, identifier:pop; 37, argument_list; 37, 38; 37, 39; 38, string:'_query'; 39, None; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:relative; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:kw; 46, identifier:pop; 47, argument_list; 47, 48; 47, 49; 48, string:'_relative'; 49, False; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:url; 53, call; 53, 54; 53, 55; 54, identifier:build_url; 55, argument_list; 55, 56; 55, 59; 55, 60; 55, 61; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_context; 59, identifier:target; 60, identifier:args; 61, identifier:kw; 62, if_statement; 62, 63; 62, 64; 63, identifier:query; 64, block; 64, 65; 64, 83; 64, 92; 64, 101; 65, if_statement; 65, 66; 65, 71; 66, call; 66, 67; 66, 68; 67, identifier:isinstance; 68, argument_list; 68, 69; 68, 70; 69, identifier:query; 70, identifier:dict; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:query; 75, call; 75, 76; 75, 77; 76, identifier:sorted; 77, argument_list; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:query; 81, identifier:items; 82, argument_list; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:query_part; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:urllib; 89, identifier:urlencode; 90, argument_list; 90, 91; 91, identifier:query; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:query_sep; 95, conditional_expression:if; 95, 96; 95, 97; 95, 100; 96, string:'&'; 97, comparison_operator:in; 97, 98; 97, 99; 98, string:'?'; 99, identifier:url; 100, string:'?'; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:url; 104, binary_operator:+; 104, 105; 104, 108; 105, binary_operator:+; 105, 106; 105, 107; 106, identifier:url; 107, identifier:query_sep; 108, identifier:query_part; 109, if_statement; 109, 110; 109, 111; 109, 114; 110, identifier:relative; 111, block; 111, 112; 112, return_statement; 112, 113; 113, identifier:url; 114, else_clause; 114, 115; 115, block; 115, 116; 116, return_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:urlparse; 120, identifier:urljoin; 121, argument_list; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:application_uri; 125, identifier:url | def url_for(*args, **kw):
self, target, args = args[0], args[1], list(args[2:])
query = kw.pop('_query', None)
relative = kw.pop('_relative', False)
url = build_url(self._context, target, args, kw)
if query:
if isinstance(query, dict):
query = sorted(query.items())
query_part = urllib.urlencode(query)
query_sep = '&' if '?' in url else '?'
url = url + query_sep + query_part
if relative:
return url
else:
return urlparse.urljoin(self.application_uri, url) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 35; 2, function_name:execute; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 4, identifier:command; 5, default_parameter; 5, 6; 5, 7; 6, identifier:return_output; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:log_file; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:log_settings; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:error_logfile; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:timeout; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:line_function; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:poll_timing; 25, float:0.01; 26, default_parameter; 26, 27; 26, 28; 27, identifier:logger; 28, None; 29, default_parameter; 29, 30; 29, 31; 30, identifier:working_folder; 31, None; 32, default_parameter; 32, 33; 32, 34; 33, identifier:env; 34, None; 35, block; 35, 36; 35, 40; 35, 66; 35, 128; 35, 141; 35, 149; 35, 166; 35, 173; 35, 179; 35, 187; 35, 197; 35, 205; 35, 222; 35, 230; 35, 234; 35, 243; 35, 254; 35, 272; 35, 299; 35, 415; 35, 425; 35, 435; 35, 448; 35, 490; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:tmp_log; 39, False; 40, if_statement; 40, 41; 40, 42; 40, 52; 41, identifier:log_settings; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:log_folder; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:log_settings; 49, identifier:get; 50, argument_list; 50, 51; 51, string:'LOG_FOLDER'; 52, else_clause; 52, 53; 53, block; 53, 54; 53, 58; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:tmp_log; 57, True; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:log_folder; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:tempfile; 64, identifier:mkdtemp; 65, argument_list; 66, if_statement; 66, 67; 66, 69; 67, not_operator; 67, 68; 68, identifier:log_file; 69, block; 69, 70; 69, 89; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:log_file; 73, call; 73, 74; 73, 79; 74, attribute; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:os; 77, identifier:path; 78, identifier:join; 79, argument_list; 79, 80; 79, 81; 79, 82; 80, identifier:log_folder; 81, string:"commands"; 82, binary_operator:%; 82, 83; 82, 84; 83, string:"execute-command-logfile-%s.log"; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:UUID; 87, identifier:uuid4; 88, argument_list; 89, try_statement; 89, 90; 89, 125; 90, block; 90, 91; 91, if_statement; 91, 92; 91, 109; 92, not_operator; 92, 93; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:os; 97, identifier:path; 98, identifier:isdir; 99, argument_list; 99, 100; 100, call; 100, 101; 100, 106; 101, attribute; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:os; 104, identifier:path; 105, identifier:join; 106, argument_list; 106, 107; 106, 108; 107, identifier:log_folder; 108, string:"commands"; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:os; 114, identifier:makedirs; 115, argument_list; 115, 116; 116, call; 116, 117; 116, 122; 117, attribute; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:os; 120, identifier:path; 121, identifier:join; 122, argument_list; 122, 123; 122, 124; 123, identifier:log_folder; 124, string:"commands"; 125, except_clause; 125, 126; 126, block; 126, 127; 127, pass_statement; 128, if_statement; 128, 129; 128, 131; 129, not_operator; 129, 130; 130, identifier:logger; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:logger; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:logging; 138, identifier:getLogger; 139, argument_list; 139, 140; 140, string:'command_execute'; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:logfile_writer; 144, call; 144, 145; 144, 146; 145, identifier:open; 146, argument_list; 146, 147; 146, 148; 147, identifier:log_file; 148, string:'a'; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:header; 152, binary_operator:%; 152, 153; 152, 154; 153, string:"%s - Executing command (timeout=%s) :\n\t%s\n\n\n"; 154, tuple; 154, 155; 154, 164; 154, 165; 155, call; 155, 156; 155, 163; 156, attribute; 156, 157; 156, 162; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:datetime; 160, identifier:now; 161, argument_list; 162, identifier:isoformat; 163, argument_list; 164, identifier:timeout; 165, identifier:command; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:logfile_writer; 170, identifier:write; 171, argument_list; 171, 172; 172, identifier:header; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:logfile_writer; 177, identifier:flush; 178, argument_list; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:logfile_reader; 182, call; 182, 183; 182, 184; 183, identifier:open; 184, argument_list; 184, 185; 184, 186; 185, identifier:log_file; 186, string:'rb'; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:logfile_reader; 191, identifier:seek; 192, argument_list; 192, 193; 192, 194; 193, integer:0; 194, attribute; 194, 195; 194, 196; 195, identifier:os; 196, identifier:SEEK_END; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:logfile_start_position; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:logfile_reader; 203, identifier:tell; 204, argument_list; 205, if_statement; 205, 206; 205, 207; 205, 216; 206, identifier:error_logfile; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:err_logfile_writer; 211, call; 211, 212; 211, 213; 212, identifier:open; 213, argument_list; 213, 214; 213, 215; 214, identifier:error_logfile; 215, string:'a'; 216, else_clause; 216, 217; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:err_logfile_writer; 221, identifier:logfile_writer; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:start; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:datetime; 228, identifier:now; 229, argument_list; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:timeout_string; 233, string:""; 234, if_statement; 234, 235; 234, 236; 235, identifier:timeout; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:timeout_string; 240, binary_operator:%; 240, 241; 240, 242; 241, string:"(timeout=%s)"; 242, identifier:timeout; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:logger; 247, identifier:info; 248, argument_list; 248, 249; 249, binary_operator:%; 249, 250; 249, 251; 250, string:u"Executing command %s :\n\t\t%s"; 251, tuple; 251, 252; 251, 253; 252, identifier:timeout_string; 253, identifier:command; 254, if_statement; 254, 255; 254, 260; 255, comparison_operator:!=; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:sys; 258, identifier:platform; 259, string:'win32'; 260, block; 260, 261; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:command; 264, binary_operator:%; 264, 265; 264, 266; 265, string:u"exec %s"; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:text_utils; 269, identifier:uni; 270, argument_list; 270, 271; 271, identifier:command; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:process; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:subprocess; 278, identifier:Popen; 279, argument_list; 279, 280; 279, 281; 279, 284; 279, 287; 279, 290; 279, 293; 279, 296; 280, identifier:command; 281, keyword_argument; 281, 282; 281, 283; 282, identifier:stdout; 283, identifier:logfile_writer; 284, keyword_argument; 284, 285; 284, 286; 285, identifier:stderr; 286, identifier:err_logfile_writer; 287, keyword_argument; 287, 288; 287, 289; 288, identifier:bufsize; 289, integer:1; 290, keyword_argument; 290, 291; 290, 292; 291, identifier:shell; 292, True; 293, keyword_argument; 293, 294; 293, 295; 294, identifier:cwd; 295, identifier:working_folder; 296, keyword_argument; 296, 297; 296, 298; 297, identifier:env; 298, identifier:env; 299, while_statement; 299, 300; 299, 307; 300, comparison_operator:==; 300, 301; 300, 306; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:process; 304, identifier:poll; 305, argument_list; 306, None; 307, block; 307, 308; 307, 315; 307, 368; 308, expression_statement; 308, 309; 309, call; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:time; 312, identifier:sleep; 313, argument_list; 313, 314; 314, identifier:poll_timing; 315, if_statement; 315, 316; 315, 319; 316, comparison_operator:!=; 316, 317; 316, 318; 317, identifier:timeout; 318, None; 319, block; 319, 320; 319, 328; 320, expression_statement; 320, 321; 321, assignment; 321, 322; 321, 323; 322, identifier:now; 323, call; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:datetime; 326, identifier:now; 327, argument_list; 328, if_statement; 328, 329; 328, 337; 329, comparison_operator:>; 329, 330; 329, 336; 330, attribute; 330, 331; 330, 335; 331, parenthesized_expression; 331, 332; 332, binary_operator:-; 332, 333; 332, 334; 333, identifier:now; 334, identifier:start; 335, identifier:seconds; 336, identifier:timeout; 337, block; 337, 338; 337, 350; 337, 361; 338, expression_statement; 338, 339; 339, call; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, identifier:os; 342, identifier:kill; 343, argument_list; 343, 344; 343, 347; 344, attribute; 344, 345; 344, 346; 345, identifier:process; 346, identifier:pid; 347, attribute; 347, 348; 347, 349; 348, identifier:signal; 349, identifier:SIGKILL; 350, expression_statement; 350, 351; 351, call; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:os; 354, identifier:waitpid; 355, argument_list; 355, 356; 355, 358; 356, unary_operator:-; 356, 357; 357, integer:1; 358, attribute; 358, 359; 358, 360; 359, identifier:os; 360, identifier:WNOHANG; 361, raise_statement; 361, 362; 362, call; 362, 363; 362, 364; 363, identifier:Exception; 364, argument_list; 364, 365; 365, binary_operator:%; 365, 366; 365, 367; 366, string:"Command execution timed out (took more than %s seconds...)"; 367, identifier:timeout; 368, if_statement; 368, 369; 368, 370; 369, identifier:line_function; 370, block; 370, 371; 370, 388; 371, expression_statement; 371, 372; 372, assignment; 372, 373; 372, 374; 373, identifier:o; 374, call; 374, 375; 374, 387; 375, attribute; 375, 376; 375, 386; 376, call; 376, 377; 376, 380; 377, attribute; 377, 378; 377, 379; 378, identifier:text_utils; 379, identifier:uni; 380, argument_list; 380, 381; 381, call; 381, 382; 381, 385; 382, attribute; 382, 383; 382, 384; 383, identifier:logfile_reader; 384, identifier:readline; 385, argument_list; 386, identifier:rstrip; 387, argument_list; 388, while_statement; 388, 389; 388, 392; 389, comparison_operator:!=; 389, 390; 389, 391; 390, identifier:o; 391, string:''; 392, block; 392, 393; 392, 398; 393, expression_statement; 393, 394; 394, call; 394, 395; 394, 396; 395, identifier:line_function; 396, argument_list; 396, 397; 397, identifier:o; 398, expression_statement; 398, 399; 399, assignment; 399, 400; 399, 401; 400, identifier:o; 401, call; 401, 402; 401, 414; 402, attribute; 402, 403; 402, 413; 403, call; 403, 404; 403, 407; 404, attribute; 404, 405; 404, 406; 405, identifier:text_utils; 406, identifier:uni; 407, argument_list; 407, 408; 408, call; 408, 409; 408, 412; 409, attribute; 409, 410; 409, 411; 410, identifier:logfile_reader; 411, identifier:readline; 412, argument_list; 413, identifier:rstrip; 414, argument_list; 415, if_statement; 415, 416; 415, 418; 416, not_operator; 416, 417; 417, identifier:return_output; 418, block; 418, 419; 419, return_statement; 419, 420; 420, call; 420, 421; 420, 424; 421, attribute; 421, 422; 421, 423; 422, identifier:process; 423, identifier:wait; 424, argument_list; 425, expression_statement; 425, 426; 426, call; 426, 427; 426, 430; 427, attribute; 427, 428; 427, 429; 428, identifier:logfile_reader; 429, identifier:seek; 430, argument_list; 430, 431; 430, 432; 431, identifier:logfile_start_position; 432, attribute; 432, 433; 432, 434; 433, identifier:os; 434, identifier:SEEK_SET; 435, expression_statement; 435, 436; 436, assignment; 436, 437; 436, 438; 437, identifier:res; 438, call; 438, 439; 438, 442; 439, attribute; 439, 440; 439, 441; 440, identifier:text_utils; 441, identifier:uni; 442, argument_list; 442, 443; 443, call; 443, 444; 443, 447; 444, attribute; 444, 445; 444, 446; 445, identifier:logfile_reader; 446, identifier:read; 447, argument_list; 448, try_statement; 448, 449; 448, 481; 449, block; 449, 450; 449, 456; 449, 462; 449, 468; 450, expression_statement; 450, 451; 451, call; 451, 452; 451, 455; 452, attribute; 452, 453; 452, 454; 453, identifier:logfile_reader; 454, identifier:close; 455, argument_list; 456, expression_statement; 456, 457; 457, call; 457, 458; 457, 461; 458, attribute; 458, 459; 458, 460; 459, identifier:logfile_writer; 460, identifier:close; 461, argument_list; 462, expression_statement; 462, 463; 463, call; 463, 464; 463, 467; 464, attribute; 464, 465; 464, 466; 465, identifier:err_logfile_writer; 466, identifier:close; 467, argument_list; 468, if_statement; 468, 469; 468, 470; 469, identifier:tmp_log; 470, block; 470, 471; 471, expression_statement; 471, 472; 472, call; 472, 473; 472, 476; 473, attribute; 473, 474; 473, 475; 474, identifier:shutil; 475, identifier:rmtree; 476, argument_list; 476, 477; 476, 478; 477, identifier:log_folder; 478, keyword_argument; 478, 479; 478, 480; 479, identifier:ignore_errors; 480, True; 481, except_clause; 481, 482; 482, block; 482, 483; 483, expression_statement; 483, 484; 484, call; 484, 485; 484, 488; 485, attribute; 485, 486; 485, 487; 486, identifier:logger; 487, identifier:exception; 488, argument_list; 488, 489; 489, string:"Error while cleaning after tbx.execute() call."; 490, return_statement; 490, 491; 491, identifier:res | def execute(command, return_output=True, log_file=None, log_settings=None, error_logfile=None, timeout=None, line_function=None, poll_timing = 0.01, logger=None, working_folder=None, env=None):
tmp_log = False
if log_settings:
log_folder = log_settings.get('LOG_FOLDER')
else:
tmp_log = True
log_folder = tempfile.mkdtemp()
if not log_file:
log_file = os.path.join(log_folder, "commands", "execute-command-logfile-%s.log" % UUID.uuid4())
try:
if not os.path.isdir(os.path.join(log_folder, "commands")):
os.makedirs(os.path.join(log_folder, "commands"))
except:
pass
if not logger:
logger = logging.getLogger('command_execute')
logfile_writer = open(log_file, 'a')
header = "%s - Executing command (timeout=%s) :\n\t%s\n\n\n" % (datetime.now().isoformat(), timeout, command)
logfile_writer.write(header)
logfile_writer.flush()
logfile_reader = open(log_file, 'rb')
logfile_reader.seek(0, os.SEEK_END)
logfile_start_position = logfile_reader.tell()
if error_logfile:
err_logfile_writer = open(error_logfile, 'a')
else:
err_logfile_writer = logfile_writer
start = datetime.now()
timeout_string = ""
if timeout:
timeout_string = "(timeout=%s)" % timeout
logger.info(u"Executing command %s :\n\t\t%s" % (timeout_string, command) )
if sys.platform != 'win32':
command = u"exec %s" % text_utils.uni(command)
process = subprocess.Popen(command, stdout=logfile_writer, stderr=err_logfile_writer, bufsize=1, shell=True, cwd=working_folder, env=env)
while process.poll() == None:
time.sleep(poll_timing)
if timeout != None:
now = datetime.now()
if (now - start).seconds> timeout:
os.kill(process.pid, signal.SIGKILL)
os.waitpid(-1, os.WNOHANG)
raise Exception("Command execution timed out (took more than %s seconds...)" % timeout)
if line_function:
o = text_utils.uni(logfile_reader.readline()).rstrip()
while o != '':
line_function(o)
o = text_utils.uni(logfile_reader.readline()).rstrip()
if not return_output:
return process.wait()
logfile_reader.seek(logfile_start_position, os.SEEK_SET)
res = text_utils.uni(logfile_reader.read())
try:
logfile_reader.close()
logfile_writer.close()
err_logfile_writer.close()
if tmp_log:
shutil.rmtree(log_folder, ignore_errors=True)
except:
logger.exception("Error while cleaning after tbx.execute() call.")
return res |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:add_backbone_atoms_linearly_from_loop_filepaths; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:loop_json_filepath; 6, identifier:fasta_filepath; 7, identifier:residue_ids; 8, block; 8, 9; 8, 11; 8, 23; 8, 33; 8, 43; 8, 53; 8, 79; 8, 105; 8, 110; 8, 115; 8, 128; 8, 140; 8, 150; 8, 167; 8, 171; 8, 175; 8, 179; 8, 183; 8, 236; 8, 245; 8, 254; 8, 297; 9, expression_statement; 9, 10; 10, string:'''A utility wrapper around add_backbone_atoms_linearly. Adds backbone atoms in a straight line from the first to
the last residue of residue_ids.
loop_json_filepath is a path to a JSON file using the JSON format for Rosetta loops files. This file identifies
the insertion points of the sequence.
fasta_filepath is a path to a FASTA file with one sequence. This sequence will be used as the sequence for
the inserted residues (between the start and stop residues defined in loop_json_filepath).
residue_ids is a list of PDB chain residues (columns 22-27 of ATOM lines in the PDB format). It is assumed that
they are sequential although the logic does not depend on that. This list should have the length length as the
sequence identified in the FASTA file.
'''; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:loop_def; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:json; 17, identifier:loads; 18, argument_list; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:read_file; 21, argument_list; 21, 22; 22, identifier:loop_json_filepath; 23, assert_statement; 23, 24; 24, parenthesized_expression; 24, 25; 25, comparison_operator:==; 25, 26; 25, 32; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, subscript; 29, 30; 29, 31; 30, identifier:loop_def; 31, string:'LoopSet'; 32, integer:1; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:start_res; 36, subscript; 36, 37; 36, 42; 37, subscript; 37, 38; 37, 41; 38, subscript; 38, 39; 38, 40; 39, identifier:loop_def; 40, string:'LoopSet'; 41, integer:0; 42, string:'start'; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:end_res; 46, subscript; 46, 47; 46, 52; 47, subscript; 47, 48; 47, 51; 48, subscript; 48, 49; 48, 50; 49, identifier:loop_def; 50, string:'LoopSet'; 51, integer:0; 52, string:'stop'; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:start_res; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:PDB; 59, identifier:ChainResidueID2String; 60, argument_list; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:start_res; 63, string:'chainID'; 64, call; 64, 65; 64, 78; 65, attribute; 65, 66; 65, 77; 66, parenthesized_expression; 66, 67; 67, binary_operator:+; 67, 68; 67, 74; 68, call; 68, 69; 68, 70; 69, identifier:str; 70, argument_list; 70, 71; 71, subscript; 71, 72; 71, 73; 72, identifier:start_res; 73, string:'resSeq'; 74, subscript; 74, 75; 74, 76; 75, identifier:start_res; 76, string:'iCode'; 77, identifier:strip; 78, argument_list; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:end_res; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:PDB; 85, identifier:ChainResidueID2String; 86, argument_list; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:end_res; 89, string:'chainID'; 90, call; 90, 91; 90, 104; 91, attribute; 91, 92; 91, 103; 92, parenthesized_expression; 92, 93; 93, binary_operator:+; 93, 94; 93, 100; 94, call; 94, 95; 94, 96; 95, identifier:str; 96, argument_list; 96, 97; 97, subscript; 97, 98; 97, 99; 98, identifier:end_res; 99, string:'resSeq'; 100, subscript; 100, 101; 100, 102; 101, identifier:end_res; 102, string:'iCode'; 103, identifier:strip; 104, argument_list; 105, assert_statement; 105, 106; 106, parenthesized_expression; 106, 107; 107, comparison_operator:in; 107, 108; 107, 109; 108, identifier:start_res; 109, identifier:residue_ids; 110, assert_statement; 110, 111; 111, parenthesized_expression; 111, 112; 112, comparison_operator:in; 112, 113; 112, 114; 113, identifier:end_res; 114, identifier:residue_ids; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:f; 118, call; 118, 119; 118, 120; 119, identifier:FASTA; 120, argument_list; 120, 121; 120, 125; 121, call; 121, 122; 121, 123; 122, identifier:read_file; 123, argument_list; 123, 124; 124, identifier:fasta_filepath; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:strict; 127, False; 128, assert_statement; 128, 129; 129, parenthesized_expression; 129, 130; 130, comparison_operator:==; 130, 131; 130, 139; 131, call; 131, 132; 131, 133; 132, identifier:len; 133, argument_list; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:f; 137, identifier:get_sequences; 138, argument_list; 139, integer:1; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:insertion_sequence; 143, subscript; 143, 144; 143, 149; 144, subscript; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:f; 147, identifier:sequences; 148, integer:0; 149, integer:2; 150, if_statement; 150, 151; 150, 161; 151, not_operator; 151, 152; 152, comparison_operator:==; 152, 153; 152, 157; 153, call; 153, 154; 153, 155; 154, identifier:len; 155, argument_list; 155, 156; 156, identifier:residue_ids; 157, call; 157, 158; 157, 159; 158, identifier:len; 159, argument_list; 159, 160; 160, identifier:insertion_sequence; 161, block; 161, 162; 162, raise_statement; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:Exception; 165, argument_list; 165, 166; 166, string:'The sequence in the FASTA file must have the same length as the list of residues.'; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:kept_residues; 170, list:[]; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:insertion_residue_map; 174, dictionary; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:in_section; 178, False; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:found_end; 182, False; 183, for_statement; 183, 184; 183, 185; 183, 192; 184, identifier:x; 185, call; 185, 186; 185, 187; 186, identifier:range; 187, argument_list; 187, 188; 188, call; 188, 189; 188, 190; 189, identifier:len; 190, argument_list; 190, 191; 191, identifier:residue_ids; 192, block; 192, 193; 192, 199; 192, 208; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:residue_id; 196, subscript; 196, 197; 196, 198; 197, identifier:residue_ids; 198, identifier:x; 199, if_statement; 199, 200; 199, 203; 200, comparison_operator:==; 200, 201; 200, 202; 201, identifier:residue_id; 202, identifier:start_res; 203, block; 203, 204; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:in_section; 207, True; 208, if_statement; 208, 209; 208, 210; 209, identifier:in_section; 210, block; 210, 211; 210, 218; 210, 226; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:kept_residues; 215, identifier:append; 216, argument_list; 216, 217; 217, identifier:residue_id; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:insertion_residue_map; 222, identifier:residue_id; 223, subscript; 223, 224; 223, 225; 224, identifier:insertion_sequence; 225, identifier:x; 226, if_statement; 226, 227; 226, 230; 227, comparison_operator:==; 227, 228; 227, 229; 228, identifier:residue_id; 229, identifier:end_res; 230, block; 230, 231; 230, 235; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:found_end; 234, True; 235, break_statement; 236, if_statement; 236, 237; 236, 239; 237, not_operator; 237, 238; 238, identifier:kept_residues; 239, block; 239, 240; 240, raise_statement; 240, 241; 241, call; 241, 242; 241, 243; 242, identifier:Exception; 243, argument_list; 243, 244; 244, string:'The insertion sequence is empty (check the start and end residue ids).'; 245, if_statement; 245, 246; 245, 248; 246, not_operator; 246, 247; 247, identifier:found_end; 248, block; 248, 249; 249, raise_statement; 249, 250; 250, call; 250, 251; 250, 252; 251, identifier:Exception; 252, argument_list; 252, 253; 253, string:'The end residue was not encountered when iterating over the insertion sequence (check the start and end residue ids).'; 254, try_statement; 254, 255; 254, 288; 255, block; 255, 256; 255, 272; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 258, identifier:start_res; 259, subscript; 259, 260; 259, 267; 260, subscript; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:self; 263, identifier:residues; 264, subscript; 264, 265; 264, 266; 265, identifier:start_res; 266, integer:0; 267, subscript; 267, 268; 267, 269; 268, identifier:start_res; 269, slice; 269, 270; 269, 271; 270, integer:1; 271, colon; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:end_res; 275, subscript; 275, 276; 275, 283; 276, subscript; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:self; 279, identifier:residues; 280, subscript; 280, 281; 280, 282; 281, identifier:end_res; 282, integer:0; 283, subscript; 283, 284; 283, 285; 284, identifier:end_res; 285, slice; 285, 286; 285, 287; 286, integer:1; 287, colon; 288, except_clause; 288, 289; 288, 290; 288, 291; 289, identifier:Exception; 290, identifier:e; 291, block; 291, 292; 292, raise_statement; 292, 293; 293, call; 293, 294; 293, 295; 294, identifier:Exception; 295, argument_list; 295, 296; 296, string:'The start or end residue could not be found in the PDB file.'; 297, return_statement; 297, 298; 298, call; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:self; 301, identifier:add_backbone_atoms_linearly; 302, argument_list; 302, 303; 302, 304; 302, 305; 302, 306; 303, identifier:start_res; 304, identifier:end_res; 305, identifier:kept_residues; 306, identifier:insertion_residue_map | def add_backbone_atoms_linearly_from_loop_filepaths(self, loop_json_filepath, fasta_filepath, residue_ids):
'''A utility wrapper around add_backbone_atoms_linearly. Adds backbone atoms in a straight line from the first to
the last residue of residue_ids.
loop_json_filepath is a path to a JSON file using the JSON format for Rosetta loops files. This file identifies
the insertion points of the sequence.
fasta_filepath is a path to a FASTA file with one sequence. This sequence will be used as the sequence for
the inserted residues (between the start and stop residues defined in loop_json_filepath).
residue_ids is a list of PDB chain residues (columns 22-27 of ATOM lines in the PDB format). It is assumed that
they are sequential although the logic does not depend on that. This list should have the length length as the
sequence identified in the FASTA file.
'''
loop_def = json.loads(read_file(loop_json_filepath))
assert(len(loop_def['LoopSet']) == 1)
start_res = loop_def['LoopSet'][0]['start']
end_res = loop_def['LoopSet'][0]['stop']
start_res = PDB.ChainResidueID2String(start_res['chainID'], (str(start_res['resSeq']) + start_res['iCode']).strip())
end_res = PDB.ChainResidueID2String(end_res['chainID'], (str(end_res['resSeq']) + end_res['iCode']).strip())
assert(start_res in residue_ids)
assert(end_res in residue_ids)
f = FASTA(read_file(fasta_filepath), strict = False)
assert(len(f.get_sequences()) == 1)
insertion_sequence = f.sequences[0][2]
if not len(residue_ids) == len(insertion_sequence):
raise Exception('The sequence in the FASTA file must have the same length as the list of residues.')
kept_residues = []
insertion_residue_map = {}
in_section = False
found_end = False
for x in range(len(residue_ids)):
residue_id = residue_ids[x]
if residue_id == start_res:
in_section = True
if in_section:
kept_residues.append(residue_id)
insertion_residue_map[residue_id] = insertion_sequence[x]
if residue_id == end_res:
found_end = True
break
if not kept_residues:
raise Exception('The insertion sequence is empty (check the start and end residue ids).')
if not found_end:
raise Exception('The end residue was not encountered when iterating over the insertion sequence (check the start and end residue ids).')
try:
start_res = self.residues[start_res[0]][start_res[1:]]
end_res = self.residues[end_res[0]][end_res[1:]]
except Exception, e:
raise Exception('The start or end residue could not be found in the PDB file.')
return self.add_backbone_atoms_linearly(start_res, end_res, kept_residues, insertion_residue_map) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:add_atoms_linearly; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:start_atom; 6, identifier:end_atom; 7, identifier:new_atoms; 8, default_parameter; 8, 9; 8, 10; 9, identifier:jitterbug; 10, float:0.2; 11, block; 11, 12; 11, 14; 11, 30; 11, 43; 11, 51; 11, 61; 11, 77; 11, 91; 11, 105; 11, 119; 11, 138; 11, 142; 11, 162; 11, 166; 11, 184; 11, 188; 11, 327; 11, 331; 11, 335; 11, 409; 12, expression_statement; 12, 13; 13, string:'''A low-level function which adds new_atoms between start_atom and end_atom. This function does not validate the
input i.e. the calling functions are responsible for ensuring that the insertion makes sense.
Returns the PDB file content with the new atoms added. These atoms are given fresh serial numbers, starting
from the first serial number larger than the current serial numbers i.e. the ATOM serial numbers do not now
necessarily increase in document order.
The jitter adds some X, Y, Z variability to the new atoms. This is important in the Rosetta software suite when
placing backbone atoms as colinearly placed atoms will break the dihedral angle calculations (the dihedral angle
over 4 colinear atoms is undefined).
'''; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:atom_name_map; 17, dictionary; 17, 18; 17, 21; 17, 24; 17, 27; 18, pair; 18, 19; 18, 20; 19, string:'CA'; 20, string:' CA '; 21, pair; 21, 22; 21, 23; 22, string:'C'; 23, string:' C '; 24, pair; 24, 25; 24, 26; 25, string:'N'; 26, string:' N '; 27, pair; 27, 28; 27, 29; 28, string:'O'; 29, string:' O '; 30, assert_statement; 30, 31; 31, parenthesized_expression; 31, 32; 32, comparison_operator:==; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:start_atom; 36, identifier:residue; 37, identifier:chain; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:end_atom; 41, identifier:residue; 42, identifier:chain; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:chain_id; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:start_atom; 49, identifier:residue; 50, identifier:chain; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:num_new_atoms; 54, call; 54, 55; 54, 56; 55, identifier:float; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, identifier:new_atoms; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 67; 63, pattern_list; 63, 64; 63, 65; 63, 66; 64, identifier:X; 65, identifier:Y; 66, identifier:Z; 67, expression_list; 67, 68; 67, 71; 67, 74; 68, attribute; 68, 69; 68, 70; 69, identifier:start_atom; 70, identifier:x; 71, attribute; 71, 72; 71, 73; 72, identifier:start_atom; 73, identifier:y; 74, attribute; 74, 75; 74, 76; 75, identifier:start_atom; 76, identifier:z; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:x_step; 80, binary_operator:/; 80, 81; 80, 87; 81, parenthesized_expression; 81, 82; 82, binary_operator:-; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:end_atom; 85, identifier:x; 86, identifier:X; 87, parenthesized_expression; 87, 88; 88, binary_operator:+; 88, 89; 88, 90; 89, identifier:num_new_atoms; 90, float:1.0; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:y_step; 94, binary_operator:/; 94, 95; 94, 101; 95, parenthesized_expression; 95, 96; 96, binary_operator:-; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:end_atom; 99, identifier:y; 100, identifier:Y; 101, parenthesized_expression; 101, 102; 102, binary_operator:+; 102, 103; 102, 104; 103, identifier:num_new_atoms; 104, float:1.0; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:z_step; 108, binary_operator:/; 108, 109; 108, 115; 109, parenthesized_expression; 109, 110; 110, binary_operator:-; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:end_atom; 113, identifier:z; 114, identifier:Z; 115, parenthesized_expression; 115, 116; 116, binary_operator:+; 116, 117; 116, 118; 117, identifier:num_new_atoms; 118, float:1.0; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:D; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:math; 125, identifier:sqrt; 126, argument_list; 126, 127; 127, binary_operator:+; 127, 128; 127, 135; 128, binary_operator:+; 128, 129; 128, 132; 129, binary_operator:*; 129, 130; 129, 131; 130, identifier:x_step; 131, identifier:x_step; 132, binary_operator:*; 132, 133; 132, 134; 133, identifier:y_step; 134, identifier:y_step; 135, binary_operator:*; 135, 136; 135, 137; 136, identifier:z_step; 137, identifier:z_step; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:jitter; 141, integer:0; 142, if_statement; 142, 143; 142, 144; 143, identifier:jitterbug; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:jitter; 148, binary_operator:/; 148, 149; 148, 161; 149, parenthesized_expression; 149, 150; 150, binary_operator:*; 150, 151; 150, 160; 151, parenthesized_expression; 151, 152; 152, binary_operator:/; 152, 153; 152, 159; 153, parenthesized_expression; 153, 154; 154, binary_operator:+; 154, 155; 154, 158; 155, binary_operator:+; 155, 156; 155, 157; 156, identifier:x_step; 157, identifier:y_step; 158, identifier:z_step; 159, float:3.0; 160, identifier:jitterbug; 161, identifier:D; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:new_lines; 165, list:[]; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:next_serial_number; 169, binary_operator:+; 169, 170; 169, 183; 170, call; 170, 171; 170, 172; 171, identifier:max; 172, argument_list; 172, 173; 173, call; 173, 174; 173, 175; 174, identifier:sorted; 175, argument_list; 175, 176; 176, call; 176, 177; 176, 182; 177, attribute; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:self; 180, identifier:atoms; 181, identifier:keys; 182, argument_list; 183, integer:1; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:round; 187, integer:0; 188, for_statement; 188, 189; 188, 190; 188, 191; 189, identifier:new_atom; 190, identifier:new_atoms; 191, block; 191, 192; 191, 208; 191, 272; 191, 279; 191, 287; 191, 295; 191, 323; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 198; 194, pattern_list; 194, 195; 194, 196; 194, 197; 195, identifier:X; 196, identifier:Y; 197, identifier:Z; 198, expression_list; 198, 199; 198, 202; 198, 205; 199, binary_operator:+; 199, 200; 199, 201; 200, identifier:X; 201, identifier:x_step; 202, binary_operator:+; 202, 203; 202, 204; 203, identifier:Y; 204, identifier:y_step; 205, binary_operator:+; 205, 206; 205, 207; 206, identifier:Z; 207, identifier:z_step; 208, if_statement; 208, 209; 208, 210; 209, identifier:jitter; 210, block; 210, 211; 210, 268; 211, if_statement; 211, 212; 211, 217; 211, 230; 211, 249; 212, comparison_operator:==; 212, 213; 212, 216; 213, binary_operator:%; 213, 214; 213, 215; 214, identifier:round; 215, integer:3; 216, integer:0; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 223; 220, pattern_list; 220, 221; 220, 222; 221, identifier:X; 222, identifier:Y; 223, expression_list; 223, 224; 223, 227; 224, binary_operator:+; 224, 225; 224, 226; 225, identifier:X; 226, identifier:jitter; 227, binary_operator:-; 227, 228; 227, 229; 228, identifier:Y; 229, identifier:jitter; 230, elif_clause; 230, 231; 230, 236; 231, comparison_operator:==; 231, 232; 231, 235; 232, binary_operator:%; 232, 233; 232, 234; 233, identifier:round; 234, integer:3; 235, integer:1; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 242; 239, pattern_list; 239, 240; 239, 241; 240, identifier:Y; 241, identifier:Z; 242, expression_list; 242, 243; 242, 246; 243, binary_operator:+; 243, 244; 243, 245; 244, identifier:Y; 245, identifier:jitter; 246, binary_operator:-; 246, 247; 246, 248; 247, identifier:Z; 248, identifier:jitter; 249, elif_clause; 249, 250; 249, 255; 250, comparison_operator:==; 250, 251; 250, 254; 251, binary_operator:%; 251, 252; 251, 253; 252, identifier:round; 253, integer:3; 254, integer:2; 255, block; 255, 256; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 261; 258, pattern_list; 258, 259; 258, 260; 259, identifier:Z; 260, identifier:X; 261, expression_list; 261, 262; 261, 265; 262, binary_operator:+; 262, 263; 262, 264; 263, identifier:Z; 264, identifier:jitter; 265, binary_operator:-; 265, 266; 265, 267; 266, identifier:X; 267, identifier:jitter; 268, expression_statement; 268, 269; 269, augmented_assignment:+=; 269, 270; 269, 271; 270, identifier:round; 271, integer:1; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 278; 274, pattern_list; 274, 275; 274, 276; 274, 277; 275, identifier:residue_id; 276, identifier:residue_type; 277, identifier:atom_name; 278, identifier:new_atom; 279, assert_statement; 279, 280; 280, parenthesized_expression; 280, 281; 281, comparison_operator:==; 281, 282; 281, 286; 282, call; 282, 283; 282, 284; 283, identifier:len; 284, argument_list; 284, 285; 285, identifier:residue_type; 286, integer:3; 287, assert_statement; 287, 288; 288, parenthesized_expression; 288, 289; 289, comparison_operator:==; 289, 290; 289, 294; 290, call; 290, 291; 290, 292; 291, identifier:len; 292, argument_list; 292, 293; 293, identifier:residue_id; 294, integer:6; 295, expression_statement; 295, 296; 296, call; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:new_lines; 299, identifier:append; 300, argument_list; 300, 301; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, string:'ATOM {0} {1} {2} {3} {4:>8.3f}{5:>8.3f}{6:>8.3f} 1.00 0.00 '; 304, identifier:format; 305, argument_list; 305, 306; 305, 315; 305, 318; 305, 319; 305, 320; 305, 321; 305, 322; 306, call; 306, 307; 306, 313; 307, attribute; 307, 308; 307, 312; 308, call; 308, 309; 308, 310; 309, identifier:str; 310, argument_list; 310, 311; 311, identifier:next_serial_number; 312, identifier:rjust; 313, argument_list; 313, 314; 314, integer:5; 315, subscript; 315, 316; 315, 317; 316, identifier:atom_name_map; 317, identifier:atom_name; 318, identifier:residue_type; 319, identifier:residue_id; 320, identifier:X; 321, identifier:Y; 322, identifier:Z; 323, expression_statement; 323, 324; 324, augmented_assignment:+=; 324, 325; 324, 326; 325, identifier:next_serial_number; 326, integer:1; 327, expression_statement; 327, 328; 328, assignment; 328, 329; 328, 330; 329, identifier:new_pdb; 330, list:[]; 331, expression_statement; 331, 332; 332, assignment; 332, 333; 332, 334; 333, identifier:in_start_residue; 334, False; 335, for_statement; 335, 336; 335, 337; 335, 340; 336, identifier:l; 337, attribute; 337, 338; 337, 339; 338, identifier:self; 339, identifier:indexed_lines; 340, block; 340, 341; 340, 360; 340, 384; 341, if_statement; 341, 342; 341, 355; 342, boolean_operator:and; 342, 343; 342, 346; 343, subscript; 343, 344; 343, 345; 344, identifier:l; 345, integer:0; 346, comparison_operator:==; 346, 347; 346, 352; 347, attribute; 347, 348; 347, 351; 348, subscript; 348, 349; 348, 350; 349, identifier:l; 350, integer:3; 351, identifier:serial_number; 352, attribute; 352, 353; 352, 354; 353, identifier:start_atom; 354, identifier:serial_number; 355, block; 355, 356; 356, expression_statement; 356, 357; 357, assignment; 357, 358; 357, 359; 358, identifier:in_start_residue; 359, True; 360, if_statement; 360, 361; 360, 372; 361, boolean_operator:and; 361, 362; 361, 363; 362, identifier:in_start_residue; 363, comparison_operator:!=; 363, 364; 363, 369; 364, attribute; 364, 365; 364, 368; 365, subscript; 365, 366; 365, 367; 366, identifier:l; 367, integer:3; 368, identifier:serial_number; 369, attribute; 369, 370; 369, 371; 370, identifier:start_atom; 371, identifier:serial_number; 372, block; 372, 373; 372, 380; 373, expression_statement; 373, 374; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:new_pdb; 377, identifier:extend; 378, argument_list; 378, 379; 379, identifier:new_lines; 380, expression_statement; 380, 381; 381, assignment; 381, 382; 381, 383; 382, identifier:in_start_residue; 383, False; 384, if_statement; 384, 385; 384, 388; 384, 398; 385, subscript; 385, 386; 385, 387; 386, identifier:l; 387, integer:0; 388, block; 388, 389; 389, expression_statement; 389, 390; 390, call; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, identifier:new_pdb; 393, identifier:append; 394, argument_list; 394, 395; 395, subscript; 395, 396; 395, 397; 396, identifier:l; 397, integer:2; 398, else_clause; 398, 399; 399, block; 399, 400; 400, expression_statement; 400, 401; 401, call; 401, 402; 401, 405; 402, attribute; 402, 403; 402, 404; 403, identifier:new_pdb; 404, identifier:append; 405, argument_list; 405, 406; 406, subscript; 406, 407; 406, 408; 407, identifier:l; 408, integer:1; 409, return_statement; 409, 410; 410, call; 410, 411; 410, 414; 411, attribute; 411, 412; 411, 413; 412, string:'\n'; 413, identifier:join; 414, argument_list; 414, 415; 415, identifier:new_pdb | def add_atoms_linearly(self, start_atom, end_atom, new_atoms, jitterbug = 0.2):
'''A low-level function which adds new_atoms between start_atom and end_atom. This function does not validate the
input i.e. the calling functions are responsible for ensuring that the insertion makes sense.
Returns the PDB file content with the new atoms added. These atoms are given fresh serial numbers, starting
from the first serial number larger than the current serial numbers i.e. the ATOM serial numbers do not now
necessarily increase in document order.
The jitter adds some X, Y, Z variability to the new atoms. This is important in the Rosetta software suite when
placing backbone atoms as colinearly placed atoms will break the dihedral angle calculations (the dihedral angle
over 4 colinear atoms is undefined).
'''
atom_name_map = {
'CA' : ' CA ',
'C' : ' C ',
'N' : ' N ',
'O' : ' O ',
}
assert(start_atom.residue.chain == end_atom.residue.chain)
chain_id = start_atom.residue.chain
num_new_atoms = float(len(new_atoms))
X, Y, Z = start_atom.x, start_atom.y, start_atom.z
x_step = (end_atom.x - X) / (num_new_atoms + 1.0)
y_step = (end_atom.y - Y) / (num_new_atoms + 1.0)
z_step = (end_atom.z - Z) / (num_new_atoms + 1.0)
D = math.sqrt(x_step * x_step + y_step * y_step + z_step * z_step)
jitter = 0
if jitterbug:
jitter = (((x_step + y_step + z_step) / 3.0) * jitterbug) / D
new_lines = []
next_serial_number = max(sorted(self.atoms.keys())) + 1
round = 0
for new_atom in new_atoms:
X, Y, Z = X + x_step, Y + y_step, Z + z_step
if jitter:
if round % 3 == 0:
X, Y = X + jitter, Y - jitter
elif round % 3 == 1:
Y, Z = Y + jitter, Z - jitter
elif round % 3 == 2:
Z, X = Z + jitter, X - jitter
round += 1
residue_id, residue_type, atom_name = new_atom
assert(len(residue_type) == 3)
assert(len(residue_id) == 6)
new_lines.append('ATOM {0} {1} {2} {3} {4:>8.3f}{5:>8.3f}{6:>8.3f} 1.00 0.00 '.format(str(next_serial_number).rjust(5), atom_name_map[atom_name], residue_type, residue_id, X, Y, Z))
next_serial_number += 1
new_pdb = []
in_start_residue = False
for l in self.indexed_lines:
if l[0] and l[3].serial_number == start_atom.serial_number:
in_start_residue = True
if in_start_residue and l[3].serial_number != start_atom.serial_number:
new_pdb.extend(new_lines)
in_start_residue = False
if l[0]:
new_pdb.append(l[2])
else:
new_pdb.append(l[1])
return '\n'.join(new_pdb) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:dispatch_request; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 18; 5, 27; 5, 37; 5, 62; 5, 71; 5, 96; 5, 207; 5, 216; 5, 225; 5, 234; 5, 243; 5, 254; 5, 271; 5, 349; 5, 373; 5, 380; 6, if_statement; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:current_user; 9, identifier:is_authenticated; 10, block; 10, 11; 11, return_statement; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:redirect; 14, argument_list; 14, 15; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:next; 18, if_statement; 18, 19; 18, 22; 19, comparison_operator:in; 19, 20; 19, 21; 20, string:'social_data'; 21, identifier:session; 22, block; 22, 23; 23, delete_statement; 23, 24; 24, subscript; 24, 25; 24, 26; 25, identifier:session; 26, string:'social_data'; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:res; 30, call; 30, 31; 30, 36; 31, attribute; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:app; 35, identifier:authorized_response; 36, argument_list; 37, if_statement; 37, 38; 37, 41; 38, comparison_operator:is; 38, 39; 38, 40; 39, identifier:res; 40, None; 41, block; 41, 42; 41, 55; 42, if_statement; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:flash; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:flash; 50, argument_list; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:auth_failed_msg; 54, string:'danger'; 55, return_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:redirect; 58, argument_list; 58, 59; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:next; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:data; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:get_profile_data; 69, argument_list; 69, 70; 70, identifier:res; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:data; 74, None; 75, block; 75, 76; 75, 89; 76, if_statement; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:flash; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:flash; 84, argument_list; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:data_failed_msg; 88, string:'danger'; 89, return_statement; 89, 90; 90, call; 90, 91; 90, 92; 91, identifier:redirect; 92, argument_list; 92, 93; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:next; 96, try_statement; 96, 97; 96, 142; 96, 192; 97, block; 97, 98; 97, 112; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:ok; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:user_service; 104, identifier:attempt_social_login; 105, argument_list; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:provider; 109, subscript; 109, 110; 109, 111; 110, identifier:data; 111, string:'id'; 112, if_statement; 112, 113; 112, 114; 113, identifier:ok; 114, block; 114, 115; 114, 135; 115, if_statement; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:flash; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:flash; 123, argument_list; 123, 124; 123, 134; 124, call; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:logged_in_msg; 129, identifier:format; 130, argument_list; 130, 131; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:provider; 134, string:'success'; 135, return_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:redirect; 138, argument_list; 138, 139; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:logged_in; 142, except_clause; 142, 143; 142, 149; 143, as_pattern; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:x; 146, identifier:AccountLocked; 147, as_pattern_target; 147, 148; 148, identifier:locked; 149, block; 149, 150; 149, 163; 149, 174; 149, 187; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:msg; 153, call; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:lock_msg; 158, identifier:format; 159, argument_list; 159, 160; 160, attribute; 160, 161; 160, 162; 161, identifier:locked; 162, identifier:locked_until; 163, if_statement; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:flash; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:flash; 171, argument_list; 171, 172; 171, 173; 172, identifier:msg; 173, string:'danger'; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:url; 177, call; 177, 178; 177, 179; 178, identifier:url_for; 179, argument_list; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:lock_redirect; 183, dictionary_splat; 183, 184; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:lock_redirect_params; 187, return_statement; 187, 188; 188, call; 188, 189; 188, 190; 189, identifier:redirect; 190, argument_list; 190, 191; 191, identifier:url; 192, except_clause; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:x; 195, identifier:EmailNotConfirmed; 196, block; 196, 197; 197, return_statement; 197, 198; 198, call; 198, 199; 198, 200; 199, identifier:redirect; 200, argument_list; 200, 201; 201, call; 201, 202; 201, 203; 202, identifier:url_for; 203, argument_list; 203, 204; 204, attribute; 204, 205; 204, 206; 205, identifier:self; 206, identifier:unconfirmed_email_endpoint; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:email; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:data; 213, identifier:get; 214, argument_list; 214, 215; 215, string:'email'; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:provider; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:data; 222, identifier:get; 223, argument_list; 223, 224; 224, string:'provider'; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:id; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:data; 231, identifier:get; 232, argument_list; 232, 233; 233, string:'id'; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:id_column; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, string:'{}_id'; 240, identifier:format; 241, argument_list; 241, 242; 242, identifier:provider; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:user; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:user_service; 249, identifier:first; 250, argument_list; 250, 251; 251, keyword_argument; 251, 252; 251, 253; 252, identifier:email; 253, identifier:email; 254, if_statement; 254, 255; 254, 256; 255, identifier:user; 256, block; 256, 257; 256, 264; 257, expression_statement; 257, 258; 258, call; 258, 259; 258, 260; 259, identifier:setattr; 260, argument_list; 260, 261; 260, 262; 260, 263; 261, identifier:user; 262, identifier:id_column; 263, identifier:id; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:user_service; 268, identifier:save; 269, argument_list; 269, 270; 270, identifier:user; 271, if_statement; 271, 272; 271, 274; 272, not_operator; 272, 273; 273, identifier:user; 274, block; 274, 275; 274, 281; 274, 290; 274, 299; 274, 317; 274, 326; 274, 332; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 278; 277, identifier:cfg; 278, attribute; 278, 279; 278, 280; 279, identifier:current_app; 280, identifier:config; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:send_welcome; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:cfg; 287, identifier:get; 288, argument_list; 288, 289; 289, string:'USER_SEND_WELCOME_MESSAGE'; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:base_confirm_url; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:cfg; 296, identifier:get; 297, argument_list; 297, 298; 298, string:'USER_BASE_EMAIL_CONFIRM_URL'; 299, if_statement; 299, 300; 299, 302; 300, not_operator; 300, 301; 301, identifier:base_confirm_url; 302, block; 302, 303; 302, 307; 303, expression_statement; 303, 304; 304, assignment; 304, 305; 304, 306; 305, identifier:endpoint; 306, string:'user.confirm.email.request'; 307, expression_statement; 307, 308; 308, assignment; 308, 309; 308, 310; 309, identifier:base_confirm_url; 310, call; 310, 311; 310, 312; 311, identifier:url_for; 312, argument_list; 312, 313; 312, 314; 313, identifier:endpoint; 314, keyword_argument; 314, 315; 314, 316; 315, identifier:_external; 316, True; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 320; 319, identifier:data; 320, call; 320, 321; 320, 322; 321, identifier:dict; 322, argument_list; 322, 323; 323, keyword_argument; 323, 324; 323, 325; 324, identifier:email; 325, identifier:email; 326, expression_statement; 326, 327; 327, assignment; 327, 328; 327, 331; 328, subscript; 328, 329; 328, 330; 329, identifier:data; 330, identifier:id_column; 331, identifier:id; 332, expression_statement; 332, 333; 333, assignment; 333, 334; 333, 335; 334, identifier:user; 335, call; 335, 336; 335, 339; 336, attribute; 336, 337; 336, 338; 337, identifier:user_service; 338, identifier:register; 339, argument_list; 339, 340; 339, 343; 339, 346; 340, keyword_argument; 340, 341; 340, 342; 341, identifier:user_data; 342, identifier:data; 343, keyword_argument; 343, 344; 343, 345; 344, identifier:send_welcome; 345, identifier:send_welcome; 346, keyword_argument; 346, 347; 346, 348; 347, identifier:base_confirm_url; 348, identifier:base_confirm_url; 349, if_statement; 349, 350; 349, 358; 350, boolean_operator:and; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:user_service; 353, identifier:require_confirmation; 354, not_operator; 354, 355; 355, attribute; 355, 356; 355, 357; 356, identifier:user; 357, identifier:email_confirmed; 358, block; 358, 359; 359, return_statement; 359, 360; 360, call; 360, 361; 360, 362; 361, identifier:redirect; 362, argument_list; 362, 363; 363, call; 363, 364; 363, 365; 364, identifier:url_for; 365, argument_list; 365, 366; 365, 369; 366, attribute; 366, 367; 366, 368; 367, identifier:self; 368, identifier:ok_endpoint; 369, dictionary_splat; 369, 370; 370, attribute; 370, 371; 370, 372; 371, identifier:self; 372, identifier:ok_params; 373, expression_statement; 373, 374; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:user_service; 377, identifier:force_login; 378, argument_list; 378, 379; 379, identifier:user; 380, return_statement; 380, 381; 381, call; 381, 382; 381, 383; 382, identifier:redirect; 383, argument_list; 383, 384; 384, attribute; 384, 385; 384, 386; 385, identifier:self; 386, identifier:force_login_redirect | def dispatch_request(self):
if current_user.is_authenticated:
return redirect(self.next)
if 'social_data' in session:
del session['social_data']
res = self.app.authorized_response()
if res is None:
if self.flash: flash(self.auth_failed_msg, 'danger')
return redirect(self.next)
data = self.get_profile_data(res)
if data is None:
if self.flash: flash(self.data_failed_msg, 'danger')
return redirect(self.next)
try:
ok = user_service.attempt_social_login(self.provider, data['id'])
if ok:
if self.flash:
flash(self.logged_in_msg.format(self.provider), 'success')
return redirect(self.logged_in)
except x.AccountLocked as locked:
msg = self.lock_msg.format(locked.locked_until)
if self.flash: flash(msg, 'danger')
url = url_for(self.lock_redirect, **self.lock_redirect_params)
return redirect(url)
except x.EmailNotConfirmed:
return redirect(url_for(self.unconfirmed_email_endpoint))
email = data.get('email')
provider = data.get('provider')
id = data.get('id')
id_column = '{}_id'.format(provider)
user = user_service.first(email=email)
if user:
setattr(user, id_column, id)
user_service.save(user)
if not user:
cfg = current_app.config
send_welcome = cfg.get('USER_SEND_WELCOME_MESSAGE')
base_confirm_url = cfg.get('USER_BASE_EMAIL_CONFIRM_URL')
if not base_confirm_url:
endpoint = 'user.confirm.email.request'
base_confirm_url = url_for(endpoint, _external=True)
data = dict(email=email)
data[id_column] = id
user = user_service.register(
user_data=data,
send_welcome=send_welcome,
base_confirm_url=base_confirm_url
)
if user_service.require_confirmation and not user.email_confirmed:
return redirect(url_for(self.ok_endpoint, **self.ok_params))
user_service.force_login(user)
return redirect(self.force_login_redirect) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:get_duration_measures; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:source_file_path; 5, default_parameter; 5, 6; 5, 7; 6, identifier:output_path; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:phonemic; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:semantic; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:quiet; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:similarity_file; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:threshold; 22, None; 23, block; 23, 24; 23, 30; 23, 36; 23, 42; 23, 48; 23, 54; 23, 60; 23, 66; 23, 72; 23, 79; 23, 163; 23, 190; 23, 222; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:args; 27, call; 27, 28; 27, 29; 28, identifier:Args; 29, argument_list; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:args; 34, identifier:output_path; 35, identifier:output_path; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:args; 40, identifier:phonemic; 41, identifier:phonemic; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:args; 46, identifier:semantic; 47, identifier:semantic; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:args; 52, identifier:source_file_path; 53, identifier:source_file_path; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:args; 58, identifier:quiet; 59, identifier:quiet; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:args; 64, identifier:similarity_file; 65, identifier:similarity_file; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:args; 70, identifier:threshold; 71, identifier:threshold; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:args; 75, call; 75, 76; 75, 77; 76, identifier:validate_arguments; 77, argument_list; 77, 78; 78, identifier:args; 79, if_statement; 79, 80; 79, 83; 79, 116; 79, 153; 80, attribute; 80, 81; 80, 82; 81, identifier:args; 82, identifier:phonemic; 83, block; 83, 84; 83, 90; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:response_category; 87, attribute; 87, 88; 87, 89; 88, identifier:args; 89, identifier:phonemic; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:output_prefix; 93, binary_operator:+; 93, 94; 93, 113; 94, binary_operator:+; 94, 95; 94, 112; 95, subscript; 95, 96; 95, 111; 96, call; 96, 97; 96, 109; 97, attribute; 97, 98; 97, 108; 98, call; 98, 99; 98, 104; 99, attribute; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:os; 102, identifier:path; 103, identifier:basename; 104, argument_list; 104, 105; 105, attribute; 105, 106; 105, 107; 106, identifier:args; 107, identifier:source_file_path; 108, identifier:split; 109, argument_list; 109, 110; 110, string:'.'; 111, integer:0; 112, string:"_vfclust_phonemic_"; 113, attribute; 113, 114; 113, 115; 114, identifier:args; 115, identifier:phonemic; 116, elif_clause; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:args; 119, identifier:semantic; 120, block; 120, 121; 120, 127; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:response_category; 124, attribute; 124, 125; 124, 126; 125, identifier:args; 126, identifier:semantic; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:output_prefix; 130, binary_operator:+; 130, 131; 130, 150; 131, binary_operator:+; 131, 132; 131, 149; 132, subscript; 132, 133; 132, 148; 133, call; 133, 134; 133, 146; 134, attribute; 134, 135; 134, 145; 135, call; 135, 136; 135, 141; 136, attribute; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:os; 139, identifier:path; 140, identifier:basename; 141, argument_list; 141, 142; 142, attribute; 142, 143; 142, 144; 143, identifier:args; 144, identifier:source_file_path; 145, identifier:split; 146, argument_list; 146, 147; 147, string:'.'; 148, integer:0; 149, string:"_vfclust_semantic_"; 150, attribute; 150, 151; 150, 152; 151, identifier:args; 152, identifier:semantic; 153, else_clause; 153, 154; 154, block; 154, 155; 154, 159; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:response_category; 158, string:""; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:output_prefix; 162, string:""; 163, if_statement; 163, 164; 163, 167; 163, 184; 164, attribute; 164, 165; 164, 166; 165, identifier:args; 166, identifier:output_path; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:target_file_path; 171, call; 171, 172; 171, 177; 172, attribute; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:os; 175, identifier:path; 176, identifier:join; 177, argument_list; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:args; 180, identifier:output_path; 181, binary_operator:+; 181, 182; 181, 183; 182, identifier:output_prefix; 183, string:'.csv'; 184, else_clause; 184, 185; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:target_file_path; 189, False; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:engine; 193, call; 193, 194; 193, 195; 194, identifier:VFClustEngine; 195, argument_list; 195, 196; 195, 199; 195, 204; 195, 207; 195, 212; 195, 217; 196, keyword_argument; 196, 197; 196, 198; 197, identifier:response_category; 198, identifier:response_category; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:response_file_path; 201, attribute; 201, 202; 201, 203; 202, identifier:args; 203, identifier:source_file_path; 204, keyword_argument; 204, 205; 204, 206; 205, identifier:target_file_path; 206, identifier:target_file_path; 207, keyword_argument; 207, 208; 207, 209; 208, identifier:quiet; 209, attribute; 209, 210; 209, 211; 210, identifier:args; 211, identifier:quiet; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:similarity_file; 214, attribute; 214, 215; 214, 216; 215, identifier:args; 216, identifier:similarity_file; 217, keyword_argument; 217, 218; 217, 219; 218, identifier:threshold; 219, attribute; 219, 220; 219, 221; 220, identifier:args; 221, identifier:threshold; 222, return_statement; 222, 223; 223, call; 223, 224; 223, 225; 224, identifier:dict; 225, argument_list; 225, 226; 226, attribute; 226, 227; 226, 228; 227, identifier:engine; 228, identifier:measures | def get_duration_measures(source_file_path,
output_path=None,
phonemic=False,
semantic=False,
quiet=False,
similarity_file = None,
threshold = None):
args = Args()
args.output_path = output_path
args.phonemic = phonemic
args.semantic = semantic
args.source_file_path = source_file_path
args.quiet = quiet
args.similarity_file = similarity_file
args.threshold = threshold
args = validate_arguments(args)
if args.phonemic:
response_category = args.phonemic
output_prefix = os.path.basename(args.source_file_path).split('.')[0] + "_vfclust_phonemic_" + args.phonemic
elif args.semantic:
response_category = args.semantic
output_prefix = os.path.basename(args.source_file_path).split('.')[0] + "_vfclust_semantic_" + args.semantic
else:
response_category = ""
output_prefix = ""
if args.output_path:
target_file_path = os.path.join(args.output_path, output_prefix + '.csv')
else:
target_file_path = False
engine = VFClustEngine(response_category=response_category,
response_file_path=args.source_file_path,
target_file_path=target_file_path,
quiet = args.quiet,
similarity_file = args.similarity_file,
threshold = args.threshold
)
return dict(engine.measures) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:tokenize; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 16; 5, 20; 5, 53; 5, 57; 5, 61; 6, if_statement; 6, 7; 6, 11; 7, not_operator; 7, 8; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:quiet; 11, block; 11, 12; 11, 14; 12, expression_statement; 12, 13; 13, identifier:print; 14, print_statement; 14, 15; 15, string:"Finding compound words..."; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:compound_word_dict; 19, dictionary; 20, for_statement; 20, 21; 20, 22; 20, 29; 21, identifier:compound_length; 22, call; 22, 23; 22, 24; 23, identifier:range; 24, argument_list; 24, 25; 24, 26; 24, 27; 25, integer:5; 26, integer:1; 27, unary_operator:-; 27, 28; 28, integer:1; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, subscript; 32, 33; 32, 34; 33, identifier:compound_word_dict; 34, identifier:compound_length; 35, list_comprehension; 35, 36; 35, 37; 35, 42; 36, identifier:name; 37, for_in_clause; 37, 38; 37, 39; 38, identifier:name; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:names; 42, if_clause; 42, 43; 43, comparison_operator:==; 43, 44; 43, 52; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:name; 50, identifier:split; 51, argument_list; 52, identifier:compound_length; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:current_index; 56, integer:0; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:finished; 60, False; 61, while_statement; 61, 62; 61, 64; 62, not_operator; 62, 63; 63, identifier:finished; 64, block; 64, 65; 65, for_statement; 65, 66; 65, 67; 65, 74; 65, 146; 66, identifier:compound_length; 67, call; 67, 68; 67, 69; 68, identifier:range; 69, argument_list; 69, 70; 69, 71; 69, 72; 70, integer:5; 71, integer:1; 72, unary_operator:-; 72, 73; 73, integer:1; 74, block; 74, 75; 75, if_statement; 75, 76; 75, 88; 76, comparison_operator:<; 76, 77; 76, 82; 77, binary_operator:-; 77, 78; 77, 81; 78, binary_operator:+; 78, 79; 78, 80; 79, identifier:current_index; 80, identifier:compound_length; 81, integer:1; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:unit_list; 88, block; 88, 89; 88, 93; 88, 114; 88, 122; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:compound_word; 92, string:""; 93, for_statement; 93, 94; 93, 95; 93, 105; 94, identifier:word; 95, subscript; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:unit_list; 99, slice; 99, 100; 99, 101; 99, 102; 100, identifier:current_index; 101, colon; 102, binary_operator:+; 102, 103; 102, 104; 103, identifier:current_index; 104, identifier:compound_length; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, augmented_assignment:+=; 107, 108; 107, 109; 108, identifier:compound_word; 109, binary_operator:+; 109, 110; 109, 111; 110, string:" "; 111, attribute; 111, 112; 111, 113; 112, identifier:word; 113, identifier:text; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:compound_word; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:compound_word; 120, identifier:strip; 121, argument_list; 122, if_statement; 122, 123; 122, 128; 123, comparison_operator:in; 123, 124; 123, 125; 124, identifier:compound_word; 125, subscript; 125, 126; 125, 127; 126, identifier:compound_word_dict; 127, identifier:compound_length; 128, block; 128, 129; 128, 141; 128, 145; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:make_compound_word; 134, argument_list; 134, 135; 134, 138; 135, keyword_argument; 135, 136; 135, 137; 136, identifier:start_index; 137, identifier:current_index; 138, keyword_argument; 138, 139; 138, 140; 139, identifier:how_many; 140, identifier:compound_length; 141, expression_statement; 141, 142; 142, augmented_assignment:+=; 142, 143; 142, 144; 143, identifier:current_index; 144, integer:1; 145, break_statement; 146, else_clause; 146, 147; 147, block; 147, 148; 147, 152; 148, expression_statement; 148, 149; 149, augmented_assignment:+=; 149, 150; 149, 151; 150, identifier:current_index; 151, integer:1; 152, if_statement; 152, 153; 152, 161; 153, comparison_operator:>=; 153, 154; 153, 155; 154, identifier:current_index; 155, call; 155, 156; 155, 157; 156, identifier:len; 157, argument_list; 157, 158; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:unit_list; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:finished; 165, True | def tokenize(self):
if not self.quiet:
print
print "Finding compound words..."
compound_word_dict = {}
for compound_length in range(5,1,-1):
compound_word_dict[compound_length] = [name for name in self.names if len(name.split()) == compound_length]
current_index = 0
finished = False
while not finished:
for compound_length in range(5,1,-1):
if current_index + compound_length - 1 < len(self.unit_list):
compound_word = ""
for word in self.unit_list[current_index:current_index + compound_length]:
compound_word += " " + word.text
compound_word = compound_word.strip()
if compound_word in compound_word_dict[compound_length]:
self.make_compound_word(start_index = current_index, how_many = compound_length)
current_index += 1
break
else:
current_index += 1
if current_index >= len(self.unit_list):
finished = True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:clean; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 24; 5, 34; 5, 38; 5, 133; 5, 137; 5, 141; 5, 198; 5, 263; 6, if_statement; 6, 7; 6, 11; 7, not_operator; 7, 8; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:quiet; 11, block; 11, 12; 11, 14; 11, 16; 11, 18; 12, expression_statement; 12, 13; 13, identifier:print; 14, print_statement; 14, 15; 15, string:"Preprocessing input..."; 16, print_statement; 16, 17; 17, string:"Raw response:"; 18, print_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:display; 23, argument_list; 24, if_statement; 24, 25; 24, 29; 25, not_operator; 25, 26; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:quiet; 29, block; 29, 30; 29, 32; 30, expression_statement; 30, 31; 31, identifier:print; 32, print_statement; 32, 33; 33, string:"Cleaning words..."; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:current_index; 37, integer:0; 38, while_statement; 38, 39; 38, 47; 39, comparison_operator:<; 39, 40; 39, 41; 40, identifier:current_index; 41, call; 41, 42; 41, 43; 42, identifier:len; 43, argument_list; 43, 44; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:unit_list; 47, block; 47, 48; 47, 58; 47, 114; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:word; 51, attribute; 51, 52; 51, 57; 52, subscript; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:unit_list; 56, identifier:current_index; 57, identifier:text; 58, if_statement; 58, 59; 58, 64; 58, 99; 59, comparison_operator:==; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:type; 63, string:"PHONETIC"; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:test; 68, parenthesized_expression; 68, 69; 69, boolean_operator:and; 69, 70; 69, 90; 70, boolean_operator:and; 70, 71; 70, 87; 71, boolean_operator:and; 71, 72; 71, 80; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:word; 75, identifier:startswith; 76, argument_list; 76, 77; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:letter_or_category; 80, not_operator; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:word; 84, identifier:endswith; 85, argument_list; 85, 86; 86, string:'-'; 87, comparison_operator:not; 87, 88; 87, 89; 88, string:'_'; 89, identifier:word; 90, comparison_operator:in; 90, 91; 90, 96; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:word; 94, identifier:lower; 95, argument_list; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:english_words; 99, elif_clause; 99, 100; 99, 105; 100, comparison_operator:==; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:type; 104, string:"SEMANTIC"; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:test; 109, comparison_operator:in; 109, 110; 109, 111; 110, identifier:word; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:permissible_words; 114, if_statement; 114, 115; 114, 117; 114, 127; 115, not_operator; 115, 116; 116, identifier:test; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:remove_unit; 123, argument_list; 123, 124; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:index; 126, identifier:current_index; 127, else_clause; 127, 128; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, augmented_assignment:+=; 130, 131; 130, 132; 131, identifier:current_index; 132, integer:1; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:current_index; 136, integer:0; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:finished; 140, False; 141, while_statement; 141, 142; 141, 152; 142, comparison_operator:<; 142, 143; 142, 144; 143, identifier:current_index; 144, binary_operator:-; 144, 145; 144, 151; 145, call; 145, 146; 145, 147; 146, identifier:len; 147, argument_list; 147, 148; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:unit_list; 151, integer:1; 152, block; 152, 153; 153, if_statement; 153, 154; 153, 182; 153, 192; 154, comparison_operator:==; 154, 155; 154, 167; 154, 168; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:stemmer; 158, identifier:stem; 159, argument_list; 159, 160; 160, attribute; 160, 161; 160, 166; 161, subscript; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:unit_list; 165, identifier:current_index; 166, identifier:text; 167, line_continuation:\; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:stemmer; 171, identifier:stem; 172, argument_list; 172, 173; 173, attribute; 173, 174; 173, 181; 174, subscript; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:unit_list; 178, binary_operator:+; 178, 179; 178, 180; 179, identifier:current_index; 180, integer:1; 181, identifier:text; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:combine_same_stem_units; 188, argument_list; 188, 189; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:index; 191, identifier:current_index; 192, else_clause; 192, 193; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, augmented_assignment:+=; 195, 196; 195, 197; 196, identifier:current_index; 197, integer:1; 198, if_statement; 198, 199; 198, 204; 199, comparison_operator:==; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:type; 203, string:"PHONETIC"; 204, block; 204, 205; 205, for_statement; 205, 206; 205, 207; 205, 210; 206, identifier:unit; 207, attribute; 207, 208; 207, 209; 208, identifier:self; 209, identifier:unit_list; 210, block; 210, 211; 210, 217; 210, 232; 210, 257; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:word; 214, attribute; 214, 215; 214, 216; 215, identifier:unit; 216, identifier:text; 217, if_statement; 217, 218; 217, 223; 218, comparison_operator:in; 218, 219; 218, 220; 219, identifier:word; 220, attribute; 220, 221; 220, 222; 221, identifier:self; 222, identifier:cmudict; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:phonetic_representation; 227, subscript; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:self; 230, identifier:cmudict; 231, identifier:word; 232, if_statement; 232, 233; 232, 238; 233, comparison_operator:not; 233, 234; 233, 235; 234, identifier:word; 235, attribute; 235, 236; 235, 237; 236, identifier:self; 237, identifier:cmudict; 238, block; 238, 239; 238, 248; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:phonetic_representation; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:generate_phonetic_representation; 246, argument_list; 246, 247; 247, identifier:word; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 251; 250, identifier:phonetic_representation; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:self; 254, identifier:modify_phonetic_representation; 255, argument_list; 255, 256; 256, identifier:phonetic_representation; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:unit; 261, identifier:phonetic_representation; 262, identifier:phonetic_representation; 263, if_statement; 263, 264; 263, 268; 264, not_operator; 264, 265; 265, attribute; 265, 266; 265, 267; 266, identifier:self; 267, identifier:quiet; 268, block; 268, 269; 268, 271; 268, 273; 269, expression_statement; 269, 270; 270, identifier:print; 271, print_statement; 271, 272; 272, string:"Cleaned response:"; 273, print_statement; 273, 274; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:self; 277, identifier:display; 278, argument_list | def clean(self):
if not self.quiet:
print
print "Preprocessing input..."
print "Raw response:"
print self.display()
if not self.quiet:
print
print "Cleaning words..."
current_index = 0
while current_index < len(self.unit_list):
word = self.unit_list[current_index].text
if self.type == "PHONETIC":
test = (word.startswith(self.letter_or_category) and
not word.endswith('-') and
'_' not in word and
word.lower() in self.english_words)
elif self.type == "SEMANTIC":
test = word in self.permissible_words
if not test:
self.remove_unit(index = current_index)
else:
current_index += 1
current_index = 0
finished = False
while current_index < len(self.unit_list) - 1:
if stemmer.stem(self.unit_list[current_index].text) == \
stemmer.stem(self.unit_list[current_index + 1].text):
self.combine_same_stem_units(index = current_index)
else:
current_index += 1
if self.type == "PHONETIC":
for unit in self.unit_list:
word = unit.text
if word in self.cmudict:
phonetic_representation = self.cmudict[word]
if word not in self.cmudict:
phonetic_representation = self.generate_phonetic_representation(word)
phonetic_representation = self.modify_phonetic_representation(phonetic_representation)
unit.phonetic_representation = phonetic_representation
if not self.quiet:
print
print "Cleaned response:"
print self.display() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.