sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:formatFlow; 3, parameters; 3, 4; 4, identifier:s; 5, block; 5, 6; 5, 10; 5, 14; 5, 18; 5, 22; 5, 75; 5, 84; 5, 245; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:result; 9, string:""; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:shifts; 13, list:[]; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:pos; 17, integer:0; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:nextIsList; 21, False; 22, function_definition; 22, 23; 22, 24; 22, 28; 23, function_name:IsNextList; 24, parameters; 24, 25; 24, 26; 24, 27; 25, identifier:index; 26, identifier:maxIndex; 27, identifier:buf; 28, block; 28, 29; 28, 36; 28, 47; 28, 73; 29, if_statement; 29, 30; 29, 33; 30, comparison_operator:==; 30, 31; 30, 32; 31, identifier:index; 32, identifier:maxIndex; 33, block; 33, 34; 34, return_statement; 34, 35; 35, False; 36, if_statement; 36, 37; 36, 44; 37, comparison_operator:==; 37, 38; 37, 43; 38, subscript; 38, 39; 38, 40; 39, identifier:buf; 40, binary_operator:+; 40, 41; 40, 42; 41, identifier:index; 42, integer:1; 43, string:'<'; 44, block; 44, 45; 45, return_statement; 45, 46; 46, True; 47, if_statement; 47, 48; 47, 53; 48, comparison_operator:<; 48, 49; 48, 50; 49, identifier:index; 50, binary_operator:-; 50, 51; 50, 52; 51, identifier:maxIndex; 52, integer:1; 53, block; 53, 54; 54, if_statement; 54, 55; 54, 70; 55, boolean_operator:and; 55, 56; 55, 63; 56, comparison_operator:==; 56, 57; 56, 62; 57, subscript; 57, 58; 57, 59; 58, identifier:buf; 59, binary_operator:+; 59, 60; 59, 61; 60, identifier:index; 61, integer:1; 62, string:'\n'; 63, comparison_operator:==; 63, 64; 63, 69; 64, subscript; 64, 65; 64, 66; 65, identifier:buf; 66, binary_operator:+; 66, 67; 66, 68; 67, identifier:index; 68, integer:2; 69, string:'<'; 70, block; 70, 71; 71, return_statement; 71, 72; 72, True; 73, return_statement; 73, 74; 74, False; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:maxIndex; 78, binary_operator:-; 78, 79; 78, 83; 79, call; 79, 80; 79, 81; 80, identifier:len; 81, argument_list; 81, 82; 82, identifier:s; 83, integer:1; 84, for_statement; 84, 85; 84, 86; 84, 93; 85, identifier:index; 86, call; 86, 87; 86, 88; 87, identifier:range; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:len; 91, argument_list; 91, 92; 92, identifier:s; 93, block; 93, 94; 93, 100; 93, 147; 93, 179; 93, 237; 93, 241; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:sym; 97, subscript; 97, 98; 97, 99; 98, identifier:s; 99, identifier:index; 100, if_statement; 100, 101; 100, 104; 101, comparison_operator:==; 101, 102; 101, 103; 102, identifier:sym; 103, string:"\n"; 104, block; 104, 105; 104, 112; 104, 120; 104, 124; 104, 146; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:lastShift; 108, subscript; 108, 109; 108, 110; 109, identifier:shifts; 110, unary_operator:-; 110, 111; 111, integer:1; 112, expression_statement; 112, 113; 113, augmented_assignment:+=; 113, 114; 113, 115; 114, identifier:result; 115, binary_operator:+; 115, 116; 115, 117; 116, identifier:sym; 117, binary_operator:*; 117, 118; 117, 119; 118, identifier:lastShift; 119, string:" "; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:pos; 123, identifier:lastShift; 124, if_statement; 124, 125; 124, 128; 125, comparison_operator:<; 125, 126; 125, 127; 126, identifier:index; 127, identifier:maxIndex; 128, block; 128, 129; 129, if_statement; 129, 130; 129, 137; 130, comparison_operator:not; 130, 131; 130, 136; 131, subscript; 131, 132; 131, 133; 132, identifier:s; 133, binary_operator:+; 133, 134; 133, 135; 134, identifier:index; 135, integer:1; 136, string:"<>"; 137, block; 137, 138; 137, 142; 138, expression_statement; 138, 139; 139, augmented_assignment:+=; 139, 140; 139, 141; 140, identifier:result; 141, string:" "; 142, expression_statement; 142, 143; 143, augmented_assignment:+=; 143, 144; 143, 145; 144, identifier:pos; 145, integer:1; 146, continue_statement; 147, if_statement; 147, 148; 147, 151; 148, comparison_operator:==; 148, 149; 148, 150; 149, identifier:sym; 150, string:"<"; 151, block; 151, 152; 151, 170; 151, 174; 151, 178; 152, if_statement; 152, 153; 152, 156; 152, 164; 153, comparison_operator:==; 153, 154; 153, 155; 154, identifier:nextIsList; 155, False; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:shifts; 161, identifier:append; 162, argument_list; 162, 163; 163, identifier:pos; 164, else_clause; 164, 165; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:nextIsList; 169, False; 170, expression_statement; 170, 171; 171, augmented_assignment:+=; 171, 172; 171, 173; 172, identifier:pos; 173, integer:1; 174, expression_statement; 174, 175; 175, augmented_assignment:+=; 175, 176; 175, 177; 176, identifier:result; 177, identifier:sym; 178, continue_statement; 179, if_statement; 179, 180; 179, 183; 180, comparison_operator:==; 180, 181; 180, 182; 181, identifier:sym; 182, string:">"; 183, block; 183, 184; 183, 191; 183, 195; 183, 201; 183, 205; 183, 209; 183, 213; 183, 236; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:shift; 187, subscript; 187, 188; 187, 189; 188, identifier:shifts; 189, unary_operator:-; 189, 190; 190, integer:1; 191, expression_statement; 191, 192; 192, augmented_assignment:+=; 192, 193; 192, 194; 193, identifier:result; 194, string:'\n'; 195, expression_statement; 195, 196; 196, augmented_assignment:+=; 196, 197; 196, 198; 197, identifier:result; 198, binary_operator:*; 198, 199; 198, 200; 199, identifier:shift; 200, string:" "; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:pos; 204, identifier:shift; 205, expression_statement; 205, 206; 206, augmented_assignment:+=; 206, 207; 206, 208; 207, identifier:result; 208, identifier:sym; 209, expression_statement; 209, 210; 210, augmented_assignment:+=; 210, 211; 210, 212; 211, identifier:pos; 212, integer:1; 213, if_statement; 213, 214; 213, 220; 213, 225; 214, call; 214, 215; 214, 216; 215, identifier:IsNextList; 216, argument_list; 216, 217; 216, 218; 216, 219; 217, identifier:index; 218, identifier:maxIndex; 219, identifier:s; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:nextIsList; 224, True; 225, else_clause; 225, 226; 226, block; 226, 227; 226, 232; 227, delete_statement; 227, 228; 228, subscript; 228, 229; 228, 230; 229, identifier:shifts; 230, unary_operator:-; 230, 231; 231, integer:1; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:nextIsList; 235, False; 236, continue_statement; 237, expression_statement; 237, 238; 238, augmented_assignment:+=; 238, 239; 238, 240; 239, identifier:result; 240, identifier:sym; 241, expression_statement; 241, 242; 242, augmented_assignment:+=; 242, 243; 242, 244; 243, identifier:pos; 244, integer:1; 245, return_statement; 245, 246; 246, identifier:result | def formatFlow(s):
result = ""
shifts = []
pos = 0
nextIsList = False
def IsNextList(index, maxIndex, buf):
if index == maxIndex:
return False
if buf[index + 1] == '<':
return True
if index < maxIndex - 1:
if buf[index + 1] == '\n' and buf[index + 2] == '<':
return True
return False
maxIndex = len(s) - 1
for index in range(len(s)):
sym = s[index]
if sym == "\n":
lastShift = shifts[-1]
result += sym + lastShift * " "
pos = lastShift
if index < maxIndex:
if s[index + 1] not in "<>":
result += " "
pos += 1
continue
if sym == "<":
if nextIsList == False:
shifts.append(pos)
else:
nextIsList = False
pos += 1
result += sym
continue
if sym == ">":
shift = shifts[-1]
result += '\n'
result += shift * " "
pos = shift
result += sym
pos += 1
if IsNextList(index, maxIndex, s):
nextIsList = True
else:
del shifts[-1]
nextIsList = False
continue
result += sym
pos += 1
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:train; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:training_set; 6, default_parameter; 6, 7; 6, 8; 7, identifier:iterations; 8, integer:500; 9, block; 9, 10; 9, 177; 9, 189; 9, 201; 9, 210; 9, 221; 9, 232; 9, 236; 9, 311; 9, 320; 10, if_statement; 10, 11; 10, 17; 10, 99; 11, comparison_operator:>; 11, 12; 11, 16; 12, call; 12, 13; 12, 14; 13, identifier:len; 14, argument_list; 14, 15; 15, identifier:training_set; 16, integer:2; 17, block; 17, 18; 17, 35; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:__X; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:np; 26, identifier:matrix; 27, argument_list; 27, 28; 28, list_comprehension; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:example; 31, integer:0; 32, for_in_clause; 32, 33; 32, 34; 33, identifier:example; 34, identifier:training_set; 35, if_statement; 35, 36; 35, 41; 35, 67; 36, comparison_operator:==; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:__num_labels; 40, integer:1; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:__y; 47, call; 47, 48; 47, 62; 48, attribute; 48, 49; 48, 61; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:np; 52, identifier:matrix; 53, argument_list; 53, 54; 54, list_comprehension; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:example; 57, integer:1; 58, for_in_clause; 58, 59; 58, 60; 59, identifier:example; 60, identifier:training_set; 61, identifier:reshape; 62, argument_list; 62, 63; 63, tuple; 63, 64; 63, 66; 64, unary_operator:-; 64, 65; 65, integer:1; 66, integer:1; 67, else_clause; 67, 68; 68, block; 68, 69; 68, 80; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:eye; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:np; 75, identifier:eye; 76, argument_list; 76, 77; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:__num_labels; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:__y; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:np; 88, identifier:matrix; 89, argument_list; 89, 90; 90, list_comprehension; 90, 91; 90, 96; 91, subscript; 91, 92; 91, 93; 92, identifier:eye; 93, subscript; 93, 94; 93, 95; 94, identifier:example; 95, integer:1; 96, for_in_clause; 96, 97; 96, 98; 97, identifier:example; 98, identifier:training_set; 99, else_clause; 99, 100; 100, block; 100, 101; 100, 114; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:__X; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:np; 109, identifier:matrix; 110, argument_list; 110, 111; 111, subscript; 111, 112; 111, 113; 112, identifier:training_set; 113, integer:0; 114, if_statement; 114, 115; 114, 120; 114, 142; 115, comparison_operator:==; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:__num_labels; 119, integer:1; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:__y; 126, call; 126, 127; 126, 137; 127, attribute; 127, 128; 127, 136; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:np; 131, identifier:matrix; 132, argument_list; 132, 133; 133, subscript; 133, 134; 133, 135; 134, identifier:training_set; 135, integer:1; 136, identifier:reshape; 137, argument_list; 137, 138; 138, tuple; 138, 139; 138, 141; 139, unary_operator:-; 139, 140; 140, integer:1; 141, integer:1; 142, else_clause; 142, 143; 143, block; 143, 144; 143, 155; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:eye; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:np; 150, identifier:eye; 151, argument_list; 151, 152; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:__num_labels; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:__y; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:np; 163, identifier:matrix; 164, argument_list; 164, 165; 165, list_comprehension; 165, 166; 165, 169; 165, 174; 166, subscript; 166, 167; 166, 168; 167, identifier:eye; 168, identifier:index; 169, for_in_clause; 169, 170; 169, 171; 170, identifier:sublist; 171, subscript; 171, 172; 171, 173; 172, identifier:training_set; 173, integer:1; 174, for_in_clause; 174, 175; 174, 176; 175, identifier:index; 176, identifier:sublist; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:self; 181, identifier:__m; 182, subscript; 182, 183; 182, 188; 183, attribute; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:__X; 187, identifier:shape; 188, integer:0; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:self; 193, identifier:__input_layer_size; 194, subscript; 194, 195; 194, 200; 195, attribute; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:__X; 199, identifier:shape; 200, integer:1; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:self; 205, identifier:__sizes; 206, list:[self.__input_layer_size]; 206, 207; 207, attribute; 207, 208; 207, 209; 208, identifier:self; 209, identifier:__input_layer_size; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 217; 212, attribute; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:self; 215, identifier:__sizes; 216, identifier:extend; 217, argument_list; 217, 218; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:__hidden_layers; 221, expression_statement; 221, 222; 222, call; 222, 223; 222, 228; 223, attribute; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:self; 226, identifier:__sizes; 227, identifier:append; 228, argument_list; 228, 229; 229, attribute; 229, 230; 229, 231; 230, identifier:self; 231, identifier:__num_labels; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:initial_theta; 235, list:[]; 236, for_statement; 236, 237; 236, 238; 236, 249; 237, identifier:count; 238, call; 238, 239; 238, 240; 239, identifier:range; 240, argument_list; 240, 241; 241, binary_operator:-; 241, 242; 241, 248; 242, call; 242, 243; 242, 244; 243, identifier:len; 244, argument_list; 244, 245; 245, attribute; 245, 246; 245, 247; 246, identifier:self; 247, identifier:__sizes; 248, integer:1; 249, block; 249, 250; 249, 278; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:epsilon; 253, binary_operator:/; 253, 254; 253, 260; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:np; 257, identifier:sqrt; 258, argument_list; 258, 259; 259, integer:6; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:np; 263, identifier:sqrt; 264, argument_list; 264, 265; 265, binary_operator:+; 265, 266; 265, 271; 266, subscript; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:self; 269, identifier:__sizes; 270, identifier:count; 271, subscript; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:self; 274, identifier:__sizes; 275, binary_operator:+; 275, 276; 275, 277; 276, identifier:count; 277, integer:1; 278, expression_statement; 278, 279; 279, call; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:initial_theta; 282, identifier:append; 283, argument_list; 283, 284; 284, binary_operator:-; 284, 285; 284, 310; 285, binary_operator:*; 285, 286; 285, 309; 286, binary_operator:*; 286, 287; 286, 308; 287, call; 287, 288; 287, 293; 288, attribute; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:np; 291, identifier:random; 292, identifier:rand; 293, argument_list; 293, 294; 293, 301; 294, subscript; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:self; 297, identifier:__sizes; 298, binary_operator:+; 298, 299; 298, 300; 299, identifier:count; 300, integer:1; 301, binary_operator:+; 301, 302; 301, 307; 302, subscript; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:self; 305, identifier:__sizes; 306, identifier:count; 307, integer:1; 308, integer:2; 309, identifier:epsilon; 310, identifier:epsilon; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:initial_theta; 314, call; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, identifier:self; 317, identifier:__unroll; 318, argument_list; 318, 319; 319, identifier:initial_theta; 320, expression_statement; 320, 321; 321, assignment; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, identifier:self; 324, identifier:__thetas; 325, call; 325, 326; 325, 329; 326, attribute; 326, 327; 326, 328; 327, identifier:self; 328, identifier:__roll; 329, argument_list; 329, 330; 330, call; 330, 331; 330, 332; 331, identifier:fmin_bfgs; 332, argument_list; 332, 333; 332, 336; 332, 337; 332, 342; 333, attribute; 333, 334; 333, 335; 334, identifier:self; 335, identifier:__cost_function; 336, identifier:initial_theta; 337, keyword_argument; 337, 338; 337, 339; 338, identifier:fprime; 339, attribute; 339, 340; 339, 341; 340, identifier:self; 341, identifier:__cost_grad_function; 342, keyword_argument; 342, 343; 342, 344; 343, identifier:maxiter; 344, identifier:iterations | def train(self, training_set, iterations=500):
if len(training_set) > 2:
self.__X = np.matrix([example[0] for example in training_set])
if self.__num_labels == 1:
self.__y = np.matrix([example[1] for example in training_set]).reshape((-1, 1))
else:
eye = np.eye(self.__num_labels)
self.__y = np.matrix([eye[example[1]] for example in training_set])
else:
self.__X = np.matrix(training_set[0])
if self.__num_labels == 1:
self.__y = np.matrix(training_set[1]).reshape((-1, 1))
else:
eye = np.eye(self.__num_labels)
self.__y = np.matrix([eye[index] for sublist in training_set[1] for index in sublist])
self.__m = self.__X.shape[0]
self.__input_layer_size = self.__X.shape[1]
self.__sizes = [self.__input_layer_size]
self.__sizes.extend(self.__hidden_layers)
self.__sizes.append(self.__num_labels)
initial_theta = []
for count in range(len(self.__sizes) - 1):
epsilon = np.sqrt(6) / np.sqrt(self.__sizes[count]+self.__sizes[count+1])
initial_theta.append(np.random.rand(self.__sizes[count+1],self.__sizes[count]+1)*2*epsilon-epsilon)
initial_theta = self.__unroll(initial_theta)
self.__thetas = self.__roll(fmin_bfgs(self.__cost_function, initial_theta, fprime=self.__cost_grad_function, maxiter=iterations)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:__cost; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:params; 6, identifier:phase; 7, identifier:X; 8, block; 8, 9; 8, 18; 8, 43; 8, 48; 8, 53; 8, 133; 8, 168; 8, 220; 8, 268; 8, 275; 8, 279; 8, 283; 8, 437; 8, 449; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:params; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:__roll; 16, argument_list; 16, 17; 17, identifier:params; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:a; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:concatenate; 25, argument_list; 25, 26; 25, 40; 26, tuple; 26, 27; 26, 39; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:np; 30, identifier:ones; 31, argument_list; 31, 32; 32, tuple; 32, 33; 32, 38; 33, subscript; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:X; 36, identifier:shape; 37, integer:0; 38, integer:1; 39, identifier:X; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:axis; 42, integer:1; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:calculated_a; 46, list:[a]; 46, 47; 47, identifier:a; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:calculated_z; 51, list:[0]; 51, 52; 52, integer:0; 53, for_statement; 53, 54; 53, 57; 53, 61; 54, pattern_list; 54, 55; 54, 56; 55, identifier:i; 56, identifier:theta; 57, call; 57, 58; 57, 59; 58, identifier:enumerate; 59, argument_list; 59, 60; 60, identifier:params; 61, block; 61, 62; 61, 75; 61, 82; 61, 91; 61, 126; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:z; 65, binary_operator:*; 65, 66; 65, 70; 66, subscript; 66, 67; 66, 68; 67, identifier:calculated_a; 68, unary_operator:-; 68, 69; 69, integer:1; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:theta; 73, identifier:transpose; 74, argument_list; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:calculated_z; 79, identifier:append; 80, argument_list; 80, 81; 81, identifier:z; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:a; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:sigmoid; 89, argument_list; 89, 90; 90, identifier:z; 91, if_statement; 91, 92; 91, 100; 92, comparison_operator:!=; 92, 93; 92, 94; 93, identifier:i; 94, binary_operator:-; 94, 95; 94, 99; 95, call; 95, 96; 95, 97; 96, identifier:len; 97, argument_list; 97, 98; 98, identifier:params; 99, integer:1; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:a; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:np; 107, identifier:concatenate; 108, argument_list; 108, 109; 108, 123; 109, tuple; 109, 110; 109, 122; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:np; 113, identifier:ones; 114, argument_list; 114, 115; 115, tuple; 115, 116; 115, 121; 116, subscript; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:a; 119, identifier:shape; 120, integer:0; 121, integer:1; 122, identifier:a; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:axis; 125, integer:1; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:calculated_a; 130, identifier:append; 131, argument_list; 131, 132; 132, identifier:a; 133, if_statement; 133, 134; 133, 137; 134, comparison_operator:==; 134, 135; 134, 136; 135, identifier:phase; 136, integer:0; 137, block; 137, 138; 137, 158; 138, if_statement; 138, 139; 138, 144; 139, comparison_operator:>; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:self; 142, identifier:__num_labels; 143, integer:1; 144, block; 144, 145; 145, return_statement; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:np; 149, identifier:argmax; 150, argument_list; 150, 151; 150, 155; 151, subscript; 151, 152; 151, 153; 152, identifier:calculated_a; 153, unary_operator:-; 153, 154; 154, integer:1; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:axis; 157, integer:1; 158, return_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:np; 162, identifier:round; 163, argument_list; 163, 164; 164, subscript; 164, 165; 164, 166; 165, identifier:calculated_a; 166, unary_operator:-; 166, 167; 167, integer:1; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:J; 171, binary_operator:/; 171, 172; 171, 217; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:np; 175, identifier:sum; 176, argument_list; 176, 177; 177, binary_operator:-; 177, 178; 177, 196; 178, unary_operator:-; 178, 179; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:np; 182, identifier:multiply; 183, argument_list; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:__y; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:np; 190, identifier:log; 191, argument_list; 191, 192; 192, subscript; 192, 193; 192, 194; 193, identifier:calculated_a; 194, unary_operator:-; 194, 195; 195, integer:1; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:np; 199, identifier:multiply; 200, argument_list; 200, 201; 200, 206; 201, binary_operator:-; 201, 202; 201, 203; 202, integer:1; 203, attribute; 203, 204; 203, 205; 204, identifier:self; 205, identifier:__y; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:np; 209, identifier:log; 210, argument_list; 210, 211; 211, binary_operator:-; 211, 212; 211, 213; 212, integer:1; 213, subscript; 213, 214; 213, 215; 214, identifier:calculated_a; 215, unary_operator:-; 215, 216; 216, integer:1; 217, attribute; 217, 218; 217, 219; 218, identifier:self; 219, identifier:__m; 220, if_statement; 220, 221; 220, 226; 221, comparison_operator:!=; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:self; 224, identifier:__lambda; 225, integer:0; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, augmented_assignment:+=; 228, 229; 228, 230; 229, identifier:J; 230, binary_operator:/; 230, 231; 230, 262; 231, binary_operator:*; 231, 232; 231, 259; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:np; 235, identifier:sum; 236, argument_list; 236, 237; 237, list_comprehension; 237, 238; 237, 256; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:np; 241, identifier:sum; 242, argument_list; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:np; 246, identifier:power; 247, argument_list; 247, 248; 247, 255; 248, subscript; 248, 249; 248, 250; 248, 252; 249, identifier:theta; 250, slice; 250, 251; 251, colon; 252, slice; 252, 253; 252, 254; 253, integer:1; 254, colon; 255, integer:2; 256, for_in_clause; 256, 257; 256, 258; 257, identifier:theta; 258, identifier:params; 259, attribute; 259, 260; 259, 261; 260, identifier:self; 261, identifier:__lambda; 262, parenthesized_expression; 262, 263; 263, binary_operator:*; 263, 264; 263, 265; 264, float:2.0; 265, attribute; 265, 266; 265, 267; 266, identifier:self; 267, identifier:__m; 268, if_statement; 268, 269; 268, 272; 269, comparison_operator:==; 269, 270; 269, 271; 270, identifier:phase; 271, integer:1; 272, block; 272, 273; 273, return_statement; 273, 274; 274, identifier:J; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 278; 277, identifier:reversed_d; 278, list:[]; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:reversed_theta_grad; 282, list:[]; 283, for_statement; 283, 284; 283, 285; 283, 292; 284, identifier:i; 285, call; 285, 286; 285, 287; 286, identifier:range; 287, argument_list; 287, 288; 288, call; 288, 289; 288, 290; 289, identifier:len; 290, argument_list; 290, 291; 291, identifier:params; 292, block; 292, 293; 292, 345; 292, 352; 292, 374; 292, 430; 293, if_statement; 293, 294; 293, 297; 293, 309; 294, comparison_operator:==; 294, 295; 294, 296; 295, identifier:i; 296, integer:0; 297, block; 297, 298; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 301; 300, identifier:d; 301, binary_operator:-; 301, 302; 301, 306; 302, subscript; 302, 303; 302, 304; 303, identifier:calculated_a; 304, unary_operator:-; 304, 305; 305, integer:1; 306, attribute; 306, 307; 306, 308; 307, identifier:self; 308, identifier:__y; 309, else_clause; 309, 310; 310, block; 310, 311; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:d; 314, call; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, identifier:np; 317, identifier:multiply; 318, argument_list; 318, 319; 318, 334; 319, binary_operator:*; 319, 320; 319, 324; 320, subscript; 320, 321; 320, 322; 321, identifier:reversed_d; 322, unary_operator:-; 322, 323; 323, integer:1; 324, subscript; 324, 325; 324, 329; 324, 331; 325, subscript; 325, 326; 325, 327; 326, identifier:params; 327, unary_operator:-; 327, 328; 328, identifier:i; 329, slice; 329, 330; 330, colon; 331, slice; 331, 332; 331, 333; 332, integer:1; 333, colon; 334, call; 334, 335; 334, 338; 335, attribute; 335, 336; 335, 337; 336, identifier:self; 337, identifier:sigmoid_grad; 338, argument_list; 338, 339; 339, subscript; 339, 340; 339, 341; 340, identifier:calculated_z; 341, binary_operator:-; 341, 342; 341, 344; 342, unary_operator:-; 342, 343; 343, integer:1; 344, identifier:i; 345, expression_statement; 345, 346; 346, call; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, identifier:reversed_d; 349, identifier:append; 350, argument_list; 350, 351; 351, identifier:d; 352, expression_statement; 352, 353; 353, assignment; 353, 354; 353, 355; 354, identifier:theta_grad; 355, binary_operator:/; 355, 356; 355, 371; 356, binary_operator:*; 356, 357; 356, 365; 357, call; 357, 358; 357, 364; 358, attribute; 358, 359; 358, 363; 359, subscript; 359, 360; 359, 361; 360, identifier:reversed_d; 361, unary_operator:-; 361, 362; 362, integer:1; 363, identifier:transpose; 364, argument_list; 365, subscript; 365, 366; 365, 367; 366, identifier:calculated_a; 367, binary_operator:-; 367, 368; 367, 370; 368, unary_operator:-; 368, 369; 369, identifier:i; 370, integer:2; 371, attribute; 371, 372; 371, 373; 372, identifier:self; 373, identifier:__m; 374, if_statement; 374, 375; 374, 380; 375, comparison_operator:!=; 375, 376; 375, 379; 376, attribute; 376, 377; 376, 378; 377, identifier:self; 378, identifier:__lambda; 379, integer:0; 380, block; 380, 381; 381, expression_statement; 381, 382; 382, augmented_assignment:+=; 382, 383; 382, 384; 383, identifier:theta_grad; 384, binary_operator:/; 384, 385; 384, 427; 385, binary_operator:*; 385, 386; 385, 424; 386, call; 386, 387; 386, 390; 387, attribute; 387, 388; 387, 389; 388, identifier:np; 389, identifier:concatenate; 390, argument_list; 390, 391; 390, 421; 391, tuple; 391, 392; 391, 409; 392, call; 392, 393; 392, 396; 393, attribute; 393, 394; 393, 395; 394, identifier:np; 395, identifier:zeros; 396, argument_list; 396, 397; 397, tuple; 397, 398; 397, 408; 398, subscript; 398, 399; 398, 407; 399, attribute; 399, 400; 399, 406; 400, subscript; 400, 401; 400, 402; 401, identifier:params; 402, binary_operator:-; 402, 403; 402, 405; 403, unary_operator:-; 403, 404; 404, integer:1; 405, identifier:i; 406, identifier:shape; 407, integer:0; 408, integer:1; 409, subscript; 409, 410; 409, 416; 409, 418; 410, subscript; 410, 411; 410, 412; 411, identifier:params; 412, binary_operator:-; 412, 413; 412, 415; 413, unary_operator:-; 413, 414; 414, integer:1; 415, identifier:i; 416, slice; 416, 417; 417, colon; 418, slice; 418, 419; 418, 420; 419, integer:1; 420, colon; 421, keyword_argument; 421, 422; 421, 423; 422, identifier:axis; 423, integer:1; 424, attribute; 424, 425; 424, 426; 425, identifier:self; 426, identifier:__lambda; 427, attribute; 427, 428; 427, 429; 428, identifier:self; 429, identifier:__m; 430, expression_statement; 430, 431; 431, call; 431, 432; 431, 435; 432, attribute; 432, 433; 432, 434; 433, identifier:reversed_theta_grad; 434, identifier:append; 435, argument_list; 435, 436; 436, identifier:theta_grad; 437, expression_statement; 437, 438; 438, assignment; 438, 439; 438, 440; 439, identifier:theta_grad; 440, call; 440, 441; 440, 444; 441, attribute; 441, 442; 441, 443; 442, identifier:self; 443, identifier:__unroll; 444, argument_list; 444, 445; 445, call; 445, 446; 445, 447; 446, identifier:reversed; 447, argument_list; 447, 448; 448, identifier:reversed_theta_grad; 449, return_statement; 449, 450; 450, identifier:theta_grad | def __cost(self, params, phase, X):
params = self.__roll(params)
a = np.concatenate((np.ones((X.shape[0], 1)), X), axis=1)
calculated_a = [a]
calculated_z = [0]
for i, theta in enumerate(params):
z = calculated_a[-1] * theta.transpose()
calculated_z.append(z)
a = self.sigmoid(z)
if i != len(params) - 1:
a = np.concatenate((np.ones((a.shape[0], 1)), a), axis=1)
calculated_a.append(a)
if phase == 0:
if self.__num_labels > 1:
return np.argmax(calculated_a[-1], axis=1)
return np.round(calculated_a[-1])
J = np.sum(-np.multiply(self.__y, np.log(calculated_a[-1]))-np.multiply(1-self.__y, np.log(1-calculated_a[-1])))/self.__m;
if self.__lambda != 0:
J += np.sum([np.sum(np.power(theta[:,1:], 2)) for theta in params])*self.__lambda/(2.0*self.__m)
if phase == 1:
return J
reversed_d = []
reversed_theta_grad = []
for i in range(len(params)):
if i == 0:
d = calculated_a[-1] - self.__y
else:
d = np.multiply(reversed_d[-1]*params[-i][:,1:], self.sigmoid_grad(calculated_z[-1-i]))
reversed_d.append(d)
theta_grad = reversed_d[-1].transpose() * calculated_a[-i-2] / self.__m
if self.__lambda != 0:
theta_grad += np.concatenate((np.zeros((params[-1-i].shape[0], 1)), params[-1-i][:,1:]), axis=1) * self.__lambda / self.__m
reversed_theta_grad.append(theta_grad)
theta_grad = self.__unroll(reversed(reversed_theta_grad))
return theta_grad |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:insert_many; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:it; 6, block; 6, 7; 6, 13; 6, 19; 6, 26; 6, 141; 6, 180; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:unique_indexes; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_uniqueIndexes; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:NO_SUCH_ATTR; 16, call; 16, 17; 16, 18; 17, identifier:object; 18, argument_list; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:new_objs; 22, call; 22, 23; 22, 24; 23, identifier:list; 24, argument_list; 24, 25; 25, identifier:it; 26, if_statement; 26, 27; 26, 28; 27, identifier:unique_indexes; 28, block; 28, 29; 29, for_statement; 29, 30; 29, 31; 29, 32; 30, identifier:ind; 31, identifier:unique_indexes; 32, block; 32, 33; 32, 39; 32, 56; 32, 92; 32, 110; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:ind_attr; 36, attribute; 36, 37; 36, 38; 37, identifier:ind; 38, identifier:attr; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:new_keys; 42, call; 42, 43; 42, 44; 43, identifier:dict; 44, generator_expression; 44, 45; 44, 53; 45, tuple; 45, 46; 45, 52; 46, call; 46, 47; 46, 48; 47, identifier:getattr; 48, argument_list; 48, 49; 48, 50; 48, 51; 49, identifier:obj; 50, identifier:ind_attr; 51, identifier:NO_SUCH_ATTR; 52, identifier:obj; 53, for_in_clause; 53, 54; 53, 55; 54, identifier:obj; 55, identifier:new_objs; 56, if_statement; 56, 57; 56, 70; 57, boolean_operator:and; 57, 58; 57, 62; 58, not_operator; 58, 59; 59, attribute; 59, 60; 59, 61; 60, identifier:ind; 61, identifier:accept_none; 62, parenthesized_expression; 62, 63; 63, boolean_operator:or; 63, 64; 63, 67; 64, comparison_operator:in; 64, 65; 64, 66; 65, None; 66, identifier:new_keys; 67, comparison_operator:in; 67, 68; 67, 69; 68, identifier:NO_SUCH_ATTR; 69, identifier:new_keys; 70, block; 70, 71; 71, raise_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:KeyError; 74, argument_list; 74, 75; 74, 78; 75, binary_operator:%; 75, 76; 75, 77; 76, string:"unique key cannot be None or blank for index %s"; 77, identifier:ind_attr; 78, list_comprehension; 78, 79; 78, 80; 78, 83; 79, identifier:ob; 80, for_in_clause; 80, 81; 80, 82; 81, identifier:ob; 82, identifier:new_objs; 83, if_clause; 83, 84; 84, comparison_operator:is; 84, 85; 84, 91; 85, call; 85, 86; 85, 87; 86, identifier:getattr; 87, argument_list; 87, 88; 87, 89; 87, 90; 88, identifier:ob; 89, identifier:ind_attr; 90, identifier:NO_SUCH_ATTR; 91, None; 92, if_statement; 92, 93; 92, 102; 93, comparison_operator:<; 93, 94; 93, 98; 94, call; 94, 95; 94, 96; 95, identifier:len; 96, argument_list; 96, 97; 97, identifier:new_keys; 98, call; 98, 99; 98, 100; 99, identifier:len; 100, argument_list; 100, 101; 101, identifier:new_objs; 102, block; 102, 103; 103, raise_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:KeyError; 106, argument_list; 106, 107; 107, binary_operator:%; 107, 108; 107, 109; 108, string:"given sequence contains duplicate keys for index %s"; 109, identifier:ind_attr; 110, for_statement; 110, 111; 110, 112; 110, 113; 111, identifier:key; 112, identifier:new_keys; 113, block; 113, 114; 114, if_statement; 114, 115; 114, 118; 115, comparison_operator:in; 115, 116; 115, 117; 116, identifier:key; 117, identifier:ind; 118, block; 118, 119; 118, 125; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:obj; 122, subscript; 122, 123; 122, 124; 123, identifier:new_keys; 124, identifier:key; 125, raise_statement; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:KeyError; 128, argument_list; 128, 129; 128, 138; 129, binary_operator:%; 129, 130; 129, 131; 130, string:"duplicate unique key value '%s' for index %s"; 131, tuple; 131, 132; 131, 137; 132, call; 132, 133; 132, 134; 133, identifier:getattr; 134, argument_list; 134, 135; 134, 136; 135, identifier:obj; 136, identifier:ind_attr; 137, identifier:ind_attr; 138, subscript; 138, 139; 138, 140; 139, identifier:new_keys; 140, identifier:key; 141, for_statement; 141, 142; 141, 143; 141, 144; 142, identifier:obj; 143, identifier:new_objs; 144, block; 144, 145; 144, 154; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 152; 147, attribute; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:obs; 151, identifier:append; 152, argument_list; 152, 153; 153, identifier:obj; 154, for_statement; 154, 155; 154, 158; 154, 165; 155, pattern_list; 155, 156; 155, 157; 156, identifier:attr; 157, identifier:ind; 158, call; 158, 159; 158, 164; 159, attribute; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:_indexes; 163, identifier:items; 164, argument_list; 165, block; 165, 166; 165, 174; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:obval; 169, call; 169, 170; 169, 171; 170, identifier:getattr; 171, argument_list; 171, 172; 171, 173; 172, identifier:obj; 173, identifier:attr; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 179; 176, subscript; 176, 177; 176, 178; 177, identifier:ind; 178, identifier:obval; 179, identifier:obj; 180, return_statement; 180, 181; 181, identifier:self | def insert_many(self, it):
unique_indexes = self._uniqueIndexes
NO_SUCH_ATTR = object()
new_objs = list(it)
if unique_indexes:
for ind in unique_indexes:
ind_attr = ind.attr
new_keys = dict((getattr(obj, ind_attr, NO_SUCH_ATTR), obj) for obj in new_objs)
if not ind.accept_none and (None in new_keys or NO_SUCH_ATTR in new_keys):
raise KeyError("unique key cannot be None or blank for index %s" % ind_attr,
[ob for ob in new_objs if getattr(ob, ind_attr, NO_SUCH_ATTR) is None])
if len(new_keys) < len(new_objs):
raise KeyError("given sequence contains duplicate keys for index %s" % ind_attr)
for key in new_keys:
if key in ind:
obj = new_keys[key]
raise KeyError("duplicate unique key value '%s' for index %s" % (getattr(obj, ind_attr), ind_attr),
new_keys[key])
for obj in new_objs:
self.obs.append(obj)
for attr, ind in self._indexes.items():
obval = getattr(obj, attr)
ind[obval] = obj
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_query_attr_sort_fn; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:attr_val; 6, block; 6, 7; 6, 13; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 12; 9, pattern_list; 9, 10; 9, 11; 10, identifier:attr; 11, identifier:v; 12, identifier:attr_val; 13, if_statement; 13, 14; 13, 19; 13, 44; 14, comparison_operator:in; 14, 15; 14, 16; 15, identifier:attr; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:_indexes; 19, block; 19, 20; 19, 28; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:idx; 23, subscript; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_indexes; 27, identifier:attr; 28, if_statement; 28, 29; 28, 32; 28, 40; 29, comparison_operator:in; 29, 30; 29, 31; 30, identifier:v; 31, identifier:idx; 32, block; 32, 33; 33, return_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:len; 36, argument_list; 36, 37; 37, subscript; 37, 38; 37, 39; 38, identifier:idx; 39, identifier:v; 40, else_clause; 40, 41; 41, block; 41, 42; 42, return_statement; 42, 43; 43, integer:0; 44, else_clause; 44, 45; 45, block; 45, 46; 46, return_statement; 46, 47; 47, float:1e9 | def _query_attr_sort_fn(self, attr_val):
attr, v = attr_val
if attr in self._indexes:
idx = self._indexes[attr]
if v in idx:
return len(idx[v])
else:
return 0
else:
return 1e9 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:reverse; 8, False; 9, block; 9, 10; 9, 227; 10, if_statement; 10, 11; 10, 19; 10, 207; 11, call; 11, 12; 11, 13; 12, identifier:isinstance; 13, argument_list; 13, 14; 13, 15; 14, identifier:key; 15, tuple; 15, 16; 15, 17; 15, 18; 16, identifier:basestring; 17, identifier:list; 18, identifier:tuple; 19, block; 19, 20; 19, 101; 19, 111; 20, if_statement; 20, 21; 20, 26; 20, 64; 21, call; 21, 22; 21, 23; 22, identifier:isinstance; 23, argument_list; 23, 24; 23, 25; 24, identifier:key; 25, identifier:basestring; 26, block; 26, 27; 26, 44; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:attrdefs; 30, list_comprehension; 30, 31; 30, 36; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:s; 34, identifier:strip; 35, argument_list; 36, for_in_clause; 36, 37; 36, 38; 37, identifier:s; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:key; 41, identifier:split; 42, argument_list; 42, 43; 43, string:','; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:attr_orders; 47, list_comprehension; 47, 48; 47, 61; 48, subscript; 48, 49; 48, 58; 49, parenthesized_expression; 49, 50; 50, binary_operator:+; 50, 51; 50, 56; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:a; 54, identifier:split; 55, argument_list; 56, list:['asc', ]; 56, 57; 57, string:'asc'; 58, slice; 58, 59; 58, 60; 59, colon; 60, integer:2; 61, for_in_clause; 61, 62; 61, 63; 62, identifier:a; 63, identifier:attrdefs; 64, else_clause; 64, 65; 65, block; 65, 66; 66, if_statement; 66, 67; 66, 74; 66, 95; 67, call; 67, 68; 67, 69; 68, identifier:isinstance; 69, argument_list; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:key; 72, integer:0; 73, identifier:basestring; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:attr_orders; 78, list_comprehension; 78, 79; 78, 92; 79, subscript; 79, 80; 79, 89; 80, parenthesized_expression; 80, 81; 81, binary_operator:+; 81, 82; 81, 87; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:a; 85, identifier:split; 86, argument_list; 87, list:['asc', ]; 87, 88; 88, string:'asc'; 89, slice; 89, 90; 89, 91; 90, colon; 91, integer:2; 92, for_in_clause; 92, 93; 92, 94; 93, identifier:a; 94, identifier:key; 95, else_clause; 95, 96; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:attr_orders; 100, identifier:key; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:attrs; 104, list_comprehension; 104, 105; 104, 106; 105, identifier:attr; 106, for_in_clause; 106, 107; 106, 110; 107, pattern_list; 107, 108; 107, 109; 108, identifier:attr; 109, identifier:order; 110, identifier:attr_orders; 111, if_statement; 111, 112; 111, 123; 111, 142; 111, 174; 112, call; 112, 113; 112, 114; 113, identifier:all; 114, generator_expression; 114, 115; 114, 118; 115, comparison_operator:==; 115, 116; 115, 117; 116, identifier:order; 117, string:'asc'; 118, for_in_clause; 118, 119; 118, 122; 119, pattern_list; 119, 120; 119, 121; 120, identifier:attr; 121, identifier:order; 122, identifier:attr_orders; 123, block; 123, 124; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:obs; 130, identifier:sort; 131, argument_list; 131, 132; 131, 139; 132, keyword_argument; 132, 133; 132, 134; 133, identifier:key; 134, call; 134, 135; 134, 136; 135, identifier:attrgetter; 136, argument_list; 136, 137; 137, list_splat; 137, 138; 138, identifier:attrs; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:reverse; 141, identifier:reverse; 142, elif_clause; 142, 143; 142, 154; 143, call; 143, 144; 143, 145; 144, identifier:all; 145, generator_expression; 145, 146; 145, 149; 146, comparison_operator:==; 146, 147; 146, 148; 147, identifier:order; 148, string:'desc'; 149, for_in_clause; 149, 150; 149, 153; 150, pattern_list; 150, 151; 150, 152; 151, identifier:attr; 152, identifier:order; 153, identifier:attr_orders; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 162; 157, attribute; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:obs; 161, identifier:sort; 162, argument_list; 162, 163; 162, 170; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:key; 165, call; 165, 166; 165, 167; 166, identifier:attrgetter; 167, argument_list; 167, 168; 168, list_splat; 168, 169; 169, identifier:attrs; 170, keyword_argument; 170, 171; 170, 172; 171, identifier:reverse; 172, not_operator; 172, 173; 173, identifier:reverse; 174, else_clause; 174, 175; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:do_all; 179, generator_expression; 179, 180; 179, 199; 180, call; 180, 181; 180, 186; 181, attribute; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:self; 184, identifier:obs; 185, identifier:sort; 186, argument_list; 186, 187; 186, 193; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:key; 189, call; 189, 190; 189, 191; 190, identifier:attrgetter; 191, argument_list; 191, 192; 192, identifier:attr; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:reverse; 195, parenthesized_expression; 195, 196; 196, comparison_operator:==; 196, 197; 196, 198; 197, identifier:order; 198, string:"desc"; 199, for_in_clause; 199, 200; 199, 203; 200, pattern_list; 200, 201; 200, 202; 201, identifier:attr; 202, identifier:order; 203, call; 203, 204; 203, 205; 204, identifier:reversed; 205, argument_list; 205, 206; 206, identifier:attr_orders; 207, else_clause; 207, 208; 208, block; 208, 209; 208, 213; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:keyfn; 212, identifier:key; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 220; 215, attribute; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:obs; 219, identifier:sort; 220, argument_list; 220, 221; 220, 224; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:key; 223, identifier:keyfn; 224, keyword_argument; 224, 225; 224, 226; 225, identifier:reverse; 226, identifier:reverse; 227, return_statement; 227, 228; 228, identifier:self | def sort(self, key, reverse=False):
if isinstance(key, (basestring, list, tuple)):
if isinstance(key, basestring):
attrdefs = [s.strip() for s in key.split(',')]
attr_orders = [(a.split()+['asc', ])[:2] for a in attrdefs]
else:
if isinstance(key[0], basestring):
attr_orders = [(a.split()+['asc', ])[:2] for a in key]
else:
attr_orders = key
attrs = [attr for attr, order in attr_orders]
if all(order == 'asc' for attr, order in attr_orders):
self.obs.sort(key=attrgetter(*attrs), reverse=reverse)
elif all(order == 'desc' for attr, order in attr_orders):
self.obs.sort(key=attrgetter(*attrs), reverse=not reverse)
else:
do_all(self.obs.sort(key=attrgetter(attr), reverse=(order == "desc"))
for attr, order in reversed(attr_orders))
else:
keyfn = key
self.obs.sort(key=keyfn, reverse=reverse)
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:select; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:fields; 6, dictionary_splat_pattern; 6, 7; 7, identifier:exprs; 8, block; 8, 9; 8, 18; 8, 41; 8, 62; 8, 66; 8, 114; 8, 130; 8, 136; 8, 169; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:fields; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:_parse_fields_string; 16, argument_list; 16, 17; 17, identifier:fields; 18, function_definition; 18, 19; 18, 20; 18, 22; 19, function_name:_make_string_callable; 20, parameters; 20, 21; 21, identifier:expr; 22, block; 22, 23; 23, if_statement; 23, 24; 23, 29; 23, 37; 24, call; 24, 25; 24, 26; 25, identifier:isinstance; 26, argument_list; 26, 27; 26, 28; 27, identifier:expr; 28, identifier:basestring; 29, block; 29, 30; 30, return_statement; 30, 31; 31, lambda; 31, 32; 31, 34; 32, lambda_parameters; 32, 33; 33, identifier:r; 34, binary_operator:%; 34, 35; 34, 36; 35, identifier:expr; 36, identifier:r; 37, else_clause; 37, 38; 38, block; 38, 39; 39, return_statement; 39, 40; 40, identifier:expr; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:exprs; 44, call; 44, 45; 44, 46; 45, identifier:dict; 46, generator_expression; 46, 47; 46, 53; 47, tuple; 47, 48; 47, 49; 48, identifier:k; 49, call; 49, 50; 49, 51; 50, identifier:_make_string_callable; 51, argument_list; 51, 52; 52, identifier:v; 53, for_in_clause; 53, 54; 53, 57; 54, pattern_list; 54, 55; 54, 56; 55, identifier:k; 56, identifier:v; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:exprs; 60, identifier:items; 61, argument_list; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:raw_tuples; 65, list:[]; 66, for_statement; 66, 67; 66, 68; 66, 71; 67, identifier:ob; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:obs; 71, block; 71, 72; 71, 87; 71, 107; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:attrvalues; 75, call; 75, 76; 75, 77; 76, identifier:tuple; 77, generator_expression; 77, 78; 77, 84; 78, call; 78, 79; 78, 80; 79, identifier:getattr; 80, argument_list; 80, 81; 80, 82; 80, 83; 81, identifier:ob; 82, identifier:fieldname; 83, None; 84, for_in_clause; 84, 85; 84, 86; 85, identifier:fieldname; 86, identifier:fields; 87, if_statement; 87, 88; 87, 89; 88, identifier:exprs; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, augmented_assignment:+=; 91, 92; 91, 93; 92, identifier:attrvalues; 93, call; 93, 94; 93, 95; 94, identifier:tuple; 95, generator_expression; 95, 96; 95, 100; 96, call; 96, 97; 96, 98; 97, identifier:expr; 98, argument_list; 98, 99; 99, identifier:ob; 100, for_in_clause; 100, 101; 100, 102; 101, identifier:expr; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:exprs; 105, identifier:values; 106, argument_list; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:raw_tuples; 111, identifier:append; 112, argument_list; 112, 113; 113, identifier:attrvalues; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:all_names; 117, binary_operator:+; 117, 118; 117, 122; 118, call; 118, 119; 118, 120; 119, identifier:tuple; 120, argument_list; 120, 121; 121, identifier:fields; 122, call; 122, 123; 122, 124; 123, identifier:tuple; 124, argument_list; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:exprs; 128, identifier:keys; 129, argument_list; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:ret; 133, call; 133, 134; 133, 135; 134, identifier:Table; 135, argument_list; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:ret; 141, identifier:_indexes; 142, identifier:update; 143, argument_list; 143, 144; 144, call; 144, 145; 144, 146; 145, identifier:dict; 146, generator_expression; 146, 147; 146, 154; 146, 165; 147, tuple; 147, 148; 147, 149; 148, identifier:k; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:v; 152, identifier:copy_template; 153, argument_list; 154, for_in_clause; 154, 155; 154, 158; 155, pattern_list; 155, 156; 155, 157; 156, identifier:k; 157, identifier:v; 158, call; 158, 159; 158, 164; 159, attribute; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:_indexes; 163, identifier:items; 164, argument_list; 165, if_clause; 165, 166; 166, comparison_operator:in; 166, 167; 166, 168; 167, identifier:k; 168, identifier:all_names; 169, return_statement; 169, 170; 170, call; 170, 171; 170, 176; 171, attribute; 171, 172; 171, 175; 172, call; 172, 173; 172, 174; 173, identifier:ret; 174, argument_list; 175, identifier:insert_many; 176, generator_expression; 176, 177; 176, 189; 177, call; 177, 178; 177, 179; 178, identifier:DataObject; 179, argument_list; 179, 180; 180, dictionary_splat; 180, 181; 181, call; 181, 182; 181, 183; 182, identifier:dict; 183, argument_list; 183, 184; 184, call; 184, 185; 184, 186; 185, identifier:zip; 186, argument_list; 186, 187; 186, 188; 187, identifier:all_names; 188, identifier:outtuple; 189, for_in_clause; 189, 190; 189, 191; 190, identifier:outtuple; 191, identifier:raw_tuples | def select(self, fields, **exprs):
fields = self._parse_fields_string(fields)
def _make_string_callable(expr):
if isinstance(expr, basestring):
return lambda r: expr % r
else:
return expr
exprs = dict((k, _make_string_callable(v)) for k, v in exprs.items())
raw_tuples = []
for ob in self.obs:
attrvalues = tuple(getattr(ob, fieldname, None) for fieldname in fields)
if exprs:
attrvalues += tuple(expr(ob) for expr in exprs.values())
raw_tuples.append(attrvalues)
all_names = tuple(fields) + tuple(exprs.keys())
ret = Table()
ret._indexes.update(dict((k, v.copy_template()) for k, v in self._indexes.items() if k in all_names))
return ret().insert_many(DataObject(**dict(zip(all_names, outtuple))) for outtuple in raw_tuples) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:csv_import; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:self; 5, identifier:csv_source; 6, default_parameter; 6, 7; 6, 8; 7, identifier:encoding; 8, string:'utf-8'; 9, default_parameter; 9, 10; 9, 11; 10, identifier:transforms; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:row_class; 14, identifier:DataObject; 15, dictionary_splat_pattern; 15, 16; 16, identifier:kwargs; 17, block; 17, 18; 17, 44; 17, 58; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:reader_args; 21, call; 21, 22; 21, 23; 22, identifier:dict; 23, generator_expression; 23, 24; 23, 27; 23, 36; 24, tuple; 24, 25; 24, 26; 25, identifier:k; 26, identifier:v; 27, for_in_clause; 27, 28; 27, 31; 28, pattern_list; 28, 29; 28, 30; 29, identifier:k; 30, identifier:v; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:kwargs; 34, identifier:items; 35, argument_list; 36, if_clause; 36, 37; 37, comparison_operator:not; 37, 38; 37, 39; 38, identifier:k; 39, list:['encoding',
'csv_source',
'transforms',
'row_class']; 39, 40; 39, 41; 39, 42; 39, 43; 40, string:'encoding'; 41, string:'csv_source'; 42, string:'transforms'; 43, string:'row_class'; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:reader; 47, lambda; 47, 48; 47, 50; 48, lambda_parameters; 48, 49; 49, identifier:src; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:csv; 53, identifier:DictReader; 54, argument_list; 54, 55; 54, 56; 55, identifier:src; 56, dictionary_splat; 56, 57; 57, identifier:reader_args; 58, return_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_import; 63, argument_list; 63, 64; 63, 65; 63, 66; 63, 67; 63, 70; 64, identifier:csv_source; 65, identifier:encoding; 66, identifier:transforms; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:reader; 69, identifier:reader; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:row_class; 72, identifier:row_class | def csv_import(self, csv_source, encoding='utf-8', transforms=None, row_class=DataObject, **kwargs):
reader_args = dict((k, v) for k, v in kwargs.items() if k not in ['encoding',
'csv_source',
'transforms',
'row_class'])
reader = lambda src: csv.DictReader(src, **reader_args)
return self._import(csv_source, encoding, transforms, reader=reader, row_class=row_class) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:csv_export; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:csv_dest; 6, default_parameter; 6, 7; 6, 8; 7, identifier:fieldnames; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:encoding; 11, string:"UTF-8"; 12, block; 12, 13; 12, 17; 12, 55; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:close_on_exit; 16, False; 17, if_statement; 17, 18; 17, 23; 18, call; 18, 19; 18, 20; 19, identifier:isinstance; 20, argument_list; 20, 21; 20, 22; 21, identifier:csv_dest; 22, identifier:basestring; 23, block; 23, 24; 23, 51; 24, if_statement; 24, 25; 24, 26; 24, 41; 25, identifier:PY_3; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:csv_dest; 30, call; 30, 31; 30, 32; 31, identifier:open; 32, argument_list; 32, 33; 32, 34; 32, 35; 32, 38; 33, identifier:csv_dest; 34, string:'w'; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:newline; 37, string:''; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:encoding; 40, identifier:encoding; 41, else_clause; 41, 42; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:csv_dest; 46, call; 46, 47; 46, 48; 47, identifier:open; 48, argument_list; 48, 49; 48, 50; 49, identifier:csv_dest; 50, string:'wb'; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:close_on_exit; 54, True; 55, try_statement; 55, 56; 55, 187; 56, block; 56, 57; 56, 76; 56, 91; 56, 105; 56, 121; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:fieldnames; 60, None; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:fieldnames; 65, call; 65, 66; 65, 67; 66, identifier:list; 67, argument_list; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:_object_attrnames; 70, argument_list; 70, 71; 71, subscript; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:obs; 75, integer:0; 76, if_statement; 76, 77; 76, 82; 77, call; 77, 78; 77, 79; 78, identifier:isinstance; 79, argument_list; 79, 80; 79, 81; 80, identifier:fieldnames; 81, identifier:basestring; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:fieldnames; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:fieldnames; 89, identifier:split; 90, argument_list; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:csv_dest; 95, identifier:write; 96, argument_list; 96, 97; 97, binary_operator:+; 97, 98; 97, 104; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, string:','; 101, identifier:join; 102, argument_list; 102, 103; 103, identifier:fieldnames; 104, identifier:NL; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:csvout; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:csv; 111, identifier:DictWriter; 112, argument_list; 112, 113; 112, 114; 112, 115; 112, 118; 113, identifier:csv_dest; 114, identifier:fieldnames; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:extrasaction; 117, string:'ignore'; 118, keyword_argument; 118, 119; 118, 120; 119, identifier:lineterminator; 120, identifier:NL; 121, if_statement; 121, 122; 121, 131; 121, 146; 122, call; 122, 123; 122, 124; 123, identifier:hasattr; 124, argument_list; 124, 125; 124, 130; 125, subscript; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:obs; 129, integer:0; 130, string:"__dict__"; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:csvout; 136, identifier:writerows; 137, generator_expression; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:o; 140, identifier:__dict__; 141, for_in_clause; 141, 142; 141, 143; 142, identifier:o; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:obs; 146, else_clause; 146, 147; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 151; 150, identifier:do_all; 151, generator_expression; 151, 152; 151, 182; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:csvout; 155, identifier:writerow; 156, argument_list; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:ODict; 159, argument_list; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:starmap; 162, argument_list; 162, 163; 162, 174; 163, lambda; 163, 164; 163, 167; 164, lambda_parameters; 164, 165; 164, 166; 165, identifier:obj; 166, identifier:fld; 167, tuple; 167, 168; 167, 169; 168, identifier:fld; 169, call; 169, 170; 169, 171; 170, identifier:getattr; 171, argument_list; 171, 172; 171, 173; 172, identifier:obj; 173, identifier:fld; 174, call; 174, 175; 174, 176; 175, identifier:zip; 176, argument_list; 176, 177; 176, 181; 177, call; 177, 178; 177, 179; 178, identifier:repeat; 179, argument_list; 179, 180; 180, identifier:o; 181, identifier:fieldnames; 182, for_in_clause; 182, 183; 182, 184; 183, identifier:o; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:obs; 187, finally_clause; 187, 188; 188, block; 188, 189; 189, if_statement; 189, 190; 189, 191; 190, identifier:close_on_exit; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:csv_dest; 196, identifier:close; 197, argument_list | def csv_export(self, csv_dest, fieldnames=None, encoding="UTF-8"):
close_on_exit = False
if isinstance(csv_dest, basestring):
if PY_3:
csv_dest = open(csv_dest, 'w', newline='', encoding=encoding)
else:
csv_dest = open(csv_dest, 'wb')
close_on_exit = True
try:
if fieldnames is None:
fieldnames = list(_object_attrnames(self.obs[0]))
if isinstance(fieldnames, basestring):
fieldnames = fieldnames.split()
csv_dest.write(','.join(fieldnames) + NL)
csvout = csv.DictWriter(csv_dest, fieldnames, extrasaction='ignore', lineterminator=NL)
if hasattr(self.obs[0], "__dict__"):
csvout.writerows(o.__dict__ for o in self.obs)
else:
do_all(csvout.writerow(ODict(starmap(lambda obj, fld: (fld, getattr(obj, fld)),
zip(repeat(o), fieldnames)))) for o in self.obs)
finally:
if close_on_exit:
csv_dest.close() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:json_import; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:source; 6, default_parameter; 6, 7; 6, 8; 7, identifier:encoding; 8, string:"UTF-8"; 9, default_parameter; 9, 10; 9, 11; 10, identifier:transforms; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:row_class; 14, identifier:DataObject; 15, block; 15, 16; 15, 77; 16, class_definition; 16, 17; 16, 18; 16, 20; 17, identifier:_JsonFileReader; 18, argument_list; 18, 19; 19, identifier:object; 20, block; 20, 21; 20, 33; 21, function_definition; 21, 22; 21, 23; 21, 26; 22, function_name:__init__; 23, parameters; 23, 24; 23, 25; 24, identifier:self; 25, identifier:src; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:source; 32, identifier:src; 33, function_definition; 33, 34; 33, 35; 33, 37; 34, function_name:__iter__; 35, parameters; 35, 36; 36, identifier:self; 37, block; 37, 38; 37, 42; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:current; 41, string:''; 42, for_statement; 42, 43; 42, 44; 42, 47; 43, identifier:line; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:source; 47, block; 47, 48; 47, 55; 47, 59; 48, if_statement; 48, 49; 48, 50; 49, identifier:current; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, augmented_assignment:+=; 52, 53; 52, 54; 53, identifier:current; 54, string:' '; 55, expression_statement; 55, 56; 56, augmented_assignment:+=; 56, 57; 56, 58; 57, identifier:current; 58, identifier:line; 59, try_statement; 59, 60; 59, 73; 60, block; 60, 61; 60, 69; 61, expression_statement; 61, 62; 62, yield; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:json; 66, identifier:loads; 67, argument_list; 67, 68; 68, identifier:current; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:current; 72, string:''; 73, except_clause; 73, 74; 73, 75; 74, identifier:Exception; 75, block; 75, 76; 76, pass_statement; 77, return_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:_import; 82, argument_list; 82, 83; 82, 84; 82, 85; 82, 88; 82, 91; 83, identifier:source; 84, identifier:encoding; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:transforms; 87, identifier:transforms; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:reader; 90, identifier:_JsonFileReader; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:row_class; 93, identifier:row_class | def json_import(self, source, encoding="UTF-8", transforms=None, row_class=DataObject):
class _JsonFileReader(object):
def __init__(self, src):
self.source = src
def __iter__(self):
current = ''
for line in self.source:
if current:
current += ' '
current += line
try:
yield json.loads(current)
current = ''
except Exception:
pass
return self._import(source, encoding, transforms=transforms, reader=_JsonFileReader, row_class=row_class) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:json_export; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:dest; 6, default_parameter; 6, 7; 6, 8; 7, identifier:fieldnames; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:encoding; 11, string:"UTF-8"; 12, block; 12, 13; 12, 17; 12, 52; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:close_on_exit; 16, False; 17, if_statement; 17, 18; 17, 23; 18, call; 18, 19; 18, 20; 19, identifier:isinstance; 20, argument_list; 20, 21; 20, 22; 21, identifier:dest; 22, identifier:basestring; 23, block; 23, 24; 23, 48; 24, if_statement; 24, 25; 24, 26; 24, 38; 25, identifier:PY_3; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:dest; 30, call; 30, 31; 30, 32; 31, identifier:open; 32, argument_list; 32, 33; 32, 34; 32, 35; 33, identifier:dest; 34, string:'w'; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:encoding; 37, identifier:encoding; 38, else_clause; 38, 39; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:dest; 43, call; 43, 44; 43, 45; 44, identifier:open; 45, argument_list; 45, 46; 45, 47; 46, identifier:dest; 47, string:'w'; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:close_on_exit; 51, True; 52, try_statement; 52, 53; 52, 130; 53, block; 53, 54; 53, 69; 54, if_statement; 54, 55; 54, 60; 55, call; 55, 56; 55, 57; 56, identifier:isinstance; 57, argument_list; 57, 58; 57, 59; 58, identifier:fieldnames; 59, identifier:basestring; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:fieldnames; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:fieldnames; 67, identifier:split; 68, argument_list; 69, if_statement; 69, 70; 69, 73; 69, 94; 70, comparison_operator:is; 70, 71; 70, 72; 71, identifier:fieldnames; 72, None; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:do_all; 77, generator_expression; 77, 78; 77, 89; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:dest; 81, identifier:write; 82, argument_list; 82, 83; 83, binary_operator:+; 83, 84; 83, 88; 84, call; 84, 85; 84, 86; 85, identifier:_to_json; 86, argument_list; 86, 87; 87, identifier:o; 88, string:'\n'; 89, for_in_clause; 89, 90; 89, 91; 90, identifier:o; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:obs; 94, else_clause; 94, 95; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:do_all; 99, generator_expression; 99, 100; 99, 125; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:dest; 103, identifier:write; 104, argument_list; 104, 105; 105, binary_operator:+; 105, 106; 105, 124; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:json; 109, identifier:dumps; 110, argument_list; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:ODict; 113, generator_expression; 113, 114; 113, 121; 114, tuple; 114, 115; 114, 116; 115, identifier:f; 116, call; 116, 117; 116, 118; 117, identifier:getattr; 118, argument_list; 118, 119; 118, 120; 119, identifier:o; 120, identifier:f; 121, for_in_clause; 121, 122; 121, 123; 122, identifier:f; 123, identifier:fieldnames; 124, string:'\n'; 125, for_in_clause; 125, 126; 125, 127; 126, identifier:o; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:obs; 130, finally_clause; 130, 131; 131, block; 131, 132; 132, if_statement; 132, 133; 132, 134; 133, identifier:close_on_exit; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:dest; 139, identifier:close; 140, argument_list | def json_export(self, dest, fieldnames=None, encoding="UTF-8"):
close_on_exit = False
if isinstance(dest, basestring):
if PY_3:
dest = open(dest, 'w', encoding=encoding)
else:
dest = open(dest, 'w')
close_on_exit = True
try:
if isinstance(fieldnames, basestring):
fieldnames = fieldnames.split()
if fieldnames is None:
do_all(dest.write(_to_json(o)+'\n') for o in self.obs)
else:
do_all(dest.write(json.dumps(ODict((f, getattr(o, f)) for f in fieldnames))+'\n') for o in self.obs)
finally:
if close_on_exit:
dest.close() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:groupby; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:keyexpr; 6, dictionary_splat_pattern; 6, 7; 7, identifier:outexprs; 8, block; 8, 9; 8, 68; 8, 75; 8, 95; 8, 101; 8, 123; 8, 180; 9, if_statement; 9, 10; 9, 15; 9, 41; 9, 61; 10, call; 10, 11; 10, 12; 11, identifier:isinstance; 12, argument_list; 12, 13; 12, 14; 13, identifier:keyexpr; 14, identifier:basestring; 15, block; 15, 16; 15, 24; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:keyattrs; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:keyexpr; 22, identifier:split; 23, argument_list; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:keyfn; 27, lambda; 27, 28; 27, 30; 28, lambda_parameters; 28, 29; 29, identifier:o; 30, call; 30, 31; 30, 32; 31, identifier:tuple; 32, generator_expression; 32, 33; 32, 38; 33, call; 33, 34; 33, 35; 34, identifier:getattr; 35, argument_list; 35, 36; 35, 37; 36, identifier:o; 37, identifier:k; 38, for_in_clause; 38, 39; 38, 40; 39, identifier:k; 40, identifier:keyattrs; 41, elif_clause; 41, 42; 41, 47; 42, call; 42, 43; 42, 44; 43, identifier:isinstance; 44, argument_list; 44, 45; 44, 46; 45, identifier:keyexpr; 46, identifier:tuple; 47, block; 47, 48; 47, 55; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:keyattrs; 51, tuple; 51, 52; 52, subscript; 52, 53; 52, 54; 53, identifier:keyexpr; 54, integer:0; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:keyfn; 58, subscript; 58, 59; 58, 60; 59, identifier:keyexpr; 60, integer:1; 61, else_clause; 61, 62; 62, block; 62, 63; 63, raise_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:TypeError; 66, argument_list; 66, 67; 67, string:"keyexpr must be string or tuple"; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:groupedobs; 71, call; 71, 72; 71, 73; 72, identifier:defaultdict; 73, argument_list; 73, 74; 74, identifier:list; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:do_all; 78, generator_expression; 78, 79; 78, 90; 79, call; 79, 80; 79, 88; 80, attribute; 80, 81; 80, 87; 81, subscript; 81, 82; 81, 83; 82, identifier:groupedobs; 83, call; 83, 84; 83, 85; 84, identifier:keyfn; 85, argument_list; 85, 86; 86, identifier:ob; 87, identifier:append; 88, argument_list; 88, 89; 89, identifier:ob; 90, for_in_clause; 90, 91; 90, 92; 91, identifier:ob; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:obs; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:tbl; 98, call; 98, 99; 98, 100; 99, identifier:Table; 100, argument_list; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 104; 103, identifier:do_all; 104, generator_expression; 104, 105; 104, 120; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:tbl; 108, identifier:create_index; 109, argument_list; 109, 110; 109, 111; 110, identifier:k; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:unique; 113, parenthesized_expression; 113, 114; 114, comparison_operator:==; 114, 115; 114, 119; 115, call; 115, 116; 115, 117; 116, identifier:len; 117, argument_list; 117, 118; 118, identifier:keyattrs; 119, integer:1; 120, for_in_clause; 120, 121; 120, 122; 121, identifier:k; 122, identifier:keyattrs; 123, for_statement; 123, 124; 123, 127; 123, 135; 124, pattern_list; 124, 125; 124, 126; 125, identifier:key; 126, identifier:recs; 127, call; 127, 128; 127, 129; 128, identifier:sorted; 129, argument_list; 129, 130; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:groupedobs; 133, identifier:items; 134, argument_list; 135, block; 135, 136; 135, 151; 135, 173; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:groupobj; 139, call; 139, 140; 139, 141; 140, identifier:DataObject; 141, argument_list; 141, 142; 142, dictionary_splat; 142, 143; 143, call; 143, 144; 143, 145; 144, identifier:dict; 145, argument_list; 145, 146; 146, call; 146, 147; 146, 148; 147, identifier:zip; 148, argument_list; 148, 149; 148, 150; 149, identifier:keyattrs; 150, identifier:key; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:do_all; 154, generator_expression; 154, 155; 154, 164; 155, call; 155, 156; 155, 157; 156, identifier:setattr; 157, argument_list; 157, 158; 157, 159; 157, 160; 158, identifier:groupobj; 159, identifier:subkey; 160, call; 160, 161; 160, 162; 161, identifier:expr; 162, argument_list; 162, 163; 163, identifier:recs; 164, for_in_clause; 164, 165; 164, 168; 165, pattern_list; 165, 166; 165, 167; 166, identifier:subkey; 167, identifier:expr; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:outexprs; 171, identifier:items; 172, argument_list; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:tbl; 177, identifier:insert; 178, argument_list; 178, 179; 179, identifier:groupobj; 180, return_statement; 180, 181; 181, identifier:tbl | def groupby(self, keyexpr, **outexprs):
if isinstance(keyexpr, basestring):
keyattrs = keyexpr.split()
keyfn = lambda o: tuple(getattr(o, k) for k in keyattrs)
elif isinstance(keyexpr, tuple):
keyattrs = (keyexpr[0],)
keyfn = keyexpr[1]
else:
raise TypeError("keyexpr must be string or tuple")
groupedobs = defaultdict(list)
do_all(groupedobs[keyfn(ob)].append(ob) for ob in self.obs)
tbl = Table()
do_all(tbl.create_index(k, unique=(len(keyattrs) == 1)) for k in keyattrs)
for key, recs in sorted(groupedobs.items()):
groupobj = DataObject(**dict(zip(keyattrs, key)))
do_all(setattr(groupobj, subkey, expr(recs)) for subkey, expr in outexprs.items())
tbl.insert(groupobj)
return tbl |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:dump_counts; 3, parameters; 3, 4; 3, 5; 3, 10; 3, 13; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:out; 7, attribute; 7, 8; 7, 9; 8, identifier:sys; 9, identifier:stdout; 10, default_parameter; 10, 11; 10, 12; 11, identifier:count_fn; 12, identifier:len; 13, default_parameter; 13, 14; 13, 15; 14, identifier:colwidth; 15, integer:10; 16, block; 16, 17; 17, if_statement; 17, 18; 17, 26; 17, 143; 17, 456; 18, comparison_operator:==; 18, 19; 18, 25; 19, call; 19, 20; 19, 21; 20, identifier:len; 21, argument_list; 21, 22; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_pivot_attrs; 25, integer:1; 26, block; 26, 27; 26, 43; 26, 63; 26, 67; 26, 71; 26, 108; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:out; 31, identifier:write; 32, argument_list; 32, 33; 33, binary_operator:%; 33, 34; 33, 35; 34, string:"Pivot: %s\n"; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, string:','; 38, identifier:join; 39, argument_list; 39, 40; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:_pivot_attrs; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:maxkeylen; 46, call; 46, 47; 46, 48; 47, identifier:max; 48, generator_expression; 48, 49; 48, 56; 49, call; 49, 50; 49, 51; 50, identifier:len; 51, argument_list; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:str; 54, argument_list; 54, 55; 55, identifier:k; 56, for_in_clause; 56, 57; 56, 58; 57, identifier:k; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:keys; 62, argument_list; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:maxvallen; 66, identifier:colwidth; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:keytally; 70, dictionary; 71, for_statement; 71, 72; 71, 75; 71, 80; 72, pattern_list; 72, 73; 72, 74; 73, identifier:k; 74, identifier:sub; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:items; 79, argument_list; 80, block; 80, 81; 80, 88; 80, 102; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:sub_v; 84, call; 84, 85; 84, 86; 85, identifier:count_fn; 86, argument_list; 86, 87; 87, identifier:sub; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:maxvallen; 91, call; 91, 92; 91, 93; 92, identifier:max; 93, argument_list; 93, 94; 93, 95; 94, identifier:maxvallen; 95, call; 95, 96; 95, 97; 96, identifier:len; 97, argument_list; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:str; 100, argument_list; 100, 101; 101, identifier:sub_v; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:keytally; 106, identifier:k; 107, identifier:sub_v; 108, for_statement; 108, 109; 108, 112; 108, 117; 109, pattern_list; 109, 110; 109, 111; 110, identifier:k; 111, identifier:sub; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:items; 116, argument_list; 117, block; 117, 118; 117, 130; 118, expression_statement; 118, 119; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:out; 122, identifier:write; 123, argument_list; 123, 124; 124, binary_operator:%; 124, 125; 124, 126; 125, string:"%-*.*s "; 126, tuple; 126, 127; 126, 128; 126, 129; 127, identifier:maxkeylen; 128, identifier:maxkeylen; 129, identifier:k; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:out; 134, identifier:write; 135, argument_list; 135, 136; 136, binary_operator:%; 136, 137; 136, 138; 137, string:"%*s\n"; 138, tuple; 138, 139; 138, 140; 139, identifier:maxvallen; 140, subscript; 140, 141; 140, 142; 141, identifier:keytally; 142, identifier:k; 143, elif_clause; 143, 144; 143, 152; 144, comparison_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:_pivot_attrs; 151, integer:2; 152, block; 152, 153; 152, 169; 152, 193; 152, 221; 152, 241; 152, 252; 152, 280; 152, 291; 152, 393; 152, 405; 152, 433; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:out; 157, identifier:write; 158, argument_list; 158, 159; 159, binary_operator:%; 159, 160; 159, 161; 160, string:"Pivot: %s\n"; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, string:','; 164, identifier:join; 165, argument_list; 165, 166; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:_pivot_attrs; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:maxkeylen; 172, call; 172, 173; 172, 174; 173, identifier:max; 174, argument_list; 174, 175; 174, 192; 175, call; 175, 176; 175, 177; 176, identifier:max; 177, generator_expression; 177, 178; 177, 185; 178, call; 178, 179; 178, 180; 179, identifier:len; 180, argument_list; 180, 181; 181, call; 181, 182; 181, 183; 182, identifier:str; 183, argument_list; 183, 184; 184, identifier:k; 185, for_in_clause; 185, 186; 185, 187; 186, identifier:k; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:self; 190, identifier:keys; 191, argument_list; 192, integer:5; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:maxvallen; 196, call; 196, 197; 196, 198; 197, identifier:max; 198, argument_list; 198, 199; 198, 220; 199, call; 199, 200; 199, 201; 200, identifier:max; 201, generator_expression; 201, 202; 201, 209; 202, call; 202, 203; 202, 204; 203, identifier:len; 204, argument_list; 204, 205; 205, call; 205, 206; 205, 207; 206, identifier:str; 207, argument_list; 207, 208; 208, identifier:k; 209, for_in_clause; 209, 210; 209, 211; 210, identifier:k; 211, call; 211, 212; 211, 219; 212, attribute; 212, 213; 212, 218; 213, subscript; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:subtables; 217, integer:0; 218, identifier:keys; 219, argument_list; 220, identifier:colwidth; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:keytally; 224, call; 224, 225; 224, 226; 225, identifier:dict; 226, generator_expression; 226, 227; 226, 230; 227, tuple; 227, 228; 227, 229; 228, identifier:k; 229, integer:0; 230, for_in_clause; 230, 231; 230, 232; 231, identifier:k; 232, call; 232, 233; 232, 240; 233, attribute; 233, 234; 233, 239; 234, subscript; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:self; 237, identifier:subtables; 238, integer:0; 239, identifier:keys; 240, argument_list; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:out; 245, identifier:write; 246, argument_list; 246, 247; 247, binary_operator:%; 247, 248; 247, 249; 248, string:"%*s "; 249, tuple; 249, 250; 249, 251; 250, identifier:maxkeylen; 251, string:''; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:out; 256, identifier:write; 257, argument_list; 257, 258; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, string:' '; 261, identifier:join; 262, generator_expression; 262, 263; 262, 269; 263, binary_operator:%; 263, 264; 263, 265; 264, string:"%*.*s"; 265, tuple; 265, 266; 265, 267; 265, 268; 266, identifier:maxvallen; 267, identifier:maxvallen; 268, identifier:k; 269, for_in_clause; 269, 270; 269, 271; 270, identifier:k; 271, call; 271, 272; 271, 279; 272, attribute; 272, 273; 272, 278; 273, subscript; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:self; 276, identifier:subtables; 277, integer:0; 278, identifier:keys; 279, argument_list; 280, expression_statement; 280, 281; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:out; 284, identifier:write; 285, argument_list; 285, 286; 286, binary_operator:%; 286, 287; 286, 288; 287, string:' %*s\n'; 288, tuple; 288, 289; 288, 290; 289, identifier:maxvallen; 290, string:'Total'; 291, for_statement; 291, 292; 291, 295; 291, 300; 292, pattern_list; 292, 293; 292, 294; 293, identifier:k; 294, identifier:sub; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:self; 298, identifier:items; 299, argument_list; 300, block; 300, 301; 300, 313; 300, 361; 300, 368; 300, 382; 301, expression_statement; 301, 302; 302, call; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:out; 305, identifier:write; 306, argument_list; 306, 307; 307, binary_operator:%; 307, 308; 307, 309; 308, string:"%-*.*s "; 309, tuple; 309, 310; 309, 311; 309, 312; 310, identifier:maxkeylen; 311, identifier:maxkeylen; 312, identifier:k; 313, for_statement; 313, 314; 313, 317; 313, 322; 314, pattern_list; 314, 315; 314, 316; 315, identifier:kk; 316, identifier:ssub; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:sub; 320, identifier:items; 321, argument_list; 322, block; 322, 323; 322, 330; 322, 341; 322, 347; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:ssub_v; 326, call; 326, 327; 326, 328; 327, identifier:count_fn; 328, argument_list; 328, 329; 329, identifier:ssub; 330, expression_statement; 330, 331; 331, call; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:out; 334, identifier:write; 335, argument_list; 335, 336; 336, binary_operator:%; 336, 337; 336, 338; 337, string:"%*d "; 338, tuple; 338, 339; 338, 340; 339, identifier:maxvallen; 340, identifier:ssub_v; 341, expression_statement; 341, 342; 342, augmented_assignment:+=; 342, 343; 342, 346; 343, subscript; 343, 344; 343, 345; 344, identifier:keytally; 345, identifier:kk; 346, identifier:ssub_v; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 350; 349, identifier:maxvallen; 350, call; 350, 351; 350, 352; 351, identifier:max; 352, argument_list; 352, 353; 352, 354; 353, identifier:maxvallen; 354, call; 354, 355; 354, 356; 355, identifier:len; 356, argument_list; 356, 357; 357, call; 357, 358; 357, 359; 358, identifier:str; 359, argument_list; 359, 360; 360, identifier:ssub_v; 361, expression_statement; 361, 362; 362, assignment; 362, 363; 362, 364; 363, identifier:sub_v; 364, call; 364, 365; 364, 366; 365, identifier:count_fn; 366, argument_list; 366, 367; 367, identifier:sub; 368, expression_statement; 368, 369; 369, assignment; 369, 370; 369, 371; 370, identifier:maxvallen; 371, call; 371, 372; 371, 373; 372, identifier:max; 373, argument_list; 373, 374; 373, 375; 374, identifier:maxvallen; 375, call; 375, 376; 375, 377; 376, identifier:len; 377, argument_list; 377, 378; 378, call; 378, 379; 378, 380; 379, identifier:str; 380, argument_list; 380, 381; 381, identifier:sub_v; 382, expression_statement; 382, 383; 383, call; 383, 384; 383, 387; 384, attribute; 384, 385; 384, 386; 385, identifier:out; 386, identifier:write; 387, argument_list; 387, 388; 388, binary_operator:%; 388, 389; 388, 390; 389, string:"%*d\n"; 390, tuple; 390, 391; 390, 392; 391, identifier:maxvallen; 392, identifier:sub_v; 393, expression_statement; 393, 394; 394, call; 394, 395; 394, 398; 395, attribute; 395, 396; 395, 397; 396, identifier:out; 397, identifier:write; 398, argument_list; 398, 399; 399, binary_operator:%; 399, 400; 399, 401; 400, string:'%-*.*s '; 401, tuple; 401, 402; 401, 403; 401, 404; 402, identifier:maxkeylen; 403, identifier:maxkeylen; 404, string:"Total"; 405, expression_statement; 405, 406; 406, call; 406, 407; 406, 410; 407, attribute; 407, 408; 407, 409; 408, identifier:out; 409, identifier:write; 410, argument_list; 410, 411; 411, call; 411, 412; 411, 415; 412, attribute; 412, 413; 412, 414; 413, string:' '; 414, identifier:join; 415, generator_expression; 415, 416; 415, 421; 416, binary_operator:%; 416, 417; 416, 418; 417, string:"%*d"; 418, tuple; 418, 419; 418, 420; 419, identifier:maxvallen; 420, identifier:tally; 421, for_in_clause; 421, 422; 421, 425; 422, pattern_list; 422, 423; 422, 424; 423, identifier:k; 424, identifier:tally; 425, call; 425, 426; 425, 427; 426, identifier:sorted; 427, argument_list; 427, 428; 428, call; 428, 429; 428, 432; 429, attribute; 429, 430; 429, 431; 430, identifier:keytally; 431, identifier:items; 432, argument_list; 433, expression_statement; 433, 434; 434, call; 434, 435; 434, 438; 435, attribute; 435, 436; 435, 437; 436, identifier:out; 437, identifier:write; 438, argument_list; 438, 439; 439, binary_operator:%; 439, 440; 439, 441; 440, string:" %*d\n"; 441, tuple; 441, 442; 441, 443; 442, identifier:maxvallen; 443, call; 443, 444; 443, 445; 444, identifier:sum; 445, generator_expression; 445, 446; 445, 447; 446, identifier:tally; 447, for_in_clause; 447, 448; 447, 451; 448, pattern_list; 448, 449; 448, 450; 449, identifier:k; 450, identifier:tally; 451, call; 451, 452; 451, 455; 452, attribute; 452, 453; 452, 454; 453, identifier:keytally; 454, identifier:items; 455, argument_list; 456, else_clause; 456, 457; 457, block; 457, 458; 458, raise_statement; 458, 459; 459, call; 459, 460; 459, 461; 460, identifier:ValueError; 461, argument_list; 461, 462; 462, string:"can only dump summary counts for 1 or 2-attribute pivots" | def dump_counts(self, out=sys.stdout, count_fn=len, colwidth=10):
if len(self._pivot_attrs) == 1:
out.write("Pivot: %s\n" % ','.join(self._pivot_attrs))
maxkeylen = max(len(str(k)) for k in self.keys())
maxvallen = colwidth
keytally = {}
for k, sub in self.items():
sub_v = count_fn(sub)
maxvallen = max(maxvallen, len(str(sub_v)))
keytally[k] = sub_v
for k, sub in self.items():
out.write("%-*.*s " % (maxkeylen, maxkeylen, k))
out.write("%*s\n" % (maxvallen, keytally[k]))
elif len(self._pivot_attrs) == 2:
out.write("Pivot: %s\n" % ','.join(self._pivot_attrs))
maxkeylen = max(max(len(str(k)) for k in self.keys()), 5)
maxvallen = max(max(len(str(k)) for k in self.subtables[0].keys()), colwidth)
keytally = dict((k, 0) for k in self.subtables[0].keys())
out.write("%*s " % (maxkeylen, ''))
out.write(' '.join("%*.*s" % (maxvallen, maxvallen, k) for k in self.subtables[0].keys()))
out.write(' %*s\n' % (maxvallen, 'Total'))
for k, sub in self.items():
out.write("%-*.*s " % (maxkeylen, maxkeylen, k))
for kk, ssub in sub.items():
ssub_v = count_fn(ssub)
out.write("%*d " % (maxvallen, ssub_v))
keytally[kk] += ssub_v
maxvallen = max(maxvallen, len(str(ssub_v)))
sub_v = count_fn(sub)
maxvallen = max(maxvallen, len(str(sub_v)))
out.write("%*d\n" % (maxvallen, sub_v))
out.write('%-*.*s ' % (maxkeylen, maxkeylen, "Total"))
out.write(' '.join("%*d" % (maxvallen, tally) for k, tally in sorted(keytally.items())))
out.write(" %*d\n" % (maxvallen, sum(tally for k, tally in keytally.items())))
else:
raise ValueError("can only dump summary counts for 1 or 2-attribute pivots") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:as_table; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:fn; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:col; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:col_label; 13, None; 14, block; 14, 15; 14, 24; 14, 42; 14, 48; 14, 63; 14, 307; 15, if_statement; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:col_label; 18, None; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:col_label; 23, identifier:col; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:fn; 27, None; 28, block; 28, 29; 28, 33; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:fn; 32, identifier:len; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:col_label; 36, None; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:col_label; 41, string:'count'; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:ret; 45, call; 45, 46; 45, 47; 46, identifier:Table; 47, argument_list; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:do_all; 51, generator_expression; 51, 52; 51, 58; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:ret; 55, identifier:create_index; 56, argument_list; 56, 57; 57, identifier:attr; 58, for_in_clause; 58, 59; 58, 60; 59, identifier:attr; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_pivot_attrs; 63, if_statement; 63, 64; 63, 72; 63, 142; 63, 218; 63, 300; 64, comparison_operator:==; 64, 65; 64, 71; 65, call; 65, 66; 65, 67; 66, identifier:len; 67, argument_list; 67, 68; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:_pivot_attrs; 71, integer:1; 72, block; 72, 73; 73, for_statement; 73, 74; 73, 75; 73, 78; 74, identifier:sub; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:subtables; 78, block; 78, 79; 78, 90; 78, 97; 78, 131; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, pattern_list; 81, 82; 81, 83; 82, identifier:subattr; 83, identifier:subval; 84, subscript; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:sub; 87, identifier:_attr_path; 88, unary_operator:-; 88, 89; 89, integer:1; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:attrdict; 93, dictionary; 93, 94; 94, pair; 94, 95; 94, 96; 95, identifier:subattr; 96, identifier:subval; 97, if_statement; 97, 98; 97, 105; 97, 115; 98, boolean_operator:or; 98, 99; 98, 102; 99, comparison_operator:is; 99, 100; 99, 101; 100, identifier:col; 101, None; 102, comparison_operator:is; 102, 103; 102, 104; 103, identifier:fn; 104, identifier:len; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 111; 108, subscript; 108, 109; 108, 110; 109, identifier:attrdict; 110, identifier:col_label; 111, call; 111, 112; 111, 113; 112, identifier:fn; 113, argument_list; 113, 114; 114, identifier:sub; 115, else_clause; 115, 116; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 122; 119, subscript; 119, 120; 119, 121; 120, identifier:attrdict; 121, identifier:col_label; 122, call; 122, 123; 122, 124; 123, identifier:fn; 124, generator_expression; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:s; 127, identifier:col; 128, for_in_clause; 128, 129; 128, 130; 129, identifier:s; 130, identifier:sub; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:ret; 135, identifier:insert; 136, argument_list; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:DataObject; 139, argument_list; 139, 140; 140, dictionary_splat; 140, 141; 141, identifier:attrdict; 142, elif_clause; 142, 143; 142, 151; 143, comparison_operator:==; 143, 144; 143, 150; 144, call; 144, 145; 144, 146; 145, identifier:len; 146, argument_list; 146, 147; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:_pivot_attrs; 150, integer:2; 151, block; 151, 152; 152, for_statement; 152, 153; 152, 154; 152, 157; 153, identifier:sub; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:subtables; 157, block; 157, 158; 158, for_statement; 158, 159; 158, 160; 158, 163; 159, identifier:ssub; 160, attribute; 160, 161; 160, 162; 161, identifier:sub; 162, identifier:subtables; 163, block; 163, 164; 163, 173; 163, 207; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:attrdict; 167, call; 167, 168; 167, 169; 168, identifier:dict; 169, argument_list; 169, 170; 170, attribute; 170, 171; 170, 172; 171, identifier:ssub; 172, identifier:_attr_path; 173, if_statement; 173, 174; 173, 181; 173, 191; 174, boolean_operator:or; 174, 175; 174, 178; 175, comparison_operator:is; 175, 176; 175, 177; 176, identifier:col; 177, None; 178, comparison_operator:is; 178, 179; 178, 180; 179, identifier:fn; 180, identifier:len; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 187; 184, subscript; 184, 185; 184, 186; 185, identifier:attrdict; 186, identifier:col_label; 187, call; 187, 188; 187, 189; 188, identifier:fn; 189, argument_list; 189, 190; 190, identifier:ssub; 191, else_clause; 191, 192; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 198; 195, subscript; 195, 196; 195, 197; 196, identifier:attrdict; 197, identifier:col_label; 198, call; 198, 199; 198, 200; 199, identifier:fn; 200, generator_expression; 200, 201; 200, 204; 201, subscript; 201, 202; 201, 203; 202, identifier:s; 203, identifier:col; 204, for_in_clause; 204, 205; 204, 206; 205, identifier:s; 206, identifier:ssub; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:ret; 211, identifier:insert; 212, argument_list; 212, 213; 213, call; 213, 214; 213, 215; 214, identifier:DataObject; 215, argument_list; 215, 216; 216, dictionary_splat; 216, 217; 217, identifier:attrdict; 218, elif_clause; 218, 219; 218, 227; 219, comparison_operator:==; 219, 220; 219, 226; 220, call; 220, 221; 220, 222; 221, identifier:len; 222, argument_list; 222, 223; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:_pivot_attrs; 226, integer:3; 227, block; 227, 228; 228, for_statement; 228, 229; 228, 230; 228, 233; 229, identifier:sub; 230, attribute; 230, 231; 230, 232; 231, identifier:self; 232, identifier:subtables; 233, block; 233, 234; 234, for_statement; 234, 235; 234, 236; 234, 239; 235, identifier:ssub; 236, attribute; 236, 237; 236, 238; 237, identifier:sub; 238, identifier:subtables; 239, block; 239, 240; 240, for_statement; 240, 241; 240, 242; 240, 245; 241, identifier:sssub; 242, attribute; 242, 243; 242, 244; 243, identifier:ssub; 244, identifier:subtables; 245, block; 245, 246; 245, 255; 245, 289; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:attrdict; 249, call; 249, 250; 249, 251; 250, identifier:dict; 251, argument_list; 251, 252; 252, attribute; 252, 253; 252, 254; 253, identifier:sssub; 254, identifier:_attr_path; 255, if_statement; 255, 256; 255, 263; 255, 273; 256, boolean_operator:or; 256, 257; 256, 260; 257, comparison_operator:is; 257, 258; 257, 259; 258, identifier:col; 259, None; 260, comparison_operator:is; 260, 261; 260, 262; 261, identifier:fn; 262, identifier:len; 263, block; 263, 264; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 269; 266, subscript; 266, 267; 266, 268; 267, identifier:attrdict; 268, identifier:col_label; 269, call; 269, 270; 269, 271; 270, identifier:fn; 271, argument_list; 271, 272; 272, identifier:sssub; 273, else_clause; 273, 274; 274, block; 274, 275; 275, expression_statement; 275, 276; 276, assignment; 276, 277; 276, 280; 277, subscript; 277, 278; 277, 279; 278, identifier:attrdict; 279, identifier:col_label; 280, call; 280, 281; 280, 282; 281, identifier:fn; 282, generator_expression; 282, 283; 282, 286; 283, subscript; 283, 284; 283, 285; 284, identifier:s; 285, identifier:col; 286, for_in_clause; 286, 287; 286, 288; 287, identifier:s; 288, identifier:sssub; 289, expression_statement; 289, 290; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:ret; 293, identifier:insert; 294, argument_list; 294, 295; 295, call; 295, 296; 295, 297; 296, identifier:DataObject; 297, argument_list; 297, 298; 298, dictionary_splat; 298, 299; 299, identifier:attrdict; 300, else_clause; 300, 301; 301, block; 301, 302; 302, raise_statement; 302, 303; 303, call; 303, 304; 303, 305; 304, identifier:ValueError; 305, argument_list; 305, 306; 306, string:"can only dump summary counts for 1 or 2-attribute pivots"; 307, return_statement; 307, 308; 308, identifier:ret | def as_table(self, fn=None, col=None, col_label=None):
if col_label is None:
col_label = col
if fn is None:
fn = len
if col_label is None:
col_label = 'count'
ret = Table()
do_all(ret.create_index(attr) for attr in self._pivot_attrs)
if len(self._pivot_attrs) == 1:
for sub in self.subtables:
subattr, subval = sub._attr_path[-1]
attrdict = {subattr: subval}
if col is None or fn is len:
attrdict[col_label] = fn(sub)
else:
attrdict[col_label] = fn(s[col] for s in sub)
ret.insert(DataObject(**attrdict))
elif len(self._pivot_attrs) == 2:
for sub in self.subtables:
for ssub in sub.subtables:
attrdict = dict(ssub._attr_path)
if col is None or fn is len:
attrdict[col_label] = fn(ssub)
else:
attrdict[col_label] = fn(s[col] for s in ssub)
ret.insert(DataObject(**attrdict))
elif len(self._pivot_attrs) == 3:
for sub in self.subtables:
for ssub in sub.subtables:
for sssub in ssub.subtables:
attrdict = dict(sssub._attr_path)
if col is None or fn is len:
attrdict[col_label] = fn(sssub)
else:
attrdict[col_label] = fn(s[col] for s in sssub)
ret.insert(DataObject(**attrdict))
else:
raise ValueError("can only dump summary counts for 1 or 2-attribute pivots")
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:remove_edge; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:u; 6, identifier:v; 7, block; 7, 8; 7, 17; 7, 27; 7, 33; 7, 48; 7, 77; 8, expression_statement; 8, 9; 9, call; 9, 10; 9, 11; 10, identifier:print; 11, argument_list; 11, 12; 12, binary_operator:%; 12, 13; 12, 14; 13, string:'Dynamically removing uv=(%r, %r)'; 14, tuple; 14, 15; 14, 16; 15, identifier:u; 16, identifier:v; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:graph; 23, identifier:remove_edge; 24, argument_list; 24, 25; 24, 26; 25, identifier:u; 26, identifier:v; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:e; 30, tuple; 30, 31; 30, 32; 31, identifier:u; 32, identifier:v; 33, if_statement; 33, 34; 33, 46; 34, not_operator; 34, 35; 35, call; 35, 36; 35, 43; 36, attribute; 36, 37; 36, 42; 37, subscript; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:forests; 41, integer:0; 42, identifier:has_edge; 43, argument_list; 43, 44; 43, 45; 44, identifier:u; 45, identifier:v; 46, block; 46, 47; 47, return_statement; 48, for_statement; 48, 49; 48, 50; 48, 64; 49, identifier:i; 50, call; 50, 51; 50, 52; 51, identifier:reversed; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:range; 55, argument_list; 55, 56; 55, 57; 56, integer:0; 57, binary_operator:+; 57, 58; 57, 63; 58, subscript; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:level; 62, identifier:e; 63, integer:1; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 74; 67, attribute; 67, 68; 67, 73; 68, subscript; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:forests; 72, identifier:i; 73, identifier:remove_edge; 74, argument_list; 74, 75; 74, 76; 75, identifier:u; 76, identifier:v; 77, for_statement; 77, 78; 77, 79; 77, 93; 78, identifier:i; 79, call; 79, 80; 79, 81; 80, identifier:reversed; 81, argument_list; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:range; 84, argument_list; 84, 85; 84, 86; 85, integer:0; 86, binary_operator:+; 86, 87; 86, 92; 87, subscript; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:level; 91, identifier:e; 92, integer:1; 93, block; 93, 94; 93, 107; 93, 122; 93, 135; 93, 150; 93, 169; 93, 176; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:Tu; 97, call; 97, 98; 97, 105; 98, attribute; 98, 99; 98, 104; 99, subscript; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:forests; 103, identifier:i; 104, identifier:subtree; 105, argument_list; 105, 106; 106, identifier:u; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:print; 110, argument_list; 110, 111; 111, binary_operator:%; 111, 112; 111, 113; 112, string:'Tu = %r'; 113, tuple; 113, 114; 114, call; 114, 115; 114, 116; 115, identifier:list; 116, argument_list; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:Tu; 120, identifier:nodes; 121, argument_list; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:Tv; 125, call; 125, 126; 125, 133; 126, attribute; 126, 127; 126, 132; 127, subscript; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:forests; 131, identifier:i; 132, identifier:subtree; 133, argument_list; 133, 134; 134, identifier:v; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:print; 138, argument_list; 138, 139; 139, binary_operator:%; 139, 140; 139, 141; 140, string:'Tv = %r'; 141, tuple; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:list; 144, argument_list; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:Tv; 148, identifier:nodes; 149, argument_list; 150, if_statement; 150, 151; 150, 160; 151, comparison_operator:>; 151, 152; 151, 156; 152, call; 152, 153; 152, 154; 153, identifier:len; 154, argument_list; 154, 155; 155, identifier:Tu; 156, call; 156, 157; 156, 158; 157, identifier:len; 158, argument_list; 158, 159; 159, identifier:Tv; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 166; 163, pattern_list; 163, 164; 163, 165; 164, identifier:Tu; 165, identifier:Tv; 166, expression_list; 166, 167; 166, 168; 167, identifier:Tv; 168, identifier:Tu; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:seen_; 172, call; 172, 173; 172, 174; 173, identifier:set; 174, argument_list; 174, 175; 175, list:[]; 176, for_statement; 176, 177; 176, 178; 176, 183; 177, identifier:x; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:Tu; 181, identifier:nodes; 182, argument_list; 183, block; 183, 184; 183, 191; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:seen_; 188, identifier:add; 189, argument_list; 189, 190; 190, identifier:x; 191, for_statement; 191, 192; 191, 193; 191, 201; 192, identifier:y; 193, call; 193, 194; 193, 199; 194, attribute; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:self; 197, identifier:graph; 198, identifier:neighbors; 199, argument_list; 199, 200; 200, identifier:x; 201, block; 201, 202; 201, 208; 202, if_statement; 202, 203; 202, 206; 203, comparison_operator:in; 203, 204; 203, 205; 204, identifier:y; 205, identifier:seen_; 206, block; 206, 207; 207, continue_statement; 208, if_statement; 208, 209; 208, 212; 208, 283; 209, comparison_operator:in; 209, 210; 209, 211; 210, identifier:y; 211, identifier:Tv; 212, block; 212, 213; 212, 222; 212, 252; 212, 282; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:print; 216, argument_list; 216, 217; 217, binary_operator:%; 217, 218; 217, 219; 218, string:'* Found replacement xy=(%r, %r)'; 219, tuple; 219, 220; 219, 221; 220, identifier:x; 221, identifier:y; 222, if_statement; 222, 223; 222, 233; 223, comparison_operator:==; 223, 224; 223, 230; 224, call; 224, 225; 224, 226; 225, identifier:len; 226, argument_list; 226, 227; 227, attribute; 227, 228; 227, 229; 228, identifier:self; 229, identifier:forests; 230, binary_operator:+; 230, 231; 230, 232; 231, identifier:i; 232, integer:1; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 241; 236, attribute; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:self; 239, identifier:forests; 240, identifier:append; 241, argument_list; 241, 242; 242, call; 242, 243; 242, 244; 243, identifier:DummyEulerTourForest; 244, argument_list; 244, 245; 245, call; 245, 246; 245, 251; 246, attribute; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:self; 249, identifier:graph; 250, identifier:nodes; 251, argument_list; 252, for_statement; 252, 253; 252, 254; 252, 261; 253, identifier:j; 254, call; 254, 255; 254, 256; 255, identifier:range; 256, argument_list; 256, 257; 256, 258; 257, integer:0; 258, binary_operator:+; 258, 259; 258, 260; 259, identifier:i; 260, integer:2; 261, block; 261, 262; 261, 270; 262, expression_statement; 262, 263; 263, call; 263, 264; 263, 265; 264, identifier:print; 265, argument_list; 265, 266; 266, binary_operator:%; 266, 267; 266, 268; 267, string:'* Add replacment to F[j=%r]'; 268, tuple; 268, 269; 269, identifier:j; 270, expression_statement; 270, 271; 271, call; 271, 272; 271, 279; 272, attribute; 272, 273; 272, 278; 273, subscript; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:self; 276, identifier:forests; 277, identifier:j; 278, identifier:add_edge; 279, argument_list; 279, 280; 279, 281; 280, identifier:x; 281, identifier:y; 282, return_statement; 283, else_clause; 283, 284; 284, block; 284, 285; 284, 294; 284, 324; 284, 351; 285, expression_statement; 285, 286; 286, call; 286, 287; 286, 288; 287, identifier:print; 288, argument_list; 288, 289; 289, binary_operator:%; 289, 290; 289, 291; 290, string:'* Charging xy=(%r, %r)'; 291, tuple; 291, 292; 291, 293; 292, identifier:x; 293, identifier:y; 294, if_statement; 294, 295; 294, 305; 295, comparison_operator:==; 295, 296; 295, 302; 296, call; 296, 297; 296, 298; 297, identifier:len; 298, argument_list; 298, 299; 299, attribute; 299, 300; 299, 301; 300, identifier:self; 301, identifier:forests; 302, binary_operator:+; 302, 303; 302, 304; 303, identifier:i; 304, integer:1; 305, block; 305, 306; 306, expression_statement; 306, 307; 307, call; 307, 308; 307, 313; 308, attribute; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:self; 311, identifier:forests; 312, identifier:append; 313, argument_list; 313, 314; 314, call; 314, 315; 314, 316; 315, identifier:DummyEulerTourForest; 316, argument_list; 316, 317; 317, call; 317, 318; 317, 323; 318, attribute; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:self; 321, identifier:graph; 322, identifier:nodes; 323, argument_list; 324, if_statement; 324, 325; 324, 336; 325, call; 325, 326; 325, 333; 326, attribute; 326, 327; 326, 332; 327, subscript; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:self; 330, identifier:forests; 331, identifier:i; 332, identifier:has_edge; 333, argument_list; 333, 334; 333, 335; 334, identifier:x; 335, identifier:y; 336, block; 336, 337; 337, expression_statement; 337, 338; 338, call; 338, 339; 338, 348; 339, attribute; 339, 340; 339, 347; 340, subscript; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:self; 343, identifier:forests; 344, binary_operator:+; 344, 345; 344, 346; 345, identifier:i; 346, integer:1; 347, identifier:add_edge; 348, argument_list; 348, 349; 348, 350; 349, identifier:x; 350, identifier:y; 351, expression_statement; 351, 352; 352, assignment; 352, 353; 352, 360; 353, subscript; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:self; 356, identifier:level; 357, tuple; 357, 358; 357, 359; 358, identifier:x; 359, identifier:y; 360, binary_operator:+; 360, 361; 360, 362; 361, identifier:i; 362, integer:1 | def remove_edge(self, u, v):
print('Dynamically removing uv=(%r, %r)' % (u, v))
self.graph.remove_edge(u, v)
e = (u, v)
if not self.forests[0].has_edge(u, v):
return
for i in reversed(range(0, self.level[e] + 1)):
self.forests[i].remove_edge(u, v)
for i in reversed(range(0, self.level[e] + 1)):
Tu = self.forests[i].subtree(u)
print('Tu = %r' % (list(Tu.nodes()),))
Tv = self.forests[i].subtree(v)
print('Tv = %r' % (list(Tv.nodes()),))
if len(Tu) > len(Tv):
Tu, Tv = Tv, Tu
seen_ = set([])
for x in Tu.nodes():
seen_.add(x)
for y in self.graph.neighbors(x):
if y in seen_:
continue
if y in Tv:
print('* Found replacement xy=(%r, %r)' % (x, y))
if len(self.forests) == i + 1:
self.forests.append(DummyEulerTourForest(self.graph.nodes()))
for j in range(0, i + 2):
print('* Add replacment to F[j=%r]' % (j,))
self.forests[j].add_edge(x, y)
return
else:
print('* Charging xy=(%r, %r)' % (x, y))
if len(self.forests) == i + 1:
self.forests.append(DummyEulerTourForest(self.graph.nodes()))
if self.forests[i].has_edge(x, y):
self.forests[i + 1].add_edge(x, y)
self.level[(x, y)] = i + 1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 39; 2, function_name:get_stats_str; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 28; 3, 31; 3, 34; 3, 37; 4, default_parameter; 4, 5; 4, 6; 5, identifier:list_; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:newlines; 9, False; 10, default_parameter; 10, 11; 10, 12; 11, identifier:keys; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:exclude_keys; 15, list:[]; 16, default_parameter; 16, 17; 16, 18; 17, identifier:lbl; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:precision; 21, None; 22, default_parameter; 22, 23; 22, 24; 23, identifier:axis; 24, integer:0; 25, default_parameter; 25, 26; 25, 27; 26, identifier:stat_dict; 27, None; 28, default_parameter; 28, 29; 28, 30; 29, identifier:use_nan; 30, False; 31, default_parameter; 31, 32; 31, 33; 32, identifier:align; 33, False; 34, default_parameter; 34, 35; 34, 36; 35, identifier:use_median; 36, False; 37, dictionary_splat_pattern; 37, 38; 38, identifier:kwargs; 39, block; 39, 40; 39, 46; 39, 51; 39, 82; 39, 108; 39, 121; 39, 129; 39, 353; 39, 366; 39, 383; 39, 398; 39, 411; 40, import_from_statement; 40, 41; 40, 44; 41, dotted_name; 41, 42; 41, 43; 42, identifier:utool; 43, identifier:util_str; 44, dotted_name; 44, 45; 45, identifier:repr4; 46, import_statement; 46, 47; 47, aliased_import; 47, 48; 47, 50; 48, dotted_name; 48, 49; 49, identifier:utool; 50, identifier:ut; 51, if_statement; 51, 52; 51, 55; 51, 72; 52, comparison_operator:is; 52, 53; 52, 54; 53, identifier:stat_dict; 54, None; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:stat_dict; 59, call; 59, 60; 59, 61; 60, identifier:get_stats; 61, argument_list; 61, 62; 61, 63; 61, 66; 61, 69; 62, identifier:list_; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:axis; 65, identifier:axis; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:use_nan; 68, identifier:use_nan; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:use_median; 71, identifier:use_median; 72, else_clause; 72, 73; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:stat_dict; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:stat_dict; 80, identifier:copy; 81, argument_list; 82, if_statement; 82, 83; 82, 86; 83, comparison_operator:is; 83, 84; 83, 85; 84, identifier:keys; 85, None; 86, block; 86, 87; 87, for_statement; 87, 88; 87, 89; 87, 98; 88, identifier:key; 89, call; 89, 90; 89, 91; 90, identifier:list; 91, argument_list; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:six; 95, identifier:iterkeys; 96, argument_list; 96, 97; 97, identifier:stat_dict; 98, block; 98, 99; 99, if_statement; 99, 100; 99, 103; 100, comparison_operator:not; 100, 101; 100, 102; 101, identifier:key; 102, identifier:keys; 103, block; 103, 104; 104, delete_statement; 104, 105; 105, subscript; 105, 106; 105, 107; 106, identifier:stat_dict; 107, identifier:key; 108, for_statement; 108, 109; 108, 110; 108, 111; 109, identifier:key; 110, identifier:exclude_keys; 111, block; 111, 112; 112, if_statement; 112, 113; 112, 116; 113, comparison_operator:in; 113, 114; 113, 115; 114, identifier:key; 115, identifier:stat_dict; 116, block; 116, 117; 117, delete_statement; 117, 118; 118, subscript; 118, 119; 118, 120; 119, identifier:stat_dict; 120, identifier:key; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:statstr_dict; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:stat_dict; 127, identifier:copy; 128, argument_list; 129, if_statement; 129, 130; 129, 133; 130, comparison_operator:is; 130, 131; 130, 132; 131, identifier:precision; 132, None; 133, block; 133, 134; 133, 142; 133, 153; 134, assert_statement; 134, 135; 134, 141; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:ut; 138, identifier:is_int; 139, argument_list; 139, 140; 140, identifier:precision; 141, string:'precision must be an integer'; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:float_fmtstr; 145, binary_operator:+; 145, 146; 145, 152; 146, binary_operator:+; 146, 147; 146, 148; 147, string:'%.'; 148, call; 148, 149; 148, 150; 149, identifier:str; 150, argument_list; 150, 151; 151, identifier:precision; 152, string:'f'; 153, for_statement; 153, 154; 153, 155; 153, 164; 154, identifier:key; 155, call; 155, 156; 155, 157; 156, identifier:list; 157, argument_list; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:six; 161, identifier:iterkeys; 162, argument_list; 162, 163; 163, identifier:statstr_dict; 164, block; 164, 165; 164, 171; 164, 180; 164, 239; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:val; 168, subscript; 168, 169; 168, 170; 169, identifier:statstr_dict; 170, identifier:key; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:isfloat; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:ut; 177, identifier:is_float; 178, argument_list; 178, 179; 179, identifier:val; 180, if_statement; 180, 181; 180, 189; 181, boolean_operator:and; 181, 182; 181, 184; 182, not_operator; 182, 183; 183, identifier:isfloat; 184, call; 184, 185; 184, 186; 185, identifier:isinstance; 186, argument_list; 186, 187; 186, 188; 187, identifier:val; 188, identifier:list; 189, block; 189, 190; 189, 201; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:type_list; 193, call; 193, 194; 193, 195; 194, identifier:list; 195, argument_list; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:map; 198, argument_list; 198, 199; 198, 200; 199, identifier:type; 200, identifier:val; 201, if_statement; 201, 202; 201, 215; 202, boolean_operator:and; 202, 203; 202, 209; 203, comparison_operator:>; 203, 204; 203, 208; 204, call; 204, 205; 204, 206; 205, identifier:len; 206, argument_list; 206, 207; 207, identifier:type_list; 208, integer:0; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:ut; 212, identifier:allsame; 213, argument_list; 213, 214; 214, identifier:type_list; 215, block; 215, 216; 216, if_statement; 216, 217; 216, 225; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:ut; 220, identifier:is_float; 221, argument_list; 221, 222; 222, subscript; 222, 223; 222, 224; 223, identifier:val; 224, integer:0; 225, block; 225, 226; 225, 230; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:isfloat; 229, True; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:val; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:np; 236, identifier:array; 237, argument_list; 237, 238; 238, identifier:val; 239, if_statement; 239, 240; 239, 241; 239, 316; 240, identifier:isfloat; 241, block; 241, 242; 241, 283; 241, 310; 242, if_statement; 242, 243; 242, 250; 242, 275; 243, call; 243, 244; 243, 245; 244, identifier:isinstance; 245, argument_list; 245, 246; 245, 247; 246, identifier:val; 247, attribute; 247, 248; 247, 249; 248, identifier:np; 249, identifier:ndarray; 250, block; 250, 251; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:strval; 254, call; 254, 255; 254, 273; 255, attribute; 255, 256; 255, 272; 256, call; 256, 257; 256, 269; 257, attribute; 257, 258; 257, 268; 258, call; 258, 259; 258, 260; 259, identifier:str; 260, argument_list; 260, 261; 261, list_comprehension; 261, 262; 261, 265; 262, binary_operator:%; 262, 263; 262, 264; 263, identifier:float_fmtstr; 264, identifier:v; 265, for_in_clause; 265, 266; 265, 267; 266, identifier:v; 267, identifier:val; 268, identifier:replace; 269, argument_list; 269, 270; 269, 271; 270, string:'\''; 271, string:''; 272, identifier:lstrip; 273, argument_list; 273, 274; 274, string:'u'; 275, else_clause; 275, 276; 276, block; 276, 277; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:strval; 280, binary_operator:%; 280, 281; 280, 282; 281, identifier:float_fmtstr; 282, identifier:val; 283, if_statement; 283, 284; 283, 291; 284, not_operator; 284, 285; 285, call; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:strval; 288, identifier:startswith; 289, argument_list; 289, 290; 290, string:'0'; 291, block; 291, 292; 291, 301; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:strval; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:strval; 298, identifier:rstrip; 299, argument_list; 299, 300; 300, string:'0'; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:strval; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:strval; 307, identifier:rstrip; 308, argument_list; 308, 309; 309, string:'.'; 310, expression_statement; 310, 311; 311, assignment; 311, 312; 311, 315; 312, subscript; 312, 313; 312, 314; 313, identifier:statstr_dict; 314, identifier:key; 315, identifier:strval; 316, else_clause; 316, 317; 317, block; 317, 318; 317, 347; 318, if_statement; 318, 319; 318, 326; 318, 338; 319, call; 319, 320; 319, 321; 320, identifier:isinstance; 321, argument_list; 321, 322; 321, 323; 322, identifier:val; 323, attribute; 323, 324; 323, 325; 324, identifier:np; 325, identifier:ndarray; 326, block; 326, 327; 327, expression_statement; 327, 328; 328, assignment; 328, 329; 328, 330; 329, identifier:strval; 330, call; 330, 331; 330, 332; 331, identifier:repr; 332, argument_list; 332, 333; 333, call; 333, 334; 333, 337; 334, attribute; 334, 335; 334, 336; 335, identifier:val; 336, identifier:tolist; 337, argument_list; 338, else_clause; 338, 339; 339, block; 339, 340; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 343; 342, identifier:strval; 343, call; 343, 344; 343, 345; 344, identifier:str; 345, argument_list; 345, 346; 346, identifier:val; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 352; 349, subscript; 349, 350; 349, 351; 350, identifier:statstr_dict; 351, identifier:key; 352, identifier:strval; 353, expression_statement; 353, 354; 354, assignment; 354, 355; 354, 356; 355, identifier:stat_str; 356, call; 356, 357; 356, 358; 357, identifier:repr4; 358, argument_list; 358, 359; 358, 360; 358, 363; 359, identifier:statstr_dict; 360, keyword_argument; 360, 361; 360, 362; 361, identifier:strvals; 362, True; 363, keyword_argument; 363, 364; 363, 365; 364, identifier:newlines; 365, identifier:newlines; 366, if_statement; 366, 367; 366, 370; 367, comparison_operator:is; 367, 368; 367, 369; 368, identifier:lbl; 369, True; 370, block; 370, 371; 371, expression_statement; 371, 372; 372, assignment; 372, 373; 372, 374; 373, identifier:lbl; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:ut; 377, identifier:get_varname_from_stack; 378, argument_list; 378, 379; 378, 380; 379, identifier:list_; 380, keyword_argument; 380, 381; 380, 382; 381, identifier:N; 382, integer:1; 383, if_statement; 383, 384; 383, 387; 384, comparison_operator:is; 384, 385; 384, 386; 385, identifier:lbl; 386, None; 387, block; 387, 388; 388, expression_statement; 388, 389; 389, assignment; 389, 390; 389, 391; 390, identifier:stat_str; 391, binary_operator:+; 391, 392; 391, 397; 392, binary_operator:+; 392, 393; 392, 396; 393, binary_operator:+; 393, 394; 393, 395; 394, string:'stats_'; 395, identifier:lbl; 396, string:' = '; 397, identifier:stat_str; 398, if_statement; 398, 399; 398, 400; 399, identifier:align; 400, block; 400, 401; 401, expression_statement; 401, 402; 402, assignment; 402, 403; 402, 404; 403, identifier:stat_str; 404, call; 404, 405; 404, 408; 405, attribute; 405, 406; 405, 407; 406, identifier:ut; 407, identifier:align; 408, argument_list; 408, 409; 408, 410; 409, identifier:stat_str; 410, string:':'; 411, return_statement; 411, 412; 412, identifier:stat_str | def get_stats_str(list_=None, newlines=False, keys=None, exclude_keys=[], lbl=None,
precision=None, axis=0, stat_dict=None, use_nan=False,
align=False, use_median=False, **kwargs):
from utool.util_str import repr4
import utool as ut
if stat_dict is None:
stat_dict = get_stats(list_, axis=axis, use_nan=use_nan, use_median=use_median)
else:
stat_dict = stat_dict.copy()
if keys is not None:
for key in list(six.iterkeys(stat_dict)):
if key not in keys:
del stat_dict[key]
for key in exclude_keys:
if key in stat_dict:
del stat_dict[key]
statstr_dict = stat_dict.copy()
if precision is not None:
assert ut.is_int(precision), 'precision must be an integer'
float_fmtstr = '%.' + str(precision) + 'f'
for key in list(six.iterkeys(statstr_dict)):
val = statstr_dict[key]
isfloat = ut.is_float(val)
if not isfloat and isinstance(val, list):
type_list = list(map(type, val))
if len(type_list) > 0 and ut.allsame(type_list):
if ut.is_float(val[0]):
isfloat = True
val = np.array(val)
if isfloat:
if isinstance(val, np.ndarray):
strval = str([float_fmtstr % v for v in val]).replace('\'', '').lstrip('u')
else:
strval = float_fmtstr % val
if not strval.startswith('0'):
strval = strval.rstrip('0')
strval = strval.rstrip('.')
statstr_dict[key] = strval
else:
if isinstance(val, np.ndarray):
strval = repr(val.tolist())
else:
strval = str(val)
statstr_dict[key] = strval
stat_str = repr4(statstr_dict, strvals=True, newlines=newlines)
if lbl is True:
lbl = ut.get_varname_from_stack(list_, N=1)
if lbl is not None:
stat_str = 'stats_' + lbl + ' = ' + stat_str
if align:
stat_str = ut.align(stat_str, ':')
return stat_str |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:search_module; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:mod; 5, identifier:pat; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ignore_case; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:recursive; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:_seen; 14, None; 15, block; 15, 16; 15, 18; 15, 29; 15, 34; 15, 42; 15, 64; 15, 149; 15, 158; 16, expression_statement; 16, 17; 17, identifier:r; 18, if_statement; 18, 19; 18, 26; 19, boolean_operator:and; 19, 20; 19, 23; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:_seen; 22, None; 23, comparison_operator:in; 23, 24; 23, 25; 24, identifier:mod; 25, identifier:_seen; 26, block; 26, 27; 27, return_statement; 27, 28; 28, list:[]; 29, import_statement; 29, 30; 30, aliased_import; 30, 31; 30, 33; 31, dotted_name; 31, 32; 32, identifier:utool; 33, identifier:ut; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:reflags; 37, binary_operator:*; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:re; 40, identifier:IGNORECASE; 41, identifier:ignore_case; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:found_list; 45, list_comprehension; 45, 46; 45, 47; 45, 53; 46, identifier:name; 47, for_in_clause; 47, 48; 47, 49; 48, identifier:name; 49, call; 49, 50; 49, 51; 50, identifier:dir; 51, argument_list; 51, 52; 52, identifier:mod; 53, if_clause; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:re; 57, identifier:search; 58, argument_list; 58, 59; 58, 60; 58, 61; 59, identifier:pat; 60, identifier:name; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:flags; 63, identifier:reflags; 64, if_statement; 64, 65; 64, 66; 65, identifier:recursive; 66, block; 66, 67; 66, 78; 66, 85; 66, 100; 66, 128; 67, if_statement; 67, 68; 67, 71; 68, comparison_operator:is; 68, 69; 68, 70; 69, identifier:_seen; 70, None; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:_seen; 75, call; 75, 76; 75, 77; 76, identifier:set; 77, argument_list; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:_seen; 82, identifier:add; 83, argument_list; 83, 84; 84, identifier:mod; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:module_attrs; 88, list_comprehension; 88, 89; 88, 94; 89, call; 89, 90; 89, 91; 90, identifier:getattr; 91, argument_list; 91, 92; 91, 93; 92, identifier:mod; 93, identifier:name; 94, for_in_clause; 94, 95; 94, 96; 95, identifier:name; 96, call; 96, 97; 96, 98; 97, identifier:dir; 98, argument_list; 98, 99; 99, identifier:mod; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:submodules; 103, list_comprehension; 103, 104; 103, 105; 103, 108; 104, identifier:submod; 105, for_in_clause; 105, 106; 105, 107; 106, identifier:submod; 107, identifier:module_attrs; 108, if_clause; 108, 109; 109, boolean_operator:and; 109, 110; 109, 121; 110, boolean_operator:and; 110, 111; 110, 118; 111, call; 111, 112; 111, 113; 112, identifier:isinstance; 113, argument_list; 113, 114; 113, 115; 114, identifier:submod; 115, attribute; 115, 116; 115, 117; 116, identifier:types; 117, identifier:ModuleType; 118, comparison_operator:not; 118, 119; 118, 120; 119, identifier:submod; 120, identifier:_seen; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:ut; 124, identifier:is_defined_by_module; 125, argument_list; 125, 126; 125, 127; 126, identifier:submod; 127, identifier:mod; 128, for_statement; 128, 129; 128, 130; 128, 131; 129, identifier:submod; 130, identifier:submodules; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, augmented_assignment:+=; 133, 134; 133, 135; 134, identifier:found_list; 135, call; 135, 136; 135, 137; 136, identifier:search_module; 137, argument_list; 137, 138; 137, 139; 137, 140; 137, 143; 137, 146; 138, identifier:submod; 139, identifier:pat; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:ignore_case; 142, identifier:ignore_case; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:recursive; 145, identifier:recursive; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:_seen; 148, identifier:_seen; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:found_list; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:ut; 155, identifier:unique_ordered; 156, argument_list; 156, 157; 157, identifier:found_list; 158, return_statement; 158, 159; 159, identifier:found_list | def search_module(mod, pat, ignore_case=True, recursive=False, _seen=None):
r
if _seen is not None and mod in _seen:
return []
import utool as ut
reflags = re.IGNORECASE * ignore_case
found_list = [name for name in dir(mod) if re.search(pat, name, flags=reflags)]
if recursive:
if _seen is None:
_seen = set()
_seen.add(mod)
module_attrs = [getattr(mod, name) for name in dir(mod)]
submodules = [
submod for submod in module_attrs
if isinstance(submod, types.ModuleType) and submod not in _seen and
ut.is_defined_by_module(submod, mod)
]
for submod in submodules:
found_list += search_module(submod, pat, ignore_case=ignore_case, recursive=recursive, _seen=_seen)
found_list = ut.unique_ordered(found_list)
return found_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:instancelist; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:obj_list; 5, default_parameter; 5, 6; 5, 7; 6, identifier:check; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:shared_attrs; 10, None; 11, block; 11, 12; 11, 455; 12, class_definition; 12, 13; 12, 14; 12, 16; 13, identifier:InstanceList_; 14, argument_list; 14, 15; 15, identifier:object; 16, block; 16, 17; 16, 213; 16, 250; 16, 284; 16, 311; 16, 325; 16, 366; 16, 398; 16, 433; 17, function_definition; 17, 18; 17, 19; 17, 25; 18, function_name:__init__; 19, parameters; 19, 20; 19, 21; 19, 22; 20, identifier:self; 21, identifier:obj_list; 22, default_parameter; 22, 23; 22, 24; 23, identifier:shared_attrs; 24, None; 25, block; 25, 26; 25, 32; 25, 38; 25, 44; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:_obj_list; 31, list:[]; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_shared_public_attrs; 37, list:[]; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:_example_type; 43, None; 44, if_statement; 44, 45; 44, 51; 45, comparison_operator:>; 45, 46; 45, 50; 46, call; 46, 47; 46, 48; 47, identifier:len; 48, argument_list; 48, 49; 49, identifier:obj_list; 50, integer:0; 51, block; 51, 52; 51, 57; 51, 63; 51, 69; 51, 76; 51, 82; 51, 126; 51, 130; 51, 152; 52, import_statement; 52, 53; 53, aliased_import; 53, 54; 53, 56; 54, dotted_name; 54, 55; 55, identifier:utool; 56, identifier:ut; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:_obj_list; 62, identifier:obj_list; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:example_obj; 66, subscript; 66, 67; 66, 68; 67, identifier:obj_list; 68, integer:0; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:example_type; 72, call; 72, 73; 72, 74; 73, identifier:type; 74, argument_list; 74, 75; 75, identifier:example_obj; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_example_type; 81, identifier:example_type; 82, if_statement; 82, 83; 82, 86; 83, comparison_operator:is; 83, 84; 83, 85; 84, identifier:shared_attrs; 85, None; 86, block; 86, 87; 87, if_statement; 87, 88; 87, 89; 87, 117; 88, identifier:check; 89, block; 89, 90; 89, 104; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:attrsgen; 93, list_comprehension; 93, 94; 93, 101; 94, call; 94, 95; 94, 96; 95, identifier:set; 96, argument_list; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:dir; 99, argument_list; 99, 100; 100, identifier:obj; 101, for_in_clause; 101, 102; 101, 103; 102, identifier:obj; 103, identifier:obj_list; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:shared_attrs; 107, call; 107, 108; 107, 109; 108, identifier:list; 109, argument_list; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:reduce; 112, argument_list; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:set; 115, identifier:intersection; 116, identifier:attrsgen; 117, else_clause; 117, 118; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:shared_attrs; 122, call; 122, 123; 122, 124; 123, identifier:dir; 124, argument_list; 124, 125; 125, identifier:example_obj; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:allowed; 129, list:[]; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:_shared_public_attrs; 135, list_comprehension; 135, 136; 135, 137; 135, 140; 136, identifier:a; 137, for_in_clause; 137, 138; 137, 139; 138, identifier:a; 139, identifier:shared_attrs; 140, if_clause; 140, 141; 141, boolean_operator:or; 141, 142; 141, 145; 142, comparison_operator:in; 142, 143; 142, 144; 143, identifier:a; 144, identifier:allowed; 145, not_operator; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:a; 149, identifier:startswith; 150, argument_list; 150, 151; 151, string:'_'; 152, for_statement; 152, 153; 152, 154; 152, 157; 153, identifier:attrname; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:_shared_public_attrs; 157, block; 157, 158; 157, 167; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:attrtype; 161, call; 161, 162; 161, 163; 162, identifier:getattr; 163, argument_list; 163, 164; 163, 165; 163, 166; 164, identifier:example_type; 165, identifier:attrname; 166, None; 167, if_statement; 167, 168; 167, 177; 167, 193; 168, boolean_operator:and; 168, 169; 168, 172; 169, comparison_operator:is; 169, 170; 169, 171; 170, identifier:attrtype; 171, None; 172, call; 172, 173; 172, 174; 173, identifier:isinstance; 174, argument_list; 174, 175; 174, 176; 175, identifier:attrtype; 176, identifier:property; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, call; 179, 180; 179, 181; 180, identifier:setattr; 181, argument_list; 181, 182; 181, 183; 181, 184; 182, identifier:InstanceList_; 183, identifier:attrname; 184, call; 184, 185; 184, 186; 185, identifier:property; 186, argument_list; 186, 187; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:self; 190, identifier:_define_prop; 191, argument_list; 191, 192; 192, identifier:attrname; 193, else_clause; 193, 194; 194, block; 194, 195; 194, 204; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:func; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:self; 201, identifier:_define_func; 202, argument_list; 202, 203; 203, identifier:attrname; 204, expression_statement; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:ut; 208, identifier:inject_func_as_method; 209, argument_list; 209, 210; 209, 211; 209, 212; 210, identifier:self; 211, identifier:func; 212, identifier:attrname; 213, function_definition; 213, 214; 213, 215; 213, 217; 214, function_name:__nice__; 215, parameters; 215, 216; 216, identifier:self; 217, block; 217, 218; 217, 239; 218, if_statement; 218, 219; 218, 224; 218, 229; 219, comparison_operator:is; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:self; 222, identifier:_example_type; 223, None; 224, block; 224, 225; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:typename; 228, string:'object'; 229, else_clause; 229, 230; 230, block; 230, 231; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:typename; 234, attribute; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:self; 237, identifier:_example_type; 238, identifier:__name__; 239, return_statement; 239, 240; 240, binary_operator:%; 240, 241; 240, 242; 241, string:'of %d %s(s)'; 242, tuple; 242, 243; 242, 249; 243, call; 243, 244; 243, 245; 244, identifier:len; 245, argument_list; 245, 246; 246, attribute; 246, 247; 246, 248; 247, identifier:self; 248, identifier:_obj_list; 249, identifier:typename; 250, function_definition; 250, 251; 250, 252; 250, 254; 251, function_name:__repr__; 252, parameters; 252, 253; 253, identifier:self; 254, block; 254, 255; 254, 263; 254, 271; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:classname; 258, attribute; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:self; 261, identifier:__class__; 262, identifier:__name__; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 266; 265, identifier:devnice; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:self; 269, identifier:__nice__; 270, argument_list; 271, return_statement; 271, 272; 272, binary_operator:%; 272, 273; 272, 274; 273, string:'<%s(%s) at %s>'; 274, tuple; 274, 275; 274, 276; 274, 277; 275, identifier:classname; 276, identifier:devnice; 277, call; 277, 278; 277, 279; 278, identifier:hex; 279, argument_list; 279, 280; 280, call; 280, 281; 280, 282; 281, identifier:id; 282, argument_list; 282, 283; 283, identifier:self; 284, function_definition; 284, 285; 284, 286; 284, 288; 285, function_name:__str__; 286, parameters; 286, 287; 287, identifier:self; 288, block; 288, 289; 288, 297; 288, 305; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 292; 291, identifier:classname; 292, attribute; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:self; 295, identifier:__class__; 296, identifier:__name__; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:devnice; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:self; 303, identifier:__nice__; 304, argument_list; 305, return_statement; 305, 306; 306, binary_operator:%; 306, 307; 306, 308; 307, string:'<%s(%s)>'; 308, tuple; 308, 309; 308, 310; 309, identifier:classname; 310, identifier:devnice; 311, function_definition; 311, 312; 311, 313; 311, 316; 312, function_name:__getitem__; 313, parameters; 313, 314; 313, 315; 314, identifier:self; 315, identifier:key; 316, block; 316, 317; 317, return_statement; 317, 318; 318, call; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:self; 321, identifier:_map_method; 322, argument_list; 322, 323; 322, 324; 323, string:'__getitem__'; 324, identifier:key; 325, function_definition; 325, 326; 325, 327; 325, 330; 326, function_name:_define_func; 327, parameters; 327, 328; 327, 329; 328, identifier:self; 329, identifier:attrname; 330, block; 330, 331; 330, 336; 330, 356; 330, 364; 331, import_statement; 331, 332; 332, aliased_import; 332, 333; 332, 335; 333, dotted_name; 333, 334; 334, identifier:utool; 335, identifier:ut; 336, function_definition; 336, 337; 336, 338; 336, 344; 337, function_name:_wrapper; 338, parameters; 338, 339; 338, 340; 338, 342; 339, identifier:self; 340, list_splat_pattern; 340, 341; 341, identifier:args; 342, dictionary_splat_pattern; 342, 343; 343, identifier:kwargs; 344, block; 344, 345; 345, return_statement; 345, 346; 346, call; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, identifier:self; 349, identifier:_map_method; 350, argument_list; 350, 351; 350, 352; 350, 354; 351, identifier:attrname; 352, list_splat; 352, 353; 353, identifier:args; 354, dictionary_splat; 354, 355; 355, identifier:kwargs; 356, expression_statement; 356, 357; 357, call; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, identifier:ut; 360, identifier:set_funcname; 361, argument_list; 361, 362; 361, 363; 362, identifier:_wrapper; 363, identifier:attrname; 364, return_statement; 364, 365; 365, identifier:_wrapper; 366, function_definition; 366, 367; 366, 368; 366, 375; 367, function_name:_map_method; 368, parameters; 368, 369; 368, 370; 368, 371; 368, 373; 369, identifier:self; 370, identifier:attrname; 371, list_splat_pattern; 371, 372; 372, identifier:args; 373, dictionary_splat_pattern; 373, 374; 374, identifier:kwargs; 375, block; 375, 376; 375, 396; 376, expression_statement; 376, 377; 377, assignment; 377, 378; 377, 379; 378, identifier:mapped_vals; 379, list_comprehension; 379, 380; 379, 391; 380, call; 380, 381; 380, 386; 381, call; 381, 382; 381, 383; 382, identifier:getattr; 383, argument_list; 383, 384; 383, 385; 384, identifier:obj; 385, identifier:attrname; 386, argument_list; 386, 387; 386, 389; 387, list_splat; 387, 388; 388, identifier:args; 389, dictionary_splat; 389, 390; 390, identifier:kwargs; 391, for_in_clause; 391, 392; 391, 393; 392, identifier:obj; 393, attribute; 393, 394; 393, 395; 394, identifier:self; 395, identifier:_obj_list; 396, return_statement; 396, 397; 397, identifier:mapped_vals; 398, function_definition; 398, 399; 398, 400; 398, 403; 399, function_name:_define_prop; 400, parameters; 400, 401; 400, 402; 401, identifier:self; 402, identifier:attrname; 403, block; 403, 404; 403, 409; 403, 421; 403, 431; 404, import_statement; 404, 405; 405, aliased_import; 405, 406; 405, 408; 406, dotted_name; 406, 407; 407, identifier:utool; 408, identifier:ut; 409, function_definition; 409, 410; 409, 411; 409, 413; 410, function_name:_getter; 411, parameters; 411, 412; 412, identifier:self; 413, block; 413, 414; 414, return_statement; 414, 415; 415, call; 415, 416; 415, 419; 416, attribute; 416, 417; 416, 418; 417, identifier:self; 418, identifier:_map_property; 419, argument_list; 419, 420; 420, identifier:attrname; 421, expression_statement; 421, 422; 422, call; 422, 423; 422, 426; 423, attribute; 423, 424; 423, 425; 424, identifier:ut; 425, identifier:set_funcname; 426, argument_list; 426, 427; 426, 428; 427, identifier:_getter; 428, binary_operator:+; 428, 429; 428, 430; 429, string:'get_'; 430, identifier:attrname; 431, return_statement; 431, 432; 432, identifier:_getter; 433, function_definition; 433, 434; 433, 435; 433, 438; 434, function_name:_map_property; 435, parameters; 435, 436; 435, 437; 436, identifier:self; 437, identifier:attrname; 438, block; 438, 439; 438, 453; 439, expression_statement; 439, 440; 440, assignment; 440, 441; 440, 442; 441, identifier:mapped_vals; 442, list_comprehension; 442, 443; 442, 448; 443, call; 443, 444; 443, 445; 444, identifier:getattr; 445, argument_list; 445, 446; 445, 447; 446, identifier:obj; 447, identifier:attrname; 448, for_in_clause; 448, 449; 448, 450; 449, identifier:obj; 450, attribute; 450, 451; 450, 452; 451, identifier:self; 452, identifier:_obj_list; 453, return_statement; 453, 454; 454, identifier:mapped_vals; 455, return_statement; 455, 456; 456, call; 456, 457; 456, 458; 457, identifier:InstanceList_; 458, argument_list; 458, 459; 458, 460; 459, identifier:obj_list; 460, identifier:shared_attrs | def instancelist(obj_list, check=False, shared_attrs=None):
class InstanceList_(object):
def __init__(self, obj_list, shared_attrs=None):
self._obj_list = []
self._shared_public_attrs = []
self._example_type = None
if len(obj_list) > 0:
import utool as ut
self._obj_list = obj_list
example_obj = obj_list[0]
example_type = type(example_obj)
self._example_type = example_type
if shared_attrs is None:
if check:
attrsgen = [set(dir(obj)) for obj in obj_list]
shared_attrs = list(reduce(set.intersection, attrsgen))
else:
shared_attrs = dir(example_obj)
allowed = []
self._shared_public_attrs = [
a for a in shared_attrs
if a in allowed or not a.startswith('_')
]
for attrname in self._shared_public_attrs:
attrtype = getattr(example_type, attrname, None)
if attrtype is not None and isinstance(attrtype, property):
setattr(InstanceList_, attrname,
property(self._define_prop(attrname)))
else:
func = self._define_func(attrname)
ut.inject_func_as_method(self, func, attrname)
def __nice__(self):
if self._example_type is None:
typename = 'object'
else:
typename = self._example_type.__name__
return 'of %d %s(s)' % (len(self._obj_list), typename)
def __repr__(self):
classname = self.__class__.__name__
devnice = self.__nice__()
return '<%s(%s) at %s>' % (classname, devnice, hex(id(self)))
def __str__(self):
classname = self.__class__.__name__
devnice = self.__nice__()
return '<%s(%s)>' % (classname, devnice)
def __getitem__(self, key):
return self._map_method('__getitem__', key)
def _define_func(self, attrname):
import utool as ut
def _wrapper(self, *args, **kwargs):
return self._map_method(attrname, *args, **kwargs)
ut.set_funcname(_wrapper, attrname)
return _wrapper
def _map_method(self, attrname, *args, **kwargs):
mapped_vals = [getattr(obj, attrname)(*args, **kwargs)
for obj in self._obj_list]
return mapped_vals
def _define_prop(self, attrname):
import utool as ut
def _getter(self):
return self._map_property(attrname)
ut.set_funcname(_getter, 'get_' + attrname)
return _getter
def _map_property(self, attrname):
mapped_vals = [getattr(obj, attrname) for obj in self._obj_list]
return mapped_vals
return InstanceList_(obj_list, shared_attrs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:merge_rows; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:merge_scalars; 8, True; 9, block; 9, 10; 9, 15; 9, 26; 9, 41; 9, 56; 9, 70; 9, 83; 9, 87; 9, 301; 9, 312; 9, 318; 10, import_statement; 10, 11; 11, aliased_import; 11, 12; 11, 14; 12, dotted_name; 12, 13; 13, identifier:utool; 14, identifier:ut; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 20; 17, pattern_list; 17, 18; 17, 19; 18, identifier:unique_labels; 19, identifier:groupxs; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:group_indicies; 24, argument_list; 24, 25; 25, identifier:key; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:single_xs; 29, list_comprehension; 29, 30; 29, 31; 29, 34; 30, identifier:xs; 31, for_in_clause; 31, 32; 31, 33; 32, identifier:xs; 33, identifier:groupxs; 34, if_clause; 34, 35; 35, comparison_operator:==; 35, 36; 35, 40; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, identifier:xs; 40, integer:1; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:multi_xs; 44, list_comprehension; 44, 45; 44, 46; 44, 49; 45, identifier:xs; 46, for_in_clause; 46, 47; 46, 48; 47, identifier:xs; 48, identifier:groupxs; 49, if_clause; 49, 50; 50, comparison_operator:>; 50, 51; 50, 55; 51, call; 51, 52; 51, 53; 52, identifier:len; 53, argument_list; 53, 54; 54, identifier:xs; 55, integer:1; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:singles; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:take; 63, argument_list; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:ut; 67, identifier:flatten; 68, argument_list; 68, 69; 69, identifier:single_xs; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:multis; 73, list_comprehension; 73, 74; 73, 80; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:take; 78, argument_list; 78, 79; 79, identifier:idxs; 80, for_in_clause; 80, 81; 80, 82; 81, identifier:idxs; 82, identifier:multi_xs; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:merged_groups; 86, list:[]; 87, for_statement; 87, 88; 87, 89; 87, 90; 88, identifier:group; 89, identifier:multis; 90, block; 90, 91; 90, 95; 90, 289; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:newgroup; 94, dictionary; 95, for_statement; 95, 96; 95, 97; 95, 102; 96, identifier:key_; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:group; 100, identifier:keys; 101, argument_list; 102, block; 102, 103; 102, 109; 102, 282; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:val; 106, subscript; 106, 107; 106, 108; 107, identifier:group; 108, identifier:key_; 109, if_statement; 109, 110; 109, 113; 109, 120; 109, 143; 109, 167; 109, 187; 109, 207; 110, comparison_operator:==; 110, 111; 110, 112; 111, identifier:key_; 112, identifier:key; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:val_; 117, subscript; 117, 118; 117, 119; 118, identifier:val; 119, integer:0; 120, elif_clause; 120, 121; 120, 130; 121, call; 121, 122; 121, 123; 122, identifier:hasattr; 123, argument_list; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:val; 127, integer:0; 128, identifier:__class__; 129, string:'union'; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:val_; 134, call; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:ut; 138, identifier:oset; 139, identifier:union; 140, argument_list; 140, 141; 141, list_splat; 141, 142; 142, identifier:val; 143, elif_clause; 143, 144; 143, 154; 144, call; 144, 145; 144, 146; 145, identifier:isinstance; 146, argument_list; 146, 147; 146, 150; 147, subscript; 147, 148; 147, 149; 148, identifier:val; 149, integer:0; 150, tuple; 150, 151; 151, attribute; 151, 152; 151, 153; 152, identifier:ut; 153, identifier:oset; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:val_; 158, call; 158, 159; 158, 164; 159, attribute; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:ut; 162, identifier:oset; 163, identifier:union; 164, argument_list; 164, 165; 165, list_splat; 165, 166; 166, identifier:val; 167, elif_clause; 167, 168; 167, 176; 168, call; 168, 169; 168, 170; 169, identifier:isinstance; 170, argument_list; 170, 171; 170, 174; 171, subscript; 171, 172; 171, 173; 172, identifier:val; 173, integer:0; 174, parenthesized_expression; 174, 175; 175, identifier:set; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:val_; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:set; 183, identifier:union; 184, argument_list; 184, 185; 185, list_splat; 185, 186; 186, identifier:val; 187, elif_clause; 187, 188; 187, 197; 188, call; 188, 189; 188, 190; 189, identifier:isinstance; 190, argument_list; 190, 191; 190, 194; 191, subscript; 191, 192; 191, 193; 192, identifier:val; 193, integer:0; 194, tuple; 194, 195; 194, 196; 195, identifier:tuple; 196, identifier:list; 197, block; 197, 198; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:val_; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:ut; 204, identifier:flatten; 205, argument_list; 205, 206; 206, identifier:val; 207, else_clause; 207, 208; 208, block; 208, 209; 209, if_statement; 209, 210; 209, 216; 209, 223; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:ut; 213, identifier:allsame; 214, argument_list; 214, 215; 215, identifier:val; 216, block; 216, 217; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:val_; 220, subscript; 220, 221; 220, 222; 221, identifier:val; 222, integer:0; 223, else_clause; 223, 224; 224, block; 224, 225; 225, if_statement; 225, 226; 225, 227; 225, 232; 226, identifier:merge_scalars; 227, block; 227, 228; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:val_; 231, identifier:val; 232, else_clause; 232, 233; 233, block; 233, 234; 234, if_statement; 234, 235; 234, 236; 234, 271; 235, True; 236, block; 236, 237; 236, 246; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:other_vals; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:ut; 243, identifier:filter_Nones; 244, argument_list; 244, 245; 245, identifier:val; 246, if_statement; 246, 247; 246, 253; 246, 260; 247, comparison_operator:==; 247, 248; 247, 252; 248, call; 248, 249; 248, 250; 249, identifier:len; 250, argument_list; 250, 251; 251, identifier:other_vals; 252, integer:1; 253, block; 253, 254; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:val_; 257, subscript; 257, 258; 257, 259; 258, identifier:val; 259, integer:0; 260, else_clause; 260, 261; 261, block; 261, 262; 262, raise_statement; 262, 263; 263, call; 263, 264; 263, 265; 264, identifier:ValueError; 265, argument_list; 265, 266; 266, binary_operator:%; 266, 267; 266, 268; 267, string:'tried to merge a scalar in %r, val=%r'; 268, tuple; 268, 269; 268, 270; 269, identifier:key_; 270, identifier:val; 271, else_clause; 271, 272; 272, block; 272, 273; 273, raise_statement; 273, 274; 274, call; 274, 275; 274, 276; 275, identifier:ValueError; 276, argument_list; 276, 277; 277, binary_operator:%; 277, 278; 277, 279; 278, string:'tried to merge a scalar in %r, val=%r'; 279, tuple; 279, 280; 279, 281; 280, identifier:key_; 281, identifier:val; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 287; 284, subscript; 284, 285; 284, 286; 285, identifier:newgroup; 286, identifier:key_; 287, list:[val_]; 287, 288; 288, identifier:val_; 289, expression_statement; 289, 290; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:merged_groups; 293, identifier:append; 294, argument_list; 294, 295; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:ut; 298, identifier:ColumnLists; 299, argument_list; 299, 300; 300, identifier:newgroup; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:merged_multi; 304, call; 304, 305; 304, 310; 305, attribute; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:self; 308, identifier:__class__; 309, identifier:flatten; 310, argument_list; 310, 311; 311, identifier:merged_groups; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 315; 314, identifier:merged; 315, binary_operator:+; 315, 316; 315, 317; 316, identifier:singles; 317, identifier:merged_multi; 318, return_statement; 318, 319; 319, identifier:merged | def merge_rows(self, key, merge_scalars=True):
import utool as ut
unique_labels, groupxs = self.group_indicies(key)
single_xs = [xs for xs in groupxs if len(xs) == 1]
multi_xs = [xs for xs in groupxs if len(xs) > 1]
singles = self.take(ut.flatten(single_xs))
multis = [self.take(idxs) for idxs in multi_xs]
merged_groups = []
for group in multis:
newgroup = {}
for key_ in group.keys():
val = group[key_]
if key_ == key:
val_ = val[0]
elif hasattr(val[0].__class__, 'union'):
val_ = ut.oset.union(*val)
elif isinstance(val[0], (ut.oset,)):
val_ = ut.oset.union(*val)
elif isinstance(val[0], (set)):
val_ = set.union(*val)
elif isinstance(val[0], (tuple, list)):
val_ = ut.flatten(val)
else:
if ut.allsame(val):
val_ = val[0]
else:
if merge_scalars:
val_ = val
else:
if True:
other_vals = ut.filter_Nones(val)
if len(other_vals) == 1:
val_ = val[0]
else:
raise ValueError(
'tried to merge a scalar in %r, val=%r' % (
key_, val))
else:
raise ValueError(
'tried to merge a scalar in %r, val=%r' % (
key_, val))
newgroup[key_] = [val_]
merged_groups.append(ut.ColumnLists(newgroup))
merged_multi = self.__class__.flatten(merged_groups)
merged = singles + merged_multi
return merged |
0, module; 0, 1; 1, ERROR; 1, 2; 1, 98; 1, 115; 1, 131; 1, 145; 2, function_definition; 2, 3; 2, 4; 2, 7; 2, 59; 3, function_name:_inject_execstr; 4, parameters; 4, 5; 4, 6; 5, identifier:modname; 6, identifier:import_tuples; 7, ERROR; 7, 8; 7, 31; 7, 40; 7, 41; 7, 44; 7, 46; 8, if_statement; 8, 9; 8, 12; 8, 21; 9, comparison_operator:==; 9, 10; 9, 11; 10, identifier:modname; 11, string:'utool'; 12, block; 12, 13; 12, 17; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:injecter; 16, string:'util_inject'; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:injecter_import; 20, string:''; 21, else_clause; 21, 22; 22, block; 22, 23; 22, 27; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:injecter_import; 26, string:'import utool'; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:injecter; 30, string:'utool'; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:injectstr_fmt; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:textwrap; 37, identifier:dedent; 38, argument_list; 38, 39; 39, string:r'''
{injecter_import}
print, rrr, profile = {injecter}.inject2(__name__, '[{modname}]')
def reassign_submodule_attributes(verbose=1):
import sys
if verbose and '--quiet' not in sys.argv:
print('dev reimport')
import {modname}
seen_ = set([])
for tup in IMPORT_TUPLES:
if len(tup) > 2 and tup[2]:
continue
submodname, fromimports = tup[0:2]
submod = getattr({modname}, submodname)
for attr in dir(submod):
if attr.startswith('_'):
continue
if attr in seen_:
continue
seen_.add(attr)
setattr({modname}, attr, getattr(submod, attr))
def reload_subs(verbose=1):
if verbose:
print('Reloading {modname} submodules')
rrr(verbose > 1)
def wrap_fbrrr(mod):
def fbrrr(*args, **kwargs):
if verbose > 0:
print('Auto-reload (using rrr) not setup for mod=%r' % (mod,))
return fbrrr
def get_rrr(mod):
if hasattr(mod, 'rrr'):
return mod.rrr
else:
return wrap_fbrrr(mod)
def get_reload_subs(mod):
return getattr(mod, 'reload_subs', wrap_fbrrr(mod))
{reload_body}
rrr(verbose > 1)
try:
reassign_submodule_attributes(verbose=verbose)
except Exception as ex:
print(ex)
rrrr = reload_subs
'''; 40, identifier:injectstr_fmt; 41, attribute; 41, 42; 41, 43; 42, identifier:injectstr_fmt; 43, identifier:replace; 44, ERROR; 44, 45; 45, string:'
injectstr_fmt = injectstr_fmt.replace('; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:rrrdir_fmt; 48, call; 48, 49; 48, 54; 48, 57; 49, concatenated_string; 49, 50; 49, 51; 49, 53; 50, string:' get_reload_subs({modname})(verbose=verbose)'; 51, ERROR; 51, 52; 52, identifier:rrrfile_fmt; 53, string:' get_rrr({modname})(verbose > 1)'; 54, ERROR; 54, 55; 54, 56; 55, identifier:def; 56, identifier:_reload_command; 57, argument_list; 57, 58; 58, identifier:tup; 59, block; 59, 60; 60, if_statement; 60, 61; 60, 73; 60, 85; 61, boolean_operator:and; 61, 62; 61, 68; 62, comparison_operator:>; 62, 63; 62, 67; 63, call; 63, 64; 63, 65; 64, identifier:len; 65, argument_list; 65, 66; 66, identifier:tup; 67, integer:2; 68, comparison_operator:is; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:tup; 71, integer:2; 72, True; 73, block; 73, 74; 74, return_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:rrrdir_fmt; 78, identifier:format; 79, argument_list; 79, 80; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:modname; 82, subscript; 82, 83; 82, 84; 83, identifier:tup; 84, integer:0; 85, else_clause; 85, 86; 86, block; 86, 87; 87, return_statement; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:rrrfile_fmt; 91, identifier:format; 92, argument_list; 92, 93; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:modname; 95, subscript; 95, 96; 95, 97; 96, identifier:tup; 97, integer:0; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:reload_body; 101, call; 101, 102; 101, 114; 102, attribute; 102, 103; 102, 113; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, string:'\n'; 106, identifier:join; 107, argument_list; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:map; 110, argument_list; 110, 111; 110, 112; 111, identifier:_reload_command; 112, identifier:import_tuples; 113, identifier:strip; 114, argument_list; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:format_dict; 118, dictionary; 118, 119; 118, 122; 118, 125; 118, 128; 119, pair; 119, 120; 119, 121; 120, string:'modname'; 121, identifier:modname; 122, pair; 122, 123; 122, 124; 123, string:'reload_body'; 124, identifier:reload_body; 125, pair; 125, 126; 125, 127; 126, string:'injecter'; 127, identifier:injecter; 128, pair; 128, 129; 128, 130; 129, string:'injecter_import'; 130, identifier:injecter_import; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:inject_execstr; 134, call; 134, 135; 134, 144; 135, attribute; 135, 136; 135, 143; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:injectstr_fmt; 139, identifier:format; 140, argument_list; 140, 141; 141, dictionary_splat; 141, 142; 142, identifier:format_dict; 143, identifier:strip; 144, argument_list; 145, return_statement; 145, 146; 146, identifier:inject_execstr | def _inject_execstr(modname, import_tuples):
if modname == 'utool':
injecter = 'util_inject'
injecter_import = ''
else:
injecter_import = 'import utool'
injecter = 'utool'
injectstr_fmt = textwrap.dedent(
r'''
{injecter_import}
print, rrr, profile = {injecter}.inject2(__name__, '[{modname}]')
def reassign_submodule_attributes(verbose=1):
import sys
if verbose and '--quiet' not in sys.argv:
print('dev reimport')
import {modname}
seen_ = set([])
for tup in IMPORT_TUPLES:
if len(tup) > 2 and tup[2]:
continue
submodname, fromimports = tup[0:2]
submod = getattr({modname}, submodname)
for attr in dir(submod):
if attr.startswith('_'):
continue
if attr in seen_:
continue
seen_.add(attr)
setattr({modname}, attr, getattr(submod, attr))
def reload_subs(verbose=1):
if verbose:
print('Reloading {modname} submodules')
rrr(verbose > 1)
def wrap_fbrrr(mod):
def fbrrr(*args, **kwargs):
if verbose > 0:
print('Auto-reload (using rrr) not setup for mod=%r' % (mod,))
return fbrrr
def get_rrr(mod):
if hasattr(mod, 'rrr'):
return mod.rrr
else:
return wrap_fbrrr(mod)
def get_reload_subs(mod):
return getattr(mod, 'reload_subs', wrap_fbrrr(mod))
{reload_body}
rrr(verbose > 1)
try:
reassign_submodule_attributes(verbose=verbose)
except Exception as ex:
print(ex)
rrrr = reload_subs
''')
injectstr_fmt = injectstr_fmt.replace('
injectstr_fmt = injectstr_fmt.replace('
rrrdir_fmt = ' get_reload_subs({modname})(verbose=verbose)'
rrrfile_fmt = ' get_rrr({modname})(verbose > 1)'
def _reload_command(tup):
if len(tup) > 2 and tup[2] is True:
return rrrdir_fmt.format(modname=tup[0])
else:
return rrrfile_fmt.format(modname=tup[0])
reload_body = '\n'.join(map(_reload_command, import_tuples)).strip()
format_dict = {
'modname': modname,
'reload_body': reload_body,
'injecter': injecter,
'injecter_import': injecter_import,
}
inject_execstr = injectstr_fmt.format(**format_dict).strip()
return inject_execstr |
0, module; 0, 1; 1, ERROR; 1, 2; 1, 424; 2, function_definition; 2, 3; 2, 4; 2, 34; 3, function_name:dynamic_import; 4, parameters; 4, 5; 4, 6; 4, 7; 4, 10; 4, 13; 4, 16; 4, 19; 4, 22; 4, 25; 4, 28; 4, 31; 5, identifier:modname; 6, identifier:import_tuples; 7, default_parameter; 7, 8; 7, 9; 8, identifier:developing; 9, True; 10, default_parameter; 10, 11; 10, 12; 11, identifier:ignore_froms; 12, list:[]; 13, default_parameter; 13, 14; 13, 15; 14, identifier:dump; 15, False; 16, default_parameter; 16, 17; 16, 18; 17, identifier:ignore_startswith; 18, list:[]; 19, default_parameter; 19, 20; 19, 21; 20, identifier:ignore_endswith; 21, list:[]; 22, default_parameter; 22, 23; 22, 24; 23, identifier:ignore_list; 24, list:[]; 25, default_parameter; 25, 26; 25, 27; 26, identifier:check_not_imported; 27, True; 28, default_parameter; 28, 29; 28, 30; 29, identifier:return_initstr; 30, False; 31, default_parameter; 31, 32; 31, 33; 32, identifier:verbose; 33, False; 34, block; 34, 35; 34, 45; 34, 64; 34, 74; 34, 84; 34, 125; 34, 133; 34, 156; 34, 167; 34, 177; 34, 220; 35, if_statement; 35, 36; 35, 37; 36, identifier:verbose; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:print; 41, argument_list; 41, 42; 42, binary_operator:%; 42, 43; 42, 44; 43, string:'[UTIL_IMPORT] Running Dynamic Imports for modname=%r '; 44, identifier:modname; 45, try_statement; 45, 46; 45, 55; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:module; 50, subscript; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:sys; 53, identifier:modules; 54, identifier:modname; 55, except_clause; 55, 56; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:module; 60, call; 60, 61; 60, 62; 61, identifier:__import__; 62, argument_list; 62, 63; 63, identifier:modname; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:imports; 67, list_comprehension; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:tup; 70, integer:0; 71, for_in_clause; 71, 72; 71, 73; 72, identifier:tup; 73, identifier:import_tuples; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:__excecute_imports; 77, argument_list; 77, 78; 77, 79; 77, 80; 77, 81; 78, identifier:module; 79, identifier:modname; 80, identifier:imports; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:verbose; 83, identifier:verbose; 84, if_statement; 84, 85; 84, 86; 84, 111; 85, identifier:developing; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:from_imports; 90, call; 90, 91; 90, 92; 91, identifier:__execute_fromimport_star; 92, argument_list; 92, 93; 92, 94; 92, 95; 92, 96; 92, 99; 92, 102; 92, 105; 92, 108; 93, identifier:module; 94, identifier:modname; 95, identifier:import_tuples; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:ignore_list; 98, identifier:ignore_list; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:ignore_startswith; 101, identifier:ignore_startswith; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:ignore_endswith; 104, identifier:ignore_endswith; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:check_not_imported; 107, identifier:check_not_imported; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:verbose; 110, identifier:verbose; 111, else_clause; 111, 112; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:from_imports; 116, call; 116, 117; 116, 118; 117, identifier:__execute_fromimport; 118, argument_list; 118, 119; 118, 120; 118, 121; 118, 122; 119, identifier:module; 120, identifier:modname; 121, identifier:import_tuples; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:verbose; 124, identifier:verbose; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:inject_execstr; 128, call; 128, 129; 128, 130; 129, identifier:_inject_execstr; 130, argument_list; 130, 131; 130, 132; 131, identifier:modname; 132, identifier:import_tuples; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:dump_requested; 136, boolean_operator:or; 136, 137; 136, 155; 137, parenthesized_expression; 137, 138; 138, boolean_operator:or; 138, 139; 138, 147; 139, comparison_operator:in; 139, 140; 139, 144; 140, parenthesized_expression; 140, 141; 141, binary_operator:%; 141, 142; 141, 143; 142, string:'--dump-%s-init'; 143, identifier:modname; 144, attribute; 144, 145; 144, 146; 145, identifier:sys; 146, identifier:argv; 147, comparison_operator:in; 147, 148; 147, 152; 148, parenthesized_expression; 148, 149; 149, binary_operator:%; 149, 150; 149, 151; 150, string:'--print-%s-init'; 151, identifier:modname; 152, attribute; 152, 153; 152, 154; 153, identifier:sys; 154, identifier:argv; 155, identifier:dump; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:overwrite_requested; 159, comparison_operator:in; 159, 160; 159, 164; 160, parenthesized_expression; 160, 161; 161, binary_operator:%; 161, 162; 161, 163; 162, string:'--update-%s-init'; 163, identifier:modname; 164, attribute; 164, 165; 164, 166; 165, identifier:sys; 166, identifier:argv; 167, if_statement; 167, 168; 167, 169; 168, identifier:verbose; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:print; 173, argument_list; 173, 174; 174, binary_operator:%; 174, 175; 174, 176; 175, string:'[UTIL_IMPORT] Finished Dynamic Imports for modname=%r '; 176, identifier:modname; 177, if_statement; 177, 178; 177, 179; 178, identifier:dump_requested; 179, block; 179, 180; 179, 192; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:is_main_proc; 183, comparison_operator:==; 183, 184; 183, 191; 184, attribute; 184, 185; 184, 190; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:multiprocessing; 188, identifier:current_process; 189, argument_list; 190, identifier:name; 191, string:'MainProcess'; 192, if_statement; 192, 193; 192, 194; 193, identifier:is_main_proc; 194, block; 194, 195; 194, 200; 194, 210; 195, import_from_statement; 195, 196; 195, 198; 196, dotted_name; 196, 197; 197, identifier:utool; 198, dotted_name; 198, 199; 199, identifier:util_str; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:initstr; 203, call; 203, 204; 203, 205; 204, identifier:_initstr; 205, argument_list; 205, 206; 205, 207; 205, 208; 205, 209; 206, identifier:modname; 207, identifier:imports; 208, identifier:from_imports; 209, identifier:inject_execstr; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 213; 212, identifier:print; 213, argument_list; 213, 214; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:util_str; 217, identifier:indent; 218, argument_list; 218, 219; 219, identifier:initstr; 220, if_statement; 220, 221; 220, 222; 221, identifier:overwrite_requested; 222, block; 222, 223; 222, 235; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:is_main_proc; 226, comparison_operator:==; 226, 227; 226, 234; 227, attribute; 227, 228; 227, 233; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:multiprocessing; 231, identifier:current_process; 232, argument_list; 233, identifier:name; 234, string:'MainProcess'; 235, if_statement; 235, 236; 235, 237; 235, 415; 236, identifier:is_main_proc; 237, block; 237, 238; 237, 243; 237, 251; 237, 264; 237, 273; 237, 285; 237, 292; 237, 297; 237, 301; 237, 305; 237, 309; 237, 380; 237, 387; 237, 396; 238, import_from_statement; 238, 239; 238, 241; 239, dotted_name; 239, 240; 240, identifier:utool; 241, dotted_name; 241, 242; 242, identifier:util_str; 243, import_from_statement; 243, 244; 243, 247; 243, 249; 244, dotted_name; 244, 245; 244, 246; 245, identifier:os; 246, identifier:path; 247, dotted_name; 247, 248; 248, identifier:join; 249, dotted_name; 249, 250; 250, identifier:exists; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:initstr; 254, call; 254, 255; 254, 256; 255, identifier:_initstr; 256, argument_list; 256, 257; 256, 258; 256, 259; 256, 260; 256, 261; 257, identifier:modname; 258, identifier:imports; 259, identifier:from_imports; 260, identifier:inject_execstr; 261, keyword_argument; 261, 262; 261, 263; 262, identifier:withheader; 263, False; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:new_else; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:util_str; 270, identifier:indent; 271, argument_list; 271, 272; 272, identifier:initstr; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:init_fpath; 276, call; 276, 277; 276, 278; 277, identifier:join; 278, argument_list; 278, 279; 278, 284; 279, subscript; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:module; 282, identifier:__path__; 283, integer:0; 284, string:'__init__.py'; 285, expression_statement; 285, 286; 286, call; 286, 287; 286, 288; 287, identifier:print; 288, argument_list; 288, 289; 289, binary_operator:%; 289, 290; 289, 291; 290, string:'attempting to update: %r'; 291, identifier:init_fpath; 292, assert_statement; 292, 293; 293, call; 293, 294; 293, 295; 294, identifier:exists; 295, argument_list; 295, 296; 296, identifier:init_fpath; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:new_lines; 300, list:[]; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:editing; 304, False; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:updated; 308, False; 309, with_statement; 309, 310; 309, 320; 310, with_clause; 310, 311; 311, with_item; 311, 312; 312, as_pattern; 312, 313; 312, 318; 313, call; 313, 314; 313, 315; 314, identifier:open; 315, argument_list; 315, 316; 315, 317; 316, identifier:init_fpath; 317, string:'r'; 318, as_pattern_target; 318, 319; 319, identifier:file_; 320, block; 320, 321; 320, 329; 320, 366; 321, expression_statement; 321, 322; 322, assignment; 322, 323; 322, 324; 323, identifier:lines; 324, call; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:file_; 327, identifier:readlines; 328, argument_list; 329, for_statement; 329, 330; 329, 331; 329, 332; 329, 357; 330, identifier:line; 331, identifier:lines; 332, ERROR; 332, 333; 332, 344; 332, 351; 332, 356; 333, if_statement; 333, 334; 333, 336; 334, not_operator; 334, 335; 335, identifier:editing; 336, block; 336, 337; 337, expression_statement; 337, 338; 338, call; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, identifier:new_lines; 341, identifier:append; 342, argument_list; 342, 343; 343, identifier:line; 344, attribute; 344, 345; 344, 350; 345, call; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:line; 348, identifier:strip; 349, argument_list; 350, identifier:startswith; 351, concatenated_string; 351, 352; 351, 353; 351, 355; 352, string:'
new_lines.append('; 353, ERROR; 353, 354; 354, escape_sequence:\n; 355, string:' + new_else + '; 356, escape_sequence:\n; 357, block; 357, 358; 357, 362; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 361; 360, identifier:editing; 361, True; 362, expression_statement; 362, 363; 363, assignment; 363, 364; 363, 365; 364, identifier:updated; 365, True; 366, if_statement; 366, 367; 366, 374; 366, 379; 367, attribute; 367, 368; 367, 373; 368, call; 368, 369; 368, 372; 369, attribute; 369, 370; 369, 371; 370, identifier:line; 371, identifier:strip; 372, argument_list; 373, identifier:startswith; 374, ERROR; 374, 375; 374, 376; 374, 377; 374, 378; 375, ERROR; 376, identifier:editing; 377, False; 378, identifier:updated; 379, block:; 380, expression_statement; 380, 381; 381, call; 381, 382; 381, 383; 382, identifier:print; 383, argument_list; 383, 384; 384, binary_operator:%; 384, 385; 384, 386; 385, string:'writing updated file: %r'; 386, identifier:init_fpath; 387, expression_statement; 387, 388; 388, assignment; 388, 389; 388, 390; 389, identifier:new_text; 390, call; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, string:''; 393, identifier:join; 394, argument_list; 394, 395; 395, identifier:new_lines; 396, with_statement; 396, 397; 396, 407; 397, with_clause; 397, 398; 398, with_item; 398, 399; 399, as_pattern; 399, 400; 399, 405; 400, call; 400, 401; 400, 402; 401, identifier:open; 402, argument_list; 402, 403; 402, 404; 403, identifier:init_fpath; 404, string:'w'; 405, as_pattern_target; 405, 406; 406, identifier:file_; 407, block; 407, 408; 408, expression_statement; 408, 409; 409, call; 409, 410; 409, 413; 410, attribute; 410, 411; 410, 412; 411, identifier:file_; 412, identifier:write; 413, argument_list; 413, 414; 414, identifier:new_text; 415, else_clause; 415, 416; 416, block; 416, 417; 417, expression_statement; 417, 418; 418, call; 418, 419; 418, 420; 419, identifier:print; 420, argument_list; 420, 421; 421, binary_operator:%; 421, 422; 421, 423; 422, string:'no write hook for file: %r'; 423, identifier:init_fpath; 424, if_statement; 424, 425; 424, 426; 424, 444; 425, identifier:return_initstr; 426, block; 426, 427; 426, 440; 427, expression_statement; 427, 428; 428, assignment; 428, 429; 428, 430; 429, identifier:initstr; 430, call; 430, 431; 430, 432; 431, identifier:_initstr; 432, argument_list; 432, 433; 432, 434; 432, 435; 432, 436; 432, 437; 433, identifier:modname; 434, identifier:imports; 435, identifier:from_imports; 436, string:''; 437, keyword_argument; 437, 438; 437, 439; 438, identifier:withheader; 439, False; 440, return_statement; 440, 441; 441, expression_list; 441, 442; 441, 443; 442, identifier:inject_execstr; 443, identifier:initstr; 444, else_clause; 444, 445; 445, block; 445, 446; 446, return_statement; 446, 447; 447, identifier:inject_execstr | def dynamic_import(modname, import_tuples, developing=True, ignore_froms=[],
dump=False, ignore_startswith=[], ignore_endswith=[],
ignore_list=[], check_not_imported=True, return_initstr=False,
verbose=False):
if verbose:
print('[UTIL_IMPORT] Running Dynamic Imports for modname=%r ' % modname)
try:
module = sys.modules[modname]
except:
module = __import__(modname)
imports = [tup[0] for tup in import_tuples]
__excecute_imports(module, modname, imports, verbose=verbose)
if developing:
from_imports = __execute_fromimport_star(module, modname, import_tuples,
ignore_list=ignore_list,
ignore_startswith=ignore_startswith,
ignore_endswith=ignore_endswith,
check_not_imported=check_not_imported,
verbose=verbose)
else:
from_imports = __execute_fromimport(module, modname, import_tuples, verbose=verbose)
inject_execstr = _inject_execstr(modname, import_tuples)
dump_requested = (('--dump-%s-init' % modname) in sys.argv or
('--print-%s-init' % modname) in sys.argv) or dump
overwrite_requested = ('--update-%s-init' % modname) in sys.argv
if verbose:
print('[UTIL_IMPORT] Finished Dynamic Imports for modname=%r ' % modname)
if dump_requested:
is_main_proc = multiprocessing.current_process().name == 'MainProcess'
if is_main_proc:
from utool import util_str
initstr = _initstr(modname, imports, from_imports, inject_execstr)
print(util_str.indent(initstr))
if overwrite_requested:
is_main_proc = multiprocessing.current_process().name == 'MainProcess'
if is_main_proc:
from utool import util_str
from os.path import join, exists
initstr = _initstr(modname, imports, from_imports, inject_execstr, withheader=False)
new_else = util_str.indent(initstr)
init_fpath = join(module.__path__[0], '__init__.py')
print('attempting to update: %r' % init_fpath)
assert exists(init_fpath)
new_lines = []
editing = False
updated = False
with open(init_fpath, 'r') as file_:
lines = file_.readlines()
for line in lines:
if not editing:
new_lines.append(line)
if line.strip().startswith('
new_lines.append('\n' + new_else + '\n
editing = True
updated = True
if line.strip().startswith('
editing = False
if updated:
print('writing updated file: %r' % init_fpath)
new_text = ''.join(new_lines)
with open(init_fpath, 'w') as file_:
file_.write(new_text)
else:
print('no write hook for file: %r' % init_fpath)
if return_initstr:
initstr = _initstr(modname, imports, from_imports, '', withheader=False)
return inject_execstr, initstr
else:
return inject_execstr |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:write_to; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:fpath; 5, identifier:to_write; 6, default_parameter; 6, 7; 6, 8; 7, identifier:aslines; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:verbose; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:onlyifdiff; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:mode; 17, string:'w'; 18, default_parameter; 18, 19; 18, 20; 19, identifier:n; 20, None; 21, block; 21, 22; 21, 54; 21, 61; 21, 74; 21, 83; 21, 96; 21, 112; 22, if_statement; 22, 23; 22, 24; 23, identifier:onlyifdiff; 24, block; 24, 25; 24, 30; 25, import_statement; 25, 26; 26, aliased_import; 26, 27; 26, 29; 27, dotted_name; 27, 28; 28, identifier:utool; 29, identifier:ut; 30, if_statement; 30, 31; 30, 47; 31, comparison_operator:==; 31, 32; 31, 41; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:ut; 35, identifier:hashstr; 36, argument_list; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:read_from; 39, argument_list; 39, 40; 40, identifier:fpath; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:ut; 44, identifier:hashstr; 45, argument_list; 45, 46; 46, identifier:to_write; 47, block; 47, 48; 47, 53; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:print; 51, argument_list; 51, 52; 52, string:'[util_io] * no difference'; 53, return_statement; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:verbose; 57, call; 57, 58; 57, 59; 58, identifier:_rectify_verb_write; 59, argument_list; 59, 60; 60, identifier:verbose; 61, if_statement; 61, 62; 61, 63; 62, identifier:verbose; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:print; 67, argument_list; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, string:'[util_io] * Writing to text file: {}'; 71, identifier:format; 72, argument_list; 72, 73; 73, identifier:fpath; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:backup; 77, boolean_operator:and; 77, 78; 77, 79; 78, False; 79, call; 79, 80; 79, 81; 80, identifier:exists; 81, argument_list; 81, 82; 82, identifier:fpath; 83, if_statement; 83, 84; 83, 85; 84, identifier:backup; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:util_path; 90, identifier:copy; 91, argument_list; 91, 92; 91, 93; 92, identifier:fpath; 93, binary_operator:+; 93, 94; 93, 95; 94, identifier:fpath; 95, string:'.backup'; 96, if_statement; 96, 97; 96, 105; 97, not_operator; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:isinstance; 100, argument_list; 100, 101; 100, 102; 101, identifier:fpath; 102, attribute; 102, 103; 102, 104; 103, identifier:six; 104, identifier:string_types; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:fpath; 109, attribute; 109, 110; 109, 111; 110, identifier:fpath; 111, identifier:name; 112, with_statement; 112, 113; 112, 123; 113, with_clause; 113, 114; 114, with_item; 114, 115; 115, as_pattern; 115, 116; 115, 121; 116, call; 116, 117; 116, 118; 117, identifier:open; 118, argument_list; 118, 119; 118, 120; 119, identifier:fpath; 120, identifier:mode; 121, as_pattern_target; 121, 122; 122, identifier:file_; 123, block; 123, 124; 124, if_statement; 124, 125; 124, 126; 124, 134; 125, identifier:aslines; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:file_; 131, identifier:writelines; 132, argument_list; 132, 133; 133, identifier:to_write; 134, else_clause; 134, 135; 135, block; 135, 136; 135, 157; 136, if_statement; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:six; 139, identifier:PY2; 140, block; 140, 141; 141, if_statement; 141, 142; 141, 147; 142, call; 142, 143; 142, 144; 143, identifier:isinstance; 144, argument_list; 144, 145; 144, 146; 145, identifier:to_write; 146, identifier:unicode; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:to_write; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:to_write; 154, identifier:encode; 155, argument_list; 155, 156; 156, string:'utf8'; 157, try_statement; 157, 158; 157, 166; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:file_; 163, identifier:write; 164, argument_list; 164, 165; 165, identifier:to_write; 166, except_clause; 166, 167; 166, 171; 167, as_pattern; 167, 168; 167, 169; 168, identifier:UnicodeEncodeError; 169, as_pattern_target; 169, 170; 170, identifier:ex; 171, block; 171, 172; 171, 186; 171, 196; 171, 205; 171, 213; 171, 218; 171, 223; 171, 236; 171, 242; 171, 255; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:start; 175, call; 175, 176; 175, 177; 176, identifier:max; 177, argument_list; 177, 178; 177, 185; 178, binary_operator:-; 178, 179; 178, 184; 179, subscript; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:ex; 182, identifier:args; 183, integer:2; 184, integer:10; 185, integer:0; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:end; 189, binary_operator:+; 189, 190; 189, 195; 190, subscript; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:ex; 193, identifier:args; 194, integer:3; 195, integer:10; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:context; 199, subscript; 199, 200; 199, 201; 200, identifier:to_write; 201, slice; 201, 202; 201, 203; 201, 204; 202, identifier:start; 203, colon; 204, identifier:end; 205, expression_statement; 205, 206; 206, call; 206, 207; 206, 208; 207, identifier:print; 208, argument_list; 208, 209; 209, call; 209, 210; 209, 211; 210, identifier:repr; 211, argument_list; 211, 212; 212, identifier:context; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:print; 216, argument_list; 216, 217; 217, identifier:context; 218, import_from_statement; 218, 219; 218, 221; 219, dotted_name; 219, 220; 220, identifier:utool; 221, dotted_name; 221, 222; 222, identifier:util_dbg; 223, expression_statement; 223, 224; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:util_dbg; 227, identifier:printex; 228, argument_list; 228, 229; 228, 230; 229, identifier:ex; 230, keyword_argument; 230, 231; 230, 232; 231, identifier:keys; 232, list:[(type, 'to_write')]; 232, 233; 233, tuple; 233, 234; 233, 235; 234, identifier:type; 235, string:'to_write'; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:file_; 240, identifier:close; 241, argument_list; 242, if_statement; 242, 243; 242, 244; 243, identifier:backup; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:util_path; 249, identifier:copy; 250, argument_list; 250, 251; 250, 254; 251, binary_operator:+; 251, 252; 251, 253; 252, identifier:fpath; 253, string:'.backup'; 254, identifier:fpath; 255, raise_statement | def write_to(fpath, to_write, aslines=False, verbose=None,
onlyifdiff=False, mode='w', n=None):
if onlyifdiff:
import utool as ut
if ut.hashstr(read_from(fpath)) == ut.hashstr(to_write):
print('[util_io] * no difference')
return
verbose = _rectify_verb_write(verbose)
if verbose:
print('[util_io] * Writing to text file: {}'.format(fpath))
backup = False and exists(fpath)
if backup:
util_path.copy(fpath, fpath + '.backup')
if not isinstance(fpath, six.string_types):
fpath = fpath.name
with open(fpath, mode) as file_:
if aslines:
file_.writelines(to_write)
else:
if six.PY2:
if isinstance(to_write, unicode):
to_write = to_write.encode('utf8')
try:
file_.write(to_write)
except UnicodeEncodeError as ex:
start = max(ex.args[2] - 10, 0)
end = ex.args[3] + 10
context = to_write[start:end]
print(repr(context))
print(context)
from utool import util_dbg
util_dbg.printex(ex, keys=[(type, 'to_write')])
file_.close()
if backup:
util_path.copy(fpath + '.backup', fpath)
raise |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:read_from; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:fpath; 5, default_parameter; 5, 6; 5, 7; 6, identifier:verbose; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:aslines; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:strict; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:n; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:errors; 19, string:'replace'; 20, block; 20, 21; 20, 23; 20, 32; 20, 39; 20, 57; 21, expression_statement; 21, 22; 22, identifier:r; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:n; 26, None; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:n; 31, identifier:__READ_TAIL_N__; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:verbose; 35, call; 35, 36; 35, 37; 36, identifier:_rectify_verb_read; 37, argument_list; 37, 38; 38, identifier:verbose; 39, if_statement; 39, 40; 39, 41; 40, identifier:verbose; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:print; 45, argument_list; 45, 46; 46, binary_operator:%; 46, 47; 46, 48; 47, string:'[util_io] * Reading text file: %r '; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:util_path; 51, identifier:tail; 52, argument_list; 52, 53; 52, 54; 53, identifier:fpath; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:n; 56, identifier:n; 57, try_statement; 57, 58; 57, 184; 58, block; 58, 59; 58, 79; 58, 182; 59, if_statement; 59, 60; 59, 73; 60, not_operator; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:util_path; 64, identifier:checkpath; 65, argument_list; 65, 66; 65, 67; 65, 70; 66, identifier:fpath; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:verbose; 69, identifier:verbose; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:n; 72, identifier:n; 73, block; 73, 74; 74, raise_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:IOError; 77, argument_list; 77, 78; 78, string:'[io] * FILE DOES NOT EXIST!'; 79, with_statement; 79, 80; 79, 90; 80, with_clause; 80, 81; 81, with_item; 81, 82; 82, as_pattern; 82, 83; 82, 88; 83, call; 83, 84; 83, 85; 84, identifier:open; 85, argument_list; 85, 86; 85, 87; 86, identifier:fpath; 87, string:'rb'; 88, as_pattern_target; 88, 89; 89, identifier:file_; 90, block; 90, 91; 91, if_statement; 91, 92; 91, 93; 91, 141; 92, identifier:aslines; 93, block; 93, 94; 94, if_statement; 94, 95; 94, 98; 94, 119; 95, attribute; 95, 96; 95, 97; 96, identifier:six; 97, identifier:PY2; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:text; 102, list_comprehension; 102, 103; 102, 112; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:line; 106, identifier:decode; 107, argument_list; 107, 108; 107, 109; 108, string:'utf8'; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:errors; 111, identifier:errors; 112, for_in_clause; 112, 113; 112, 114; 113, identifier:line; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:file_; 117, identifier:readlines; 118, argument_list; 119, else_clause; 119, 120; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:text; 124, list_comprehension; 124, 125; 124, 134; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:line; 128, identifier:decode; 129, argument_list; 129, 130; 129, 131; 130, string:'utf8'; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:errors; 133, identifier:errors; 134, for_in_clause; 134, 135; 134, 136; 135, identifier:line; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:file_; 139, identifier:readlines; 140, argument_list; 141, else_clause; 141, 142; 142, block; 142, 143; 143, if_statement; 143, 144; 143, 147; 143, 164; 144, attribute; 144, 145; 144, 146; 145, identifier:six; 146, identifier:PY2; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:text; 151, call; 151, 152; 151, 159; 152, attribute; 152, 153; 152, 158; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:file_; 156, identifier:read; 157, argument_list; 158, identifier:decode; 159, argument_list; 159, 160; 159, 161; 160, string:'utf8'; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:errors; 163, identifier:errors; 164, else_clause; 164, 165; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:text; 169, call; 169, 170; 169, 177; 170, attribute; 170, 171; 170, 176; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:file_; 174, identifier:read; 175, argument_list; 176, identifier:decode; 177, argument_list; 177, 178; 177, 179; 178, string:'utf8'; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:errors; 181, identifier:errors; 182, return_statement; 182, 183; 183, identifier:text; 184, except_clause; 184, 185; 184, 189; 185, as_pattern; 185, 186; 185, 187; 186, identifier:IOError; 187, as_pattern_target; 187, 188; 188, identifier:ex; 189, block; 189, 190; 189, 195; 189, 219; 190, import_from_statement; 190, 191; 190, 193; 191, dotted_name; 191, 192; 192, identifier:utool; 193, dotted_name; 193, 194; 194, identifier:util_dbg; 195, if_statement; 195, 196; 195, 199; 196, boolean_operator:or; 196, 197; 196, 198; 197, identifier:verbose; 198, identifier:strict; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:util_dbg; 204, identifier:printex; 205, argument_list; 205, 206; 205, 207; 205, 218; 206, identifier:ex; 207, binary_operator:%; 207, 208; 207, 209; 208, string:' * Error reading fpath=%r'; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:util_path; 212, identifier:tail; 213, argument_list; 213, 214; 213, 215; 214, identifier:fpath; 215, keyword_argument; 215, 216; 215, 217; 216, identifier:n; 217, identifier:n; 218, string:'[io]'; 219, if_statement; 219, 220; 219, 221; 220, identifier:strict; 221, block; 221, 222; 222, raise_statement | def read_from(fpath, verbose=None, aslines=False, strict=True, n=None, errors='replace'):
r
if n is None:
n = __READ_TAIL_N__
verbose = _rectify_verb_read(verbose)
if verbose:
print('[util_io] * Reading text file: %r ' % util_path.tail(fpath, n=n))
try:
if not util_path.checkpath(fpath, verbose=verbose, n=n):
raise IOError('[io] * FILE DOES NOT EXIST!')
with open(fpath, 'rb') as file_:
if aslines:
if six.PY2:
text = [line.decode('utf8', errors=errors)
for line in file_.readlines()]
else:
text = [line.decode('utf8', errors=errors)
for line in file_.readlines()]
else:
if six.PY2:
text = file_.read().decode('utf8', errors=errors)
else:
text = file_.read().decode('utf8', errors=errors)
return text
except IOError as ex:
from utool import util_dbg
if verbose or strict:
util_dbg.printex(ex, ' * Error reading fpath=%r' %
util_path.tail(fpath, n=n), '[io]')
if strict:
raise |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:load_cPkl; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:fpath; 5, default_parameter; 5, 6; 5, 7; 6, identifier:verbose; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:n; 10, None; 11, block; 11, 12; 11, 19; 11, 38; 11, 130; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:verbose; 15, call; 15, 16; 15, 17; 16, identifier:_rectify_verb_read; 17, argument_list; 17, 18; 18, identifier:verbose; 19, if_statement; 19, 20; 19, 21; 20, identifier:verbose; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:print; 25, argument_list; 25, 26; 26, binary_operator:%; 26, 27; 26, 28; 27, string:'[util_io] * load_cPkl(%r)'; 28, tuple; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:util_path; 32, identifier:tail; 33, argument_list; 33, 34; 33, 35; 34, identifier:fpath; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:n; 37, identifier:n; 38, try_statement; 38, 39; 38, 61; 38, 96; 39, block; 39, 40; 40, with_statement; 40, 41; 40, 51; 41, with_clause; 41, 42; 42, with_item; 42, 43; 43, as_pattern; 43, 44; 43, 49; 44, call; 44, 45; 44, 46; 45, identifier:open; 46, argument_list; 46, 47; 46, 48; 47, identifier:fpath; 48, string:'rb'; 49, as_pattern_target; 49, 50; 50, identifier:file_; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:data; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:pickle; 58, identifier:load; 59, argument_list; 59, 60; 60, identifier:file_; 61, except_clause; 61, 62; 61, 63; 62, identifier:UnicodeDecodeError; 63, block; 63, 64; 64, if_statement; 64, 65; 64, 68; 64, 93; 65, attribute; 65, 66; 65, 67; 66, identifier:six; 67, identifier:PY3; 68, block; 68, 69; 69, with_statement; 69, 70; 69, 80; 70, with_clause; 70, 71; 71, with_item; 71, 72; 72, as_pattern; 72, 73; 72, 78; 73, call; 73, 74; 73, 75; 74, identifier:open; 75, argument_list; 75, 76; 75, 77; 76, identifier:fpath; 77, string:'rb'; 78, as_pattern_target; 78, 79; 79, identifier:file_; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:data; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:pickle; 87, identifier:load; 88, argument_list; 88, 89; 88, 90; 89, identifier:file_; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:encoding; 92, string:'latin1'; 93, else_clause; 93, 94; 94, block; 94, 95; 95, raise_statement; 96, except_clause; 96, 97; 96, 101; 97, as_pattern; 97, 98; 97, 99; 98, identifier:ValueError; 99, as_pattern_target; 99, 100; 100, identifier:ex; 101, block; 101, 102; 102, if_statement; 102, 103; 102, 106; 102, 127; 103, attribute; 103, 104; 103, 105; 104, identifier:six; 105, identifier:PY2; 106, block; 106, 107; 107, if_statement; 107, 108; 107, 113; 107, 124; 108, comparison_operator:==; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:ex; 111, identifier:message; 112, string:'unsupported pickle protocol: 4'; 113, block; 113, 114; 114, raise_statement; 114, 115; 115, call; 115, 116; 115, 117; 116, identifier:ValueError; 117, argument_list; 117, 118; 118, binary_operator:%; 118, 119; 118, 122; 119, concatenated_string; 119, 120; 119, 121; 120, string:'unsupported Python3 pickle protocol 4 '; 121, string:'in Python2 for fpath=%r'; 122, tuple; 122, 123; 123, identifier:fpath; 124, else_clause; 124, 125; 125, block; 125, 126; 126, raise_statement; 127, else_clause; 127, 128; 128, block; 128, 129; 129, raise_statement; 130, return_statement; 130, 131; 131, identifier:data | def load_cPkl(fpath, verbose=None, n=None):
verbose = _rectify_verb_read(verbose)
if verbose:
print('[util_io] * load_cPkl(%r)' % (util_path.tail(fpath, n=n),))
try:
with open(fpath, 'rb') as file_:
data = pickle.load(file_)
except UnicodeDecodeError:
if six.PY3:
with open(fpath, 'rb') as file_:
data = pickle.load(file_, encoding='latin1')
else:
raise
except ValueError as ex:
if six.PY2:
if ex.message == 'unsupported pickle protocol: 4':
raise ValueError(
'unsupported Python3 pickle protocol 4 '
'in Python2 for fpath=%r' % (fpath,))
else:
raise
else:
raise
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:save_hdf5; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:fpath; 5, identifier:data; 6, default_parameter; 6, 7; 6, 8; 7, identifier:verbose; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:compression; 11, string:'lzf'; 12, block; 12, 13; 12, 15; 12, 18; 12, 25; 12, 41; 12, 83; 12, 87; 12, 94; 12, 98; 13, expression_statement; 13, 14; 14, identifier:r; 15, import_statement; 15, 16; 16, dotted_name; 16, 17; 17, identifier:h5py; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:verbose; 21, call; 21, 22; 21, 23; 22, identifier:_rectify_verb_write; 23, argument_list; 23, 24; 24, identifier:verbose; 25, if_statement; 25, 26; 25, 27; 26, identifier:verbose; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:print; 31, argument_list; 31, 32; 32, binary_operator:%; 32, 33; 32, 34; 33, string:'[util_io] * save_hdf5(%r, data)'; 34, tuple; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:util_path; 38, identifier:tail; 39, argument_list; 39, 40; 40, identifier:fpath; 41, if_statement; 41, 42; 41, 45; 42, comparison_operator:>; 42, 43; 42, 44; 43, identifier:verbose; 44, integer:1; 45, block; 45, 46; 46, if_statement; 46, 47; 46, 52; 46, 71; 47, call; 47, 48; 47, 49; 48, identifier:isinstance; 49, argument_list; 49, 50; 49, 51; 50, identifier:data; 51, identifier:dict; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:print; 56, argument_list; 56, 57; 57, binary_operator:%; 57, 58; 57, 59; 58, string:'[util_io] ... shapes=%r'; 59, tuple; 59, 60; 60, list_comprehension; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:val; 63, identifier:shape; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:val; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:data; 69, identifier:values; 70, argument_list; 71, else_clause; 71, 72; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:print; 76, argument_list; 76, 77; 77, binary_operator:%; 77, 78; 77, 79; 78, string:'[util_io] ... shape=%r'; 79, tuple; 79, 80; 80, attribute; 80, 81; 80, 82; 81, identifier:data; 82, identifier:shape; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:chunks; 86, True; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:fname; 90, call; 90, 91; 90, 92; 91, identifier:basename; 92, argument_list; 92, 93; 93, identifier:fpath; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:h5kw; 97, dictionary; 98, if_statement; 98, 99; 98, 104; 98, 244; 99, call; 99, 100; 99, 101; 100, identifier:isinstance; 101, argument_list; 101, 102; 101, 103; 102, identifier:data; 103, identifier:dict; 104, block; 104, 105; 104, 131; 104, 151; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:array_data; 108, dictionary_comprehension; 108, 109; 108, 112; 108, 121; 109, pair; 109, 110; 109, 111; 110, identifier:key; 111, identifier:val; 112, for_in_clause; 112, 113; 112, 116; 113, pattern_list; 113, 114; 113, 115; 114, identifier:key; 115, identifier:val; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:data; 119, identifier:items; 120, argument_list; 121, if_clause; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:isinstance; 124, argument_list; 124, 125; 124, 126; 125, identifier:val; 126, tuple; 126, 127; 126, 128; 127, identifier:list; 128, attribute; 128, 129; 128, 130; 129, identifier:np; 130, identifier:ndarray; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:attr_data; 134, dictionary_comprehension; 134, 135; 134, 138; 134, 147; 135, pair; 135, 136; 135, 137; 136, identifier:key; 137, identifier:val; 138, for_in_clause; 138, 139; 138, 142; 139, pattern_list; 139, 140; 139, 141; 140, identifier:key; 141, identifier:val; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:data; 145, identifier:items; 146, argument_list; 147, if_clause; 147, 148; 148, comparison_operator:not; 148, 149; 148, 150; 149, identifier:key; 150, identifier:array_data; 151, with_statement; 151, 152; 151, 168; 152, with_clause; 152, 153; 153, with_item; 153, 154; 154, as_pattern; 154, 155; 154, 166; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:h5py; 158, identifier:File; 159, argument_list; 159, 160; 159, 161; 159, 164; 160, identifier:fpath; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:mode; 163, string:'w'; 164, dictionary_splat; 164, 165; 165, identifier:h5kw; 166, as_pattern_target; 166, 167; 167, identifier:file_; 168, block; 168, 169; 168, 178; 168, 225; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:grp; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:file_; 175, identifier:create_group; 176, argument_list; 176, 177; 177, identifier:fname; 178, for_statement; 178, 179; 178, 182; 178, 188; 179, pattern_list; 179, 180; 179, 181; 180, identifier:key; 181, identifier:val; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:six; 185, identifier:iteritems; 186, argument_list; 186, 187; 187, identifier:array_data; 188, block; 188, 189; 188, 198; 188, 219; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:val; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:np; 195, identifier:asarray; 196, argument_list; 196, 197; 197, identifier:val; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:dset; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:grp; 204, identifier:create_dataset; 205, argument_list; 205, 206; 205, 207; 205, 210; 205, 213; 205, 216; 206, identifier:key; 207, attribute; 207, 208; 207, 209; 208, identifier:val; 209, identifier:shape; 210, attribute; 210, 211; 210, 212; 211, identifier:val; 212, identifier:dtype; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:chunks; 215, identifier:chunks; 216, keyword_argument; 216, 217; 216, 218; 217, identifier:compression; 218, identifier:compression; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 224; 221, subscript; 221, 222; 221, 223; 222, identifier:dset; 223, ellipsis:...; 224, identifier:val; 225, for_statement; 225, 226; 225, 229; 225, 235; 226, pattern_list; 226, 227; 226, 228; 227, identifier:key; 228, identifier:val; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:six; 232, identifier:iteritems; 233, argument_list; 233, 234; 234, identifier:attr_data; 235, block; 235, 236; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 243; 238, subscript; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:grp; 241, identifier:attrs; 242, identifier:key; 243, identifier:val; 244, else_clause; 244, 245; 245, block; 245, 246; 245, 254; 245, 260; 245, 266; 246, assert_statement; 246, 247; 247, call; 247, 248; 247, 249; 248, identifier:isinstance; 249, argument_list; 249, 250; 249, 251; 250, identifier:data; 251, attribute; 251, 252; 251, 253; 252, identifier:np; 253, identifier:ndarray; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:shape; 257, attribute; 257, 258; 257, 259; 258, identifier:data; 259, identifier:shape; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:dtype; 263, attribute; 263, 264; 263, 265; 264, identifier:data; 265, identifier:dtype; 266, with_statement; 266, 267; 266, 283; 267, with_clause; 267, 268; 268, with_item; 268, 269; 269, as_pattern; 269, 270; 269, 281; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:h5py; 273, identifier:File; 274, argument_list; 274, 275; 274, 276; 274, 279; 275, identifier:fpath; 276, keyword_argument; 276, 277; 276, 278; 277, identifier:mode; 278, string:'w'; 279, dictionary_splat; 279, 280; 280, identifier:h5kw; 281, as_pattern_target; 281, 282; 282, identifier:file_; 283, block; 283, 284; 283, 301; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 287; 286, identifier:dset; 287, call; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:file_; 290, identifier:create_dataset; 291, argument_list; 291, 292; 291, 293; 291, 294; 291, 295; 291, 298; 292, identifier:fname; 293, identifier:shape; 294, identifier:dtype; 295, keyword_argument; 295, 296; 295, 297; 296, identifier:chunks; 297, identifier:chunks; 298, keyword_argument; 298, 299; 298, 300; 299, identifier:compression; 300, identifier:compression; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 306; 303, subscript; 303, 304; 303, 305; 304, identifier:dset; 305, ellipsis:...; 306, identifier:data | def save_hdf5(fpath, data, verbose=None, compression='lzf'):
r
import h5py
verbose = _rectify_verb_write(verbose)
if verbose:
print('[util_io] * save_hdf5(%r, data)' % (util_path.tail(fpath),))
if verbose > 1:
if isinstance(data, dict):
print('[util_io] ... shapes=%r' % ([val.shape for val in data.values()],))
else:
print('[util_io] ... shape=%r' % (data.shape,))
chunks = True
fname = basename(fpath)
h5kw = {}
if isinstance(data, dict):
array_data = {key: val for key, val in data.items()
if isinstance(val, (list, np.ndarray))}
attr_data = {key: val for key, val in data.items() if key not in array_data}
with h5py.File(fpath, mode='w', **h5kw) as file_:
grp = file_.create_group(fname)
for key, val in six.iteritems(array_data):
val = np.asarray(val)
dset = grp.create_dataset(
key, val.shape, val.dtype, chunks=chunks,
compression=compression)
dset[...] = val
for key, val in six.iteritems(attr_data):
grp.attrs[key] = val
else:
assert isinstance(data, np.ndarray)
shape = data.shape
dtype = data.dtype
with h5py.File(fpath, mode='w', **h5kw) as file_:
dset = file_.create_dataset(
fname, shape, dtype, chunks=chunks, compression=compression)
dset[...] = data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 32; 2, function_name:formatex; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 4, identifier:ex; 5, default_parameter; 5, 6; 5, 7; 6, identifier:msg; 7, string:'[!?] Caught exception'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:prefix; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:key_list; 13, list:[]; 14, default_parameter; 14, 15; 14, 16; 15, identifier:locals_; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:iswarning; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:tb; 22, False; 23, default_parameter; 23, 24; 23, 25; 24, identifier:N; 25, integer:0; 26, default_parameter; 26, 27; 26, 28; 27, identifier:keys; 28, None; 29, default_parameter; 29, 30; 29, 31; 30, identifier:colored; 31, None; 32, block; 32, 33; 32, 35; 32, 52; 32, 68; 32, 77; 32, 81; 32, 88; 32, 97; 32, 142; 32, 172; 32, 180; 32, 189; 33, expression_statement; 33, 34; 34, identifier:r; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:is; 36, 37; 36, 38; 37, identifier:prefix; 38, None; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:prefix; 43, call; 43, 44; 43, 45; 44, identifier:get_caller_prefix; 45, argument_list; 45, 46; 45, 49; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:aserror; 48, True; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:N; 51, identifier:N; 52, if_statement; 52, 53; 52, 56; 53, comparison_operator:is; 53, 54; 53, 55; 54, identifier:locals_; 55, None; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:locals_; 60, attribute; 60, 61; 60, 67; 61, call; 61, 62; 61, 63; 62, identifier:get_parent_frame; 63, argument_list; 63, 64; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:N; 66, identifier:N; 67, identifier:f_locals; 68, if_statement; 68, 69; 68, 72; 69, comparison_operator:is; 69, 70; 69, 71; 70, identifier:keys; 71, None; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:key_list; 76, identifier:keys; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:errstr_list; 80, list:[]; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:ex_tag; 84, conditional_expression:if; 84, 85; 84, 86; 84, 87; 85, string:'WARNING'; 86, identifier:iswarning; 87, string:'EXCEPTION'; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:errstr_list; 92, identifier:append; 93, argument_list; 93, 94; 94, binary_operator:%; 94, 95; 94, 96; 95, string:'<!!! %s !!!>'; 96, identifier:ex_tag; 97, if_statement; 97, 98; 97, 101; 98, boolean_operator:or; 98, 99; 98, 100; 99, identifier:tb; 100, identifier:FORCE_TB; 101, block; 101, 102; 101, 110; 101, 135; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:tbtext; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:traceback; 108, identifier:format_exc; 109, argument_list; 110, if_statement; 110, 111; 110, 114; 111, boolean_operator:or; 111, 112; 111, 113; 112, identifier:colored; 113, identifier:COLORED_EXCEPTIONS; 114, block; 114, 115; 114, 120; 115, import_from_statement; 115, 116; 115, 118; 116, dotted_name; 116, 117; 117, identifier:utool; 118, dotted_name; 118, 119; 119, identifier:util_str; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:tbtext; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:util_str; 126, identifier:highlight_text; 127, argument_list; 127, 128; 127, 129; 127, 132; 128, identifier:tbtext; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:lexer_name; 131, string:'pytb'; 132, keyword_argument; 132, 133; 132, 134; 133, identifier:stripall; 134, True; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:errstr_list; 139, identifier:append; 140, argument_list; 140, 141; 141, identifier:tbtext; 142, expression_statement; 142, 143; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:errstr_list; 146, identifier:append; 147, argument_list; 147, 148; 148, binary_operator:+; 148, 149; 148, 159; 149, binary_operator:+; 149, 150; 149, 153; 150, binary_operator:+; 150, 151; 150, 152; 151, identifier:prefix; 152, string:' '; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:six; 156, identifier:text_type; 157, argument_list; 157, 158; 158, identifier:msg; 159, binary_operator:%; 159, 160; 159, 161; 160, string:'\n%r: %s'; 161, tuple; 161, 162; 161, 166; 162, call; 162, 163; 162, 164; 163, identifier:type; 164, argument_list; 164, 165; 165, identifier:ex; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:six; 169, identifier:text_type; 170, argument_list; 170, 171; 171, identifier:ex; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 175; 174, identifier:parse_locals_keylist; 175, argument_list; 175, 176; 175, 177; 175, 178; 175, 179; 176, identifier:locals_; 177, identifier:key_list; 178, identifier:errstr_list; 179, identifier:prefix; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:errstr_list; 184, identifier:append; 185, argument_list; 185, 186; 186, binary_operator:%; 186, 187; 186, 188; 187, string:'</!!! %s !!!>'; 188, identifier:ex_tag; 189, return_statement; 189, 190; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, string:'\n'; 193, identifier:join; 194, argument_list; 194, 195; 195, identifier:errstr_list | def formatex(ex, msg='[!?] Caught exception',
prefix=None, key_list=[], locals_=None, iswarning=False, tb=False,
N=0, keys=None, colored=None):
r
if prefix is None:
prefix = get_caller_prefix(aserror=True, N=N)
if locals_ is None:
locals_ = get_parent_frame(N=N).f_locals
if keys is not None:
key_list = keys
errstr_list = []
ex_tag = 'WARNING' if iswarning else 'EXCEPTION'
errstr_list.append('<!!! %s !!!>' % ex_tag)
if tb or FORCE_TB:
tbtext = traceback.format_exc()
if colored or COLORED_EXCEPTIONS:
from utool import util_str
tbtext = util_str.highlight_text(tbtext, lexer_name='pytb', stripall=True)
errstr_list.append(tbtext)
errstr_list.append(prefix + ' ' + six.text_type(msg) + '\n%r: %s' % (type(ex), six.text_type(ex)))
parse_locals_keylist(locals_, key_list, errstr_list, prefix)
errstr_list.append('</!!! %s !!!>' % ex_tag)
return '\n'.join(errstr_list) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:__send_rdy; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:connection; 6, identifier:command; 7, block; 7, 8; 7, 265; 7, 284; 7, 294; 7, 300; 7, 308; 7, 326; 7, 351; 8, if_statement; 8, 9; 8, 16; 8, 209; 9, comparison_operator:is; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:__consumer; 14, identifier:original_rdy; 15, None; 16, block; 16, 17; 16, 32; 16, 49; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:node_count; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:__consumer; 25, identifier:get_node_count_for_topic; 26, argument_list; 26, 27; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:connection; 30, identifier:context; 31, identifier:topic; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:__logger_rdy; 38, identifier:debug; 39, argument_list; 39, 40; 39, 43; 39, 48; 40, concatenated_string; 40, 41; 40, 42; 41, string:"Calculating RDY: max_in_flight=(%d) "; 42, string:"node_count=(%d)"; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:__consumer; 47, identifier:max_in_flight; 48, identifier:node_count; 49, if_statement; 49, 50; 49, 57; 49, 101; 50, comparison_operator:>=; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:__consumer; 55, identifier:max_in_flight; 56, identifier:node_count; 57, block; 57, 58; 57, 82; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:rdy_this; 61, call; 61, 62; 61, 63; 62, identifier:int; 63, argument_list; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:math; 67, identifier:ceil; 68, argument_list; 68, 69; 69, binary_operator:/; 69, 70; 69, 78; 70, call; 70, 71; 70, 72; 71, identifier:float; 72, argument_list; 72, 73; 73, attribute; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:__consumer; 77, identifier:max_in_flight; 78, call; 78, 79; 78, 80; 79, identifier:float; 80, argument_list; 80, 81; 81, identifier:node_count; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:__logger_rdy; 88, identifier:debug; 89, argument_list; 89, 90; 89, 94; 89, 99; 89, 100; 90, concatenated_string; 90, 91; 90, 92; 90, 93; 91, string:"Assigning RDY based on max_in_flight "; 92, string:"(%d) and node count (%d) (optimal): "; 93, string:"(%d)"; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:__consumer; 98, identifier:max_in_flight; 99, identifier:node_count; 100, identifier:rdy_this; 101, else_clause; 101, 102; 102, block; 102, 103; 102, 114; 102, 141; 102, 151; 102, 205; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:__logger_rdy; 109, identifier:debug; 110, argument_list; 110, 111; 111, concatenated_string; 111, 112; 111, 113; 112, string:"(max_in_flight > nodes). Doing RDY "; 113, string:"election."; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:sleeping_connections; 117, list_comprehension; 117, 118; 117, 119; 117, 120; 117, 134; 117, 135; 118, identifier:c; 119, line_continuation:\; 120, for_in_clause; 120, 121; 120, 124; 120, 125; 121, tuple_pattern; 121, 122; 121, 123; 122, identifier:c; 123, identifier:info; 124, line_continuation:\; 125, call; 125, 126; 125, 133; 126, attribute; 126, 127; 126, 132; 127, attribute; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:__consumer; 131, identifier:connection_context; 132, identifier:items; 133, argument_list; 134, line_continuation:\; 135, if_clause; 135, 136; 136, comparison_operator:==; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:info; 139, string:'rdy_count'; 140, integer:0; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 148; 143, attribute; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:__logger_rdy; 147, identifier:debug; 148, argument_list; 148, 149; 148, 150; 149, string:"Current sleeping_connections: %s"; 150, identifier:sleeping_connections; 151, if_statement; 151, 152; 151, 153; 151, 191; 152, identifier:sleeping_connections; 153, block; 153, 154; 153, 163; 153, 173; 153, 184; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:elected_connection; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:random; 160, identifier:choice; 161, argument_list; 161, 162; 162, identifier:sleeping_connections; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 170; 165, attribute; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:__logger_rdy; 169, identifier:debug; 170, argument_list; 170, 171; 170, 172; 171, string:"Sending RDY of (1) on: [%s]"; 172, identifier:elected_connection; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:command_elected; 176, call; 176, 177; 176, 182; 177, attribute; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:nsq; 180, identifier:command; 181, identifier:Command; 182, argument_list; 182, 183; 183, identifier:elected_connection; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:command_elected; 188, identifier:rdy; 189, argument_list; 189, 190; 190, integer:1; 191, else_clause; 191, 192; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, call; 194, 195; 194, 200; 195, attribute; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:__logger; 199, identifier:debug; 200, argument_list; 200, 201; 200, 204; 201, concatenated_string; 201, 202; 201, 203; 202, string:"No sleeping connections. We got the "; 203, string:"short stick: [%s]"; 204, identifier:connection; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:rdy_this; 208, integer:0; 209, else_clause; 209, 210; 210, block; 210, 211; 211, try_statement; 211, 212; 211, 244; 212, block; 212, 213; 212, 234; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:rdy_this; 216, call; 216, 217; 216, 222; 217, attribute; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:__consumer; 221, identifier:original_rdy; 222, argument_list; 222, 223; 222, 226; 222, 231; 223, attribute; 223, 224; 223, 225; 224, identifier:connection; 225, identifier:node; 226, attribute; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:self; 229, identifier:__consumer; 230, identifier:connection_count; 231, attribute; 231, 232; 231, 233; 232, identifier:self; 233, identifier:__consumer; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 241; 236, attribute; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:self; 239, identifier:__logger_rdy; 240, identifier:debug; 241, argument_list; 241, 242; 241, 243; 242, string:"Using RDY from callback: (%d)"; 243, identifier:rdy_this; 244, except_clause; 244, 245; 244, 246; 245, identifier:TypeError; 246, block; 246, 247; 246, 255; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:rdy_this; 250, attribute; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:self; 253, identifier:__consumer; 254, identifier:original_rdy; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 262; 257, attribute; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:self; 260, identifier:__logger_rdy; 261, identifier:debug; 262, argument_list; 262, 263; 262, 264; 263, string:"Using static RDY: (%d)"; 264, identifier:rdy_this; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:rdy_this; 268, call; 268, 269; 268, 270; 269, identifier:min; 270, argument_list; 270, 271; 270, 279; 271, binary_operator:+; 271, 272; 271, 273; 271, 274; 272, identifier:rdy_this; 273, line_continuation:\; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:self; 277, identifier:__get_total_rdy_count; 278, argument_list; 279, attribute; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:self; 282, identifier:__consumer; 283, identifier:max_in_flight; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 287; 286, identifier:server_features; 287, attribute; 287, 288; 287, 293; 288, attribute; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:self; 291, identifier:__consumer; 292, identifier:identify; 293, identifier:server_features; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:max_rdy_count; 297, subscript; 297, 298; 297, 299; 298, identifier:server_features; 299, string:'max_rdy_count'; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:rdy_this; 303, call; 303, 304; 303, 305; 304, identifier:min; 305, argument_list; 305, 306; 305, 307; 306, identifier:max_rdy_count; 307, identifier:rdy_this; 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:self; 313, identifier:__logger_rdy; 314, identifier:debug; 315, argument_list; 315, 316; 315, 319; 315, 324; 315, 325; 316, concatenated_string; 316, 317; 316, 318; 317, string:"Final RDY (max_in_flight=(%d) "; 318, string:"max_rdy_count=(%d)): (%d)"; 319, attribute; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:self; 322, identifier:__consumer; 323, identifier:max_in_flight; 324, identifier:max_rdy_count; 325, identifier:rdy_this; 326, if_statement; 326, 327; 326, 330; 326, 338; 327, comparison_operator:>; 327, 328; 327, 329; 328, identifier:rdy_this; 329, integer:0; 330, block; 330, 331; 331, expression_statement; 331, 332; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:command; 335, identifier:rdy; 336, argument_list; 336, 337; 337, identifier:rdy_this; 338, else_clause; 338, 339; 339, block; 339, 340; 340, expression_statement; 340, 341; 341, call; 341, 342; 341, 347; 342, attribute; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:self; 345, identifier:__logger_rdy; 346, identifier:info; 347, argument_list; 347, 348; 348, concatenated_string; 348, 349; 348, 350; 349, string:"This connection will go to sleep (not "; 350, string:"enough RDY to go around)."; 351, return_statement; 351, 352; 352, identifier:rdy_this | def __send_rdy(self, connection, command):
if self.__consumer.original_rdy is None:
node_count = self.__consumer.get_node_count_for_topic(
connection.context.topic)
self.__logger_rdy.debug("Calculating RDY: max_in_flight=(%d) "
"node_count=(%d)",
self.__consumer.max_in_flight, node_count)
if self.__consumer.max_in_flight >= node_count:
rdy_this = int(math.ceil(
float(self.__consumer.max_in_flight) /
float(node_count)))
self.__logger_rdy.debug("Assigning RDY based on max_in_flight "
"(%d) and node count (%d) (optimal): "
"(%d)",
self.__consumer.max_in_flight,
node_count, rdy_this)
else:
self.__logger_rdy.debug("(max_in_flight > nodes). Doing RDY "
"election.")
sleeping_connections = [
c \
for (c, info) \
in self.__consumer.connection_context.items() \
if info['rdy_count'] == 0]
self.__logger_rdy.debug("Current sleeping_connections: %s",
sleeping_connections)
if sleeping_connections:
elected_connection = random.choice(sleeping_connections)
self.__logger_rdy.debug("Sending RDY of (1) on: [%s]",
elected_connection)
command_elected = nsq.command.Command(elected_connection)
command_elected.rdy(1)
else:
self.__logger.debug("No sleeping connections. We got the "
"short stick: [%s]", connection)
rdy_this = 0
else:
try:
rdy_this = self.__consumer.original_rdy(
connection.node,
self.__consumer.connection_count,
self.__consumer)
self.__logger_rdy.debug("Using RDY from callback: (%d)",
rdy_this)
except TypeError:
rdy_this = self.__consumer.original_rdy
self.__logger_rdy.debug("Using static RDY: (%d)", rdy_this)
rdy_this = min(rdy_this + \
self.__get_total_rdy_count(),
self.__consumer.max_in_flight)
server_features = self.__consumer.identify.server_features
max_rdy_count = server_features['max_rdy_count']
rdy_this = min(max_rdy_count, rdy_this)
self.__logger_rdy.debug("Final RDY (max_in_flight=(%d) "
"max_rdy_count=(%d)): (%d)",
self.__consumer.max_in_flight, max_rdy_count,
rdy_this)
if rdy_this > 0:
command.rdy(rdy_this)
else:
self.__logger_rdy.info("This connection will go to sleep (not "
"enough RDY to go around).")
return rdy_this |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:add_instruction; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:instr; 6, block; 6, 7; 6, 14; 6, 23; 6, 52; 7, assert_statement; 7, 8; 8, parenthesized_expression; 8, 9; 9, call; 9, 10; 9, 11; 10, identifier:isinstance; 11, argument_list; 11, 12; 11, 13; 12, identifier:instr; 13, identifier:Instruction; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:instruction_list; 20, identifier:append; 21, argument_list; 21, 22; 22, identifier:instr; 23, if_statement; 23, 24; 23, 31; 24, comparison_operator:not; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:instr; 27, identifier:lhs; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:defined_variables; 31, block; 31, 32; 32, if_statement; 32, 33; 32, 40; 33, call; 33, 34; 33, 35; 34, identifier:isinstance; 35, argument_list; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:instr; 38, identifier:lhs; 39, identifier:Variable; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 48; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:defined_variables; 47, identifier:append; 48, argument_list; 48, 49; 49, attribute; 49, 50; 49, 51; 50, identifier:instr; 51, identifier:lhs; 52, if_statement; 52, 53; 52, 58; 52, 88; 53, call; 53, 54; 53, 55; 54, identifier:isinstance; 55, argument_list; 55, 56; 55, 57; 56, identifier:instr; 57, identifier:EqInstruction; 58, block; 58, 59; 59, if_statement; 59, 60; 59, 67; 60, call; 60, 61; 60, 62; 61, identifier:isinstance; 62, argument_list; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:instr; 65, identifier:rhs; 66, identifier:Variable; 67, block; 67, 68; 68, if_statement; 68, 69; 68, 76; 69, comparison_operator:not; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:instr; 72, identifier:rhs; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:used_variables; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:used_variables; 83, identifier:append; 84, argument_list; 84, 85; 85, attribute; 85, 86; 85, 87; 86, identifier:instr; 87, identifier:rhs; 88, else_clause; 88, 89; 89, block; 89, 90; 89, 119; 90, if_statement; 90, 91; 90, 98; 91, call; 91, 92; 91, 93; 92, identifier:isinstance; 93, argument_list; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:instr; 96, identifier:rhs_1; 97, identifier:Variable; 98, block; 98, 99; 99, if_statement; 99, 100; 99, 107; 100, comparison_operator:not; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:instr; 103, identifier:rhs_1; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:used_variables; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 115; 110, attribute; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:used_variables; 114, identifier:append; 115, argument_list; 115, 116; 116, attribute; 116, 117; 116, 118; 117, identifier:instr; 118, identifier:rhs_1; 119, if_statement; 119, 120; 119, 127; 120, call; 120, 121; 120, 122; 121, identifier:isinstance; 122, argument_list; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:instr; 125, identifier:rhs_2; 126, identifier:Variable; 127, block; 127, 128; 128, if_statement; 128, 129; 128, 136; 129, comparison_operator:not; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:instr; 132, identifier:rhs_2; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:used_variables; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 144; 139, attribute; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:self; 142, identifier:used_variables; 143, identifier:append; 144, argument_list; 144, 145; 145, attribute; 145, 146; 145, 147; 146, identifier:instr; 147, identifier:rhs_2 | def add_instruction (self, instr):
assert(isinstance(instr, Instruction))
self.instruction_list.append(instr)
if instr.lhs not in self.defined_variables:
if isinstance(instr.lhs, Variable):
self.defined_variables.append(instr.lhs)
if isinstance(instr, EqInstruction):
if isinstance(instr.rhs, Variable):
if instr.rhs not in self.used_variables:
self.used_variables.append(instr.rhs)
else:
if isinstance(instr.rhs_1, Variable):
if instr.rhs_1 not in self.used_variables:
self.used_variables.append(instr.rhs_1)
if isinstance(instr.rhs_2, Variable):
if instr.rhs_2 not in self.used_variables:
self.used_variables.append(instr.rhs_2) |
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, 12; 5, 22; 5, 26; 5, 30; 5, 50; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:token_list; 11, list:[]; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:ps; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:parse_string; 20, identifier:strip; 21, argument_list; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:i; 25, integer:0; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:last_token; 29, None; 30, while_statement; 30, 31; 30, 45; 31, boolean_operator:and; 31, 32; 31, 38; 32, comparison_operator:<; 32, 33; 32, 34; 33, identifier:i; 34, call; 34, 35; 34, 36; 35, identifier:len; 36, argument_list; 36, 37; 37, identifier:ps; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:ps; 42, identifier:i; 43, identifier:isspace; 44, argument_list; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, augmented_assignment:+=; 47, 48; 47, 49; 48, identifier:i; 49, integer:1; 50, while_statement; 50, 51; 50, 57; 51, comparison_operator:<; 51, 52; 51, 53; 52, identifier:i; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, identifier:ps; 57, block; 57, 58; 57, 62; 57, 304; 57, 330; 57, 337; 57, 341; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:token; 61, string:''; 62, if_statement; 62, 63; 62, 70; 62, 104; 62, 206; 62, 292; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:ps; 67, identifier:i; 68, identifier:isalpha; 69, argument_list; 70, block; 70, 71; 71, while_statement; 71, 72; 71, 93; 72, boolean_operator:and; 72, 73; 72, 79; 73, comparison_operator:<; 73, 74; 73, 75; 74, identifier:i; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, identifier:ps; 79, parenthesized_expression; 79, 80; 80, boolean_operator:or; 80, 81; 80, 88; 81, call; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:ps; 85, identifier:i; 86, identifier:isalnum; 87, argument_list; 88, comparison_operator:==; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:ps; 91, identifier:i; 92, string:'_'; 93, block; 93, 94; 93, 100; 94, expression_statement; 94, 95; 95, augmented_assignment:+=; 95, 96; 95, 97; 96, identifier:token; 97, subscript; 97, 98; 97, 99; 98, identifier:ps; 99, identifier:i; 100, expression_statement; 100, 101; 101, augmented_assignment:+=; 101, 102; 101, 103; 102, identifier:i; 103, integer:1; 104, elif_clause; 104, 105; 104, 112; 105, call; 105, 106; 105, 111; 106, attribute; 106, 107; 106, 110; 107, subscript; 107, 108; 107, 109; 108, identifier:ps; 109, identifier:i; 110, identifier:isdigit; 111, argument_list; 112, block; 112, 113; 113, while_statement; 113, 114; 113, 195; 114, boolean_operator:and; 114, 115; 114, 121; 115, comparison_operator:<; 115, 116; 115, 117; 116, identifier:i; 117, call; 117, 118; 117, 119; 118, identifier:len; 119, argument_list; 119, 120; 120, identifier:ps; 121, parenthesized_expression; 121, 122; 122, boolean_operator:or; 122, 123; 122, 172; 123, boolean_operator:or; 123, 124; 123, 149; 124, boolean_operator:or; 124, 125; 124, 144; 125, boolean_operator:or; 125, 126; 125, 139; 126, boolean_operator:or; 126, 127; 126, 134; 127, call; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:ps; 131, identifier:i; 132, identifier:isdigit; 133, argument_list; 134, comparison_operator:==; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:ps; 137, identifier:i; 138, string:'.'; 139, comparison_operator:==; 139, 140; 139, 143; 140, subscript; 140, 141; 140, 142; 141, identifier:ps; 142, identifier:i; 143, string:'e'; 144, comparison_operator:==; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:ps; 147, identifier:i; 148, string:'E'; 149, parenthesized_expression; 149, 150; 150, boolean_operator:and; 150, 151; 150, 156; 151, comparison_operator:==; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:ps; 154, identifier:i; 155, string:'+'; 156, parenthesized_expression; 156, 157; 157, boolean_operator:or; 157, 158; 157, 165; 158, comparison_operator:==; 158, 159; 158, 164; 159, subscript; 159, 160; 159, 161; 160, identifier:ps; 161, binary_operator:-; 161, 162; 161, 163; 162, identifier:i; 163, integer:1; 164, string:'e'; 165, comparison_operator:==; 165, 166; 165, 171; 166, subscript; 166, 167; 166, 168; 167, identifier:ps; 168, binary_operator:-; 168, 169; 168, 170; 169, identifier:i; 170, integer:1; 171, string:'E'; 172, parenthesized_expression; 172, 173; 173, boolean_operator:and; 173, 174; 173, 179; 174, comparison_operator:==; 174, 175; 174, 178; 175, subscript; 175, 176; 175, 177; 176, identifier:ps; 177, identifier:i; 178, string:'-'; 179, parenthesized_expression; 179, 180; 180, boolean_operator:or; 180, 181; 180, 188; 181, comparison_operator:==; 181, 182; 181, 187; 182, subscript; 182, 183; 182, 184; 183, identifier:ps; 184, binary_operator:-; 184, 185; 184, 186; 185, identifier:i; 186, integer:1; 187, string:'e'; 188, comparison_operator:==; 188, 189; 188, 194; 189, subscript; 189, 190; 189, 191; 190, identifier:ps; 191, binary_operator:-; 191, 192; 191, 193; 192, identifier:i; 193, integer:1; 194, string:'E'; 195, block; 195, 196; 195, 202; 196, expression_statement; 196, 197; 197, augmented_assignment:+=; 197, 198; 197, 199; 198, identifier:token; 199, subscript; 199, 200; 199, 201; 200, identifier:ps; 201, identifier:i; 202, expression_statement; 202, 203; 203, augmented_assignment:+=; 203, 204; 203, 205; 204, identifier:i; 205, integer:1; 206, elif_clause; 206, 207; 206, 212; 207, comparison_operator:==; 207, 208; 207, 211; 208, subscript; 208, 209; 208, 210; 209, identifier:ps; 210, identifier:i; 211, string:'.'; 212, block; 212, 213; 213, if_statement; 213, 214; 213, 223; 213, 257; 214, call; 214, 215; 214, 222; 215, attribute; 215, 216; 215, 221; 216, subscript; 216, 217; 216, 218; 217, identifier:ps; 218, binary_operator:+; 218, 219; 218, 220; 219, identifier:i; 220, integer:1; 221, identifier:isdigit; 222, argument_list; 223, block; 223, 224; 224, while_statement; 224, 225; 224, 246; 225, boolean_operator:and; 225, 226; 225, 232; 226, comparison_operator:<; 226, 227; 226, 228; 227, identifier:i; 228, call; 228, 229; 228, 230; 229, identifier:len; 230, argument_list; 230, 231; 231, identifier:ps; 232, parenthesized_expression; 232, 233; 233, boolean_operator:or; 233, 234; 233, 241; 234, call; 234, 235; 234, 240; 235, attribute; 235, 236; 235, 239; 236, subscript; 236, 237; 236, 238; 237, identifier:ps; 238, identifier:i; 239, identifier:isdigit; 240, argument_list; 241, comparison_operator:==; 241, 242; 241, 245; 242, subscript; 242, 243; 242, 244; 243, identifier:ps; 244, identifier:i; 245, string:'.'; 246, block; 246, 247; 246, 253; 247, expression_statement; 247, 248; 248, augmented_assignment:+=; 248, 249; 248, 250; 249, identifier:token; 250, subscript; 250, 251; 250, 252; 251, identifier:ps; 252, identifier:i; 253, expression_statement; 253, 254; 254, augmented_assignment:+=; 254, 255; 254, 256; 255, identifier:i; 256, integer:1; 257, else_clause; 257, 258; 258, block; 258, 259; 259, while_statement; 259, 260; 259, 281; 260, boolean_operator:and; 260, 261; 260, 267; 261, comparison_operator:<; 261, 262; 261, 263; 262, identifier:i; 263, call; 263, 264; 263, 265; 264, identifier:len; 265, argument_list; 265, 266; 266, identifier:ps; 267, parenthesized_expression; 267, 268; 268, boolean_operator:or; 268, 269; 268, 276; 269, call; 269, 270; 269, 275; 270, attribute; 270, 271; 270, 274; 271, subscript; 271, 272; 271, 273; 272, identifier:ps; 273, identifier:i; 274, identifier:isalpha; 275, argument_list; 276, comparison_operator:==; 276, 277; 276, 280; 277, subscript; 277, 278; 277, 279; 278, identifier:ps; 279, identifier:i; 280, string:'.'; 281, block; 281, 282; 281, 288; 282, expression_statement; 282, 283; 283, augmented_assignment:+=; 283, 284; 283, 285; 284, identifier:token; 285, subscript; 285, 286; 285, 287; 286, identifier:ps; 287, identifier:i; 288, expression_statement; 288, 289; 289, augmented_assignment:+=; 289, 290; 289, 291; 290, identifier:i; 291, integer:1; 292, else_clause; 292, 293; 293, block; 293, 294; 293, 300; 294, expression_statement; 294, 295; 295, augmented_assignment:+=; 295, 296; 295, 297; 296, identifier:token; 297, subscript; 297, 298; 297, 299; 298, identifier:ps; 299, identifier:i; 300, expression_statement; 300, 301; 301, augmented_assignment:+=; 301, 302; 301, 303; 302, identifier:i; 303, integer:1; 304, if_statement; 304, 305; 304, 325; 305, boolean_operator:and; 305, 306; 305, 309; 305, 310; 306, comparison_operator:==; 306, 307; 306, 308; 307, identifier:token; 308, string:'-'; 309, line_continuation:\; 310, parenthesized_expression; 310, 311; 311, boolean_operator:or; 311, 312; 311, 319; 312, boolean_operator:or; 312, 313; 312, 316; 313, comparison_operator:==; 313, 314; 313, 315; 314, identifier:last_token; 315, None; 316, comparison_operator:==; 316, 317; 316, 318; 317, identifier:last_token; 318, string:'('; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:self; 322, identifier:is_op; 323, argument_list; 323, 324; 324, identifier:last_token; 325, block; 325, 326; 326, expression_statement; 326, 327; 327, assignment; 327, 328; 327, 329; 328, identifier:token; 329, string:'~'; 330, expression_statement; 330, 331; 331, augmented_assignment:+=; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:self; 334, identifier:token_list; 335, list:[token]; 335, 336; 336, identifier:token; 337, expression_statement; 337, 338; 338, assignment; 338, 339; 338, 340; 339, identifier:last_token; 340, identifier:token; 341, while_statement; 341, 342; 341, 356; 342, boolean_operator:and; 342, 343; 342, 349; 343, comparison_operator:<; 343, 344; 343, 345; 344, identifier:i; 345, call; 345, 346; 345, 347; 346, identifier:len; 347, argument_list; 347, 348; 348, identifier:ps; 349, call; 349, 350; 349, 355; 350, attribute; 350, 351; 350, 354; 351, subscript; 351, 352; 351, 353; 352, identifier:ps; 353, identifier:i; 354, identifier:isspace; 355, argument_list; 356, block; 356, 357; 357, expression_statement; 357, 358; 358, augmented_assignment:+=; 358, 359; 358, 360; 359, identifier:i; 360, integer:1 | def tokenize(self):
self.token_list = []
ps = self.parse_string.strip()
i = 0
last_token = None
while i < len(ps) and ps[i].isspace():
i += 1
while i < len(ps):
token = ''
if ps[i].isalpha():
while i < len(ps) and (ps[i].isalnum() or ps[i] == '_'):
token += ps[i]
i += 1
elif ps[i].isdigit():
while i < len(ps) and (ps[i].isdigit() or
ps[i] == '.' or
ps[i] == 'e' or
ps[i] == 'E' or
(ps[i] == '+' and (ps[i-1] == 'e' or ps[i-1] == 'E')) or
(ps[i] == '-' and (ps[i-1] == 'e' or ps[i-1] == 'E'))):
token += ps[i]
i += 1
elif ps[i] == '.':
if ps[i+1].isdigit():
while i < len(ps) and (ps[i].isdigit() or ps[i] == '.'):
token += ps[i]
i += 1
else:
while i < len(ps) and (ps[i].isalpha() or ps[i] == '.'):
token += ps[i]
i += 1
else:
token += ps[i]
i += 1
if token == '-' and \
(last_token == None or last_token == '(' or self.is_op(last_token)):
token = '~'
self.token_list += [token]
last_token = token
while i < len(ps) and ps[i].isspace():
i += 1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:setup_repo; 3, parameters; 4, block; 4, 5; 4, 7; 4, 12; 4, 17; 4, 22; 4, 39; 4, 48; 4, 63; 4, 71; 4, 83; 4, 93; 4, 97; 4, 103; 4, 115; 4, 275; 5, expression_statement; 5, 6; 6, identifier:r; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 10; 9, identifier:print; 10, argument_list; 10, 11; 11, string:'\n [setup_repo]!'; 12, import_from_statement; 12, 13; 12, 15; 13, dotted_name; 13, 14; 14, identifier:functools; 15, dotted_name; 15, 16; 16, identifier:partial; 17, import_statement; 17, 18; 18, aliased_import; 18, 19; 18, 21; 19, dotted_name; 19, 20; 20, identifier:utool; 21, identifier:ut; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:code_dpath; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:ut; 28, identifier:truepath; 29, argument_list; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:ut; 33, identifier:get_argval; 34, argument_list; 34, 35; 34, 36; 35, string:'--code-dir'; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:default; 38, string:'~/code'; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:_code_dpath; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:ut; 45, identifier:unexpanduser; 46, argument_list; 46, 47; 47, identifier:code_dpath; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:repo_fname; 51, parenthesized_expression; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:ut; 55, identifier:get_argval; 56, argument_list; 56, 57; 56, 60; 57, tuple; 57, 58; 57, 59; 58, string:'--repo'; 59, string:'--repo-name'; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:type_; 62, identifier:str; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:repo_dpath; 66, call; 66, 67; 66, 68; 67, identifier:join; 68, argument_list; 68, 69; 68, 70; 69, identifier:code_dpath; 70, identifier:repo_fname; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:modname; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:ut; 77, identifier:get_argval; 78, argument_list; 78, 79; 78, 80; 79, string:'--modname'; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:default; 82, identifier:repo_fname; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:ut; 87, identifier:ensuredir; 88, argument_list; 88, 89; 88, 90; 89, identifier:repo_dpath; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:verbose; 92, True; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:_regencmd; 96, string:'python -m utool --tf setup_repo --repo={repo_fname} --codedir={_code_dpath} --modname={modname}'; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:flake8_noqacmd; 100, binary_operator:+; 100, 101; 100, 102; 101, string:'flake8'; 102, string:':noqa'; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:regencmd; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:_regencmd; 109, identifier:format; 110, argument_list; 110, 111; 111, dictionary_splat; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:locals; 114, argument_list; 115, with_statement; 115, 116; 115, 124; 116, with_clause; 116, 117; 117, with_item; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:ut; 121, identifier:ChdirContext; 122, argument_list; 122, 123; 123, identifier:repo_dpath; 124, block; 124, 125; 124, 131; 124, 135; 124, 151; 124, 166; 124, 181; 124, 199; 124, 214; 124, 234; 124, 257; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:locals_; 128, call; 128, 129; 128, 130; 129, identifier:locals; 130, argument_list; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:force; 134, True; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:_ensure_text; 138, call; 138, 139; 138, 140; 139, identifier:partial; 140, argument_list; 140, 141; 140, 142; 140, 145; 140, 148; 141, identifier:ensure_text; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:repo_dpath; 144, string:'.'; 145, keyword_argument; 145, 146; 145, 147; 146, identifier:force; 147, None; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:locals_; 150, identifier:locals_; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:_ensure_text; 154, argument_list; 154, 155; 154, 158; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:fname; 157, string:'todo.md'; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:text; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:ut; 163, identifier:codeblock; 164, argument_list; 164, 165; 165, string:r'''
* Add TODOS!
'''; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 169; 168, identifier:_ensure_text; 169, argument_list; 169, 170; 169, 173; 170, keyword_argument; 170, 171; 170, 172; 171, identifier:fname; 172, string:'README.md'; 173, keyword_argument; 173, 174; 173, 175; 174, identifier:text; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:ut; 178, identifier:codeblock; 179, argument_list; 179, 180; 180, string:r'''
'''; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:_ensure_text; 184, argument_list; 184, 185; 184, 188; 184, 191; 185, keyword_argument; 185, 186; 185, 187; 186, identifier:fname; 187, string:'setup.py'; 188, keyword_argument; 188, 189; 188, 190; 189, identifier:chmod; 190, string:'+x'; 191, keyword_argument; 191, 192; 191, 193; 192, identifier:text; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:ut; 196, identifier:codeblock; 197, argument_list; 197, 198; 198, string:r'''
from __future__ import absolute_import, division, print_function, unicode_literals
from setuptools import setup
try:
from utool import util_setup
except ImportError:
print('ERROR: setup requires utool')
raise
INSTALL_REQUIRES = [
]
CLUTTER_PATTERNS = [
]
if __name__ == '__main__':
kwargs = util_setup.setuptools_setup(
setup_fpath=__file__,
name='{modname}',
packages=util_setup.find_packages(),
version=util_setup.parse_package_for_version('{modname}'),
license=util_setup.read_license('LICENSE'),
long_description=util_setup.parse_readme('README.md'),
ext_modules=util_setup.find_ext_modules(),
cmdclass=util_setup.get_cmdclass(),
keywords='',
install_requires=INSTALL_REQUIRES,
clutter_patterns=CLUTTER_PATTERNS,
classifiers=[],
)
setup(**kwargs)
'''; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 202; 201, identifier:_ensure_text; 202, argument_list; 202, 203; 202, 206; 203, keyword_argument; 203, 204; 203, 205; 204, identifier:fname; 205, string:'.gitignore'; 206, keyword_argument; 206, 207; 206, 208; 207, identifier:text; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:ut; 211, identifier:codeblock; 212, argument_list; 212, 213; 213, string:r'''
*.py[cod]
*.so
*.egg
*.egg-info
dist
build
eggs
parts
bin
var
sdist
develop-eggs
.installed.cfg
lib
lib64
__pycache__
pip-log.txt
logs
.coverage
.tox
nosetests.xml
*.mo
.mr.developer.cfg
.project
.pydevproject
.DS_Store
*.dump.txt
*.sqlite3
*.lprof
*.prof
*.flann
*.npz
_timeings.txt
failed.txt
*.orig
_doc
timeings.txt
failed_doctests.txt
'''; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 217; 216, identifier:_ensure_text; 217, argument_list; 217, 218; 217, 226; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:fname; 220, call; 220, 221; 220, 222; 221, identifier:join; 222, argument_list; 222, 223; 222, 224; 222, 225; 223, identifier:repo_dpath; 224, identifier:modname; 225, string:'__init__.py'; 226, keyword_argument; 226, 227; 226, 228; 227, identifier:text; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:ut; 231, identifier:codeblock; 232, argument_list; 232, 233; 233, string:r'''
from __future__ import absolute_import, division, print_function, unicode_literals
import sys
__version__ = '0.0.0'
IMPORT_TUPLES = [
]
__DYNAMIC__ = '--nodyn' not in sys.argv
DOELSE = False
if __DYNAMIC__:
from utool._internal import util_importer
ignore_endswith = []
import_execstr = util_importer.dynamic_import(
__name__, IMPORT_TUPLES, ignore_endswith=ignore_endswith)
exec(import_execstr)
DOELSE = False
else:
DOELSE = True
if DOELSE:
pass
'''; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 237; 236, identifier:_ensure_text; 237, argument_list; 237, 238; 237, 246; 237, 249; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:fname; 240, call; 240, 241; 240, 242; 241, identifier:join; 242, argument_list; 242, 243; 242, 244; 242, 245; 243, identifier:repo_dpath; 244, identifier:modname; 245, string:'__main__.py'; 246, keyword_argument; 246, 247; 246, 248; 247, identifier:chmod; 248, string:'+x'; 249, keyword_argument; 249, 250; 249, 251; 250, identifier:text; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:ut; 254, identifier:codeblock; 255, argument_list; 255, 256; 256, string:r'''
from __future__ import absolute_import, division, print_function, unicode_literals
def {modname}_main():
ignore_prefix = []
ignore_suffix = []
import utool as ut
ut.main_function_tester('{modname}', ignore_prefix, ignore_suffix)
if __name__ == '__main__':
print('Running {modname} main')
{modname}_main()
'''; 257, expression_statement; 257, 258; 258, call; 258, 259; 258, 260; 259, identifier:_ensure_text; 260, argument_list; 260, 261; 260, 264; 260, 267; 261, keyword_argument; 261, 262; 261, 263; 262, identifier:fname; 263, string:'run_tests.py'; 264, keyword_argument; 264, 265; 264, 266; 265, identifier:chmod; 266, string:'+x'; 267, keyword_argument; 267, 268; 267, 269; 268, identifier:text; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:ut; 272, identifier:codeblock; 273, argument_list; 273, 274; 274, string:r'''
from __future__ import absolute_import, division, print_function
import sys
import utool as ut
def run_tests():
import sys
ut.change_term_title('RUN {modname} TESTS')
exclude_doctests_fnames = set([
])
exclude_dirs = [
'_broken', 'old', 'tests', 'timeits',
'_scripts', '_timeits', '_doc', 'notebook',
]
dpath_list = ['{modname}']
doctest_modname_list = ut.find_doctestable_modnames(
dpath_list, exclude_doctests_fnames, exclude_dirs)
coverage = ut.get_argflag(('--coverage', '--cov',))
if coverage:
import coverage
cov = coverage.Coverage(source=doctest_modname_list)
cov.start()
print('Starting coverage')
exclude_lines = [
'pragma: no cover',
'def __repr__',
'if self.debug:',
'if settings.DEBUG',
'raise AssertionError',
'raise NotImplementedError',
'if 0:',
'if ut.VERBOSE',
'if _debug:',
'if __name__ == .__main__.:',
'print(.*)',
]
for line in exclude_lines:
cov.exclude(line)
for modname in doctest_modname_list:
exec('import ' + modname, globals())
module_list = [sys.modules[name] for name in doctest_modname_list]
nPass, nTotal, failed_cmd_list = ut.doctest_module_list(module_list)
if coverage:
print('Stoping coverage')
cov.stop()
print('Saving coverage')
cov.save()
print('Generating coverage html report')
cov.html_report()
if nPass != nTotal:
return 1
else:
return 0
if __name__ == '__main__':
import multiprocessing
multiprocessing.freeze_support()
retcode = run_tests()
sys.exit(retcode)
'''; 275, expression_statement; 275, 276; 276, call; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:ut; 279, identifier:ensuredir; 280, argument_list; 280, 281; 280, 286; 281, call; 281, 282; 281, 283; 282, identifier:join; 283, argument_list; 283, 284; 283, 285; 284, identifier:repo_dpath; 285, identifier:modname; 286, keyword_argument; 286, 287; 286, 288; 287, identifier:verbose; 288, True | def setup_repo():
r
print('\n [setup_repo]!')
from functools import partial
import utool as ut
code_dpath = ut.truepath(ut.get_argval('--code-dir', default='~/code'))
_code_dpath = ut.unexpanduser(code_dpath)
repo_fname = (ut.get_argval(('--repo', '--repo-name'), type_=str))
repo_dpath = join(code_dpath, repo_fname)
modname = ut.get_argval('--modname', default=repo_fname)
ut.ensuredir(repo_dpath, verbose=True)
_regencmd = 'python -m utool --tf setup_repo --repo={repo_fname} --codedir={_code_dpath} --modname={modname}'
flake8_noqacmd = 'flake8' + ':noqa'
regencmd = _regencmd.format(**locals())
with ut.ChdirContext(repo_dpath):
locals_ = locals()
force = True
_ensure_text = partial(ensure_text, repo_dpath='.', force=None, locals_=locals_)
_ensure_text(
fname='todo.md',
text=ut.codeblock(
r'''
* Add TODOS!
''')
)
_ensure_text(
fname='README.md',
text=ut.codeblock(
r'''
''')
)
_ensure_text(
fname='setup.py',
chmod='+x',
text=ut.codeblock(
r'''
from __future__ import absolute_import, division, print_function, unicode_literals
from setuptools import setup
try:
from utool import util_setup
except ImportError:
print('ERROR: setup requires utool')
raise
INSTALL_REQUIRES = [
]
CLUTTER_PATTERNS = [
]
if __name__ == '__main__':
kwargs = util_setup.setuptools_setup(
setup_fpath=__file__,
name='{modname}',
packages=util_setup.find_packages(),
version=util_setup.parse_package_for_version('{modname}'),
license=util_setup.read_license('LICENSE'),
long_description=util_setup.parse_readme('README.md'),
ext_modules=util_setup.find_ext_modules(),
cmdclass=util_setup.get_cmdclass(),
keywords='',
install_requires=INSTALL_REQUIRES,
clutter_patterns=CLUTTER_PATTERNS,
classifiers=[],
)
setup(**kwargs)
'''
)
)
_ensure_text(
fname='.gitignore',
text=ut.codeblock(
r'''
*.py[cod]
*.so
*.egg
*.egg-info
dist
build
eggs
parts
bin
var
sdist
develop-eggs
.installed.cfg
lib
lib64
__pycache__
pip-log.txt
logs
.coverage
.tox
nosetests.xml
*.mo
.mr.developer.cfg
.project
.pydevproject
.DS_Store
*.dump.txt
*.sqlite3
*.lprof
*.prof
*.flann
*.npz
_timeings.txt
failed.txt
*.orig
_doc
timeings.txt
failed_doctests.txt
'''
)
)
_ensure_text(
fname=join(repo_dpath, modname, '__init__.py'),
text=ut.codeblock(
r'''
from __future__ import absolute_import, division, print_function, unicode_literals
import sys
__version__ = '0.0.0'
IMPORT_TUPLES = [
]
__DYNAMIC__ = '--nodyn' not in sys.argv
DOELSE = False
if __DYNAMIC__:
from utool._internal import util_importer
ignore_endswith = []
import_execstr = util_importer.dynamic_import(
__name__, IMPORT_TUPLES, ignore_endswith=ignore_endswith)
exec(import_execstr)
DOELSE = False
else:
DOELSE = True
if DOELSE:
pass
'''
)
)
_ensure_text(
fname=join(repo_dpath, modname, '__main__.py'),
chmod='+x',
text=ut.codeblock(
r'''
from __future__ import absolute_import, division, print_function, unicode_literals
def {modname}_main():
ignore_prefix = []
ignore_suffix = []
import utool as ut
ut.main_function_tester('{modname}', ignore_prefix, ignore_suffix)
if __name__ == '__main__':
print('Running {modname} main')
{modname}_main()
'''
)
)
_ensure_text(
fname='run_tests.py',
chmod='+x',
text=ut.codeblock(
r'''
from __future__ import absolute_import, division, print_function
import sys
import utool as ut
def run_tests():
import sys
ut.change_term_title('RUN {modname} TESTS')
exclude_doctests_fnames = set([
])
exclude_dirs = [
'_broken', 'old', 'tests', 'timeits',
'_scripts', '_timeits', '_doc', 'notebook',
]
dpath_list = ['{modname}']
doctest_modname_list = ut.find_doctestable_modnames(
dpath_list, exclude_doctests_fnames, exclude_dirs)
coverage = ut.get_argflag(('--coverage', '--cov',))
if coverage:
import coverage
cov = coverage.Coverage(source=doctest_modname_list)
cov.start()
print('Starting coverage')
exclude_lines = [
'pragma: no cover',
'def __repr__',
'if self.debug:',
'if settings.DEBUG',
'raise AssertionError',
'raise NotImplementedError',
'if 0:',
'if ut.VERBOSE',
'if _debug:',
'if __name__ == .__main__.:',
'print(.*)',
]
for line in exclude_lines:
cov.exclude(line)
for modname in doctest_modname_list:
exec('import ' + modname, globals())
module_list = [sys.modules[name] for name in doctest_modname_list]
nPass, nTotal, failed_cmd_list = ut.doctest_module_list(module_list)
if coverage:
print('Stoping coverage')
cov.stop()
print('Saving coverage')
cov.save()
print('Generating coverage html report')
cov.html_report()
if nPass != nTotal:
return 1
else:
return 0
if __name__ == '__main__':
import multiprocessing
multiprocessing.freeze_support()
retcode = run_tests()
sys.exit(retcode)
'''
)
)
ut.ensuredir(join(repo_dpath, modname), verbose=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 36; 2, function_name:generate2; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 3, 30; 3, 33; 4, identifier:func; 5, identifier:args_gen; 6, default_parameter; 6, 7; 6, 8; 7, identifier:kw_gen; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:ntasks; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:ordered; 14, True; 15, default_parameter; 15, 16; 15, 17; 16, identifier:force_serial; 17, False; 18, default_parameter; 18, 19; 18, 20; 19, identifier:use_pool; 20, False; 21, default_parameter; 21, 22; 21, 23; 22, identifier:chunksize; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:nprocs; 26, None; 27, default_parameter; 27, 28; 27, 29; 28, identifier:progkw; 29, dictionary; 30, default_parameter; 30, 31; 30, 32; 31, identifier:nTasks; 32, None; 33, default_parameter; 33, 34; 33, 35; 34, identifier:verbose; 35, None; 36, block; 36, 37; 36, 39; 36, 48; 36, 57; 36, 88; 36, 101; 36, 108; 36, 123; 36, 138; 36, 147; 36, 159; 36, 173; 37, expression_statement; 37, 38; 38, identifier:r; 39, if_statement; 39, 40; 39, 43; 40, comparison_operator:is; 40, 41; 40, 42; 41, identifier:verbose; 42, None; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:verbose; 47, integer:2; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:ntasks; 51, None; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:ntasks; 56, identifier:nTasks; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:ntasks; 60, None; 61, block; 61, 62; 62, try_statement; 62, 63; 62, 71; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:ntasks; 67, call; 67, 68; 67, 69; 68, identifier:len; 69, argument_list; 69, 70; 70, identifier:args_gen; 71, except_clause; 71, 72; 71, 73; 72, identifier:TypeError; 73, block; 73, 74; 73, 81; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:args_gen; 77, call; 77, 78; 77, 79; 78, identifier:list; 79, argument_list; 79, 80; 80, identifier:args_gen; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:ntasks; 84, call; 84, 85; 84, 86; 85, identifier:len; 86, argument_list; 86, 87; 87, identifier:args_gen; 88, if_statement; 88, 89; 88, 96; 89, boolean_operator:or; 89, 90; 89, 93; 90, comparison_operator:==; 90, 91; 90, 92; 91, identifier:ntasks; 92, integer:1; 93, comparison_operator:<; 93, 94; 93, 95; 94, identifier:ntasks; 95, identifier:__MIN_PARALLEL_TASKS__; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:force_serial; 100, True; 101, if_statement; 101, 102; 101, 103; 102, identifier:__FORCE_SERIAL__; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:force_serial; 107, identifier:__FORCE_SERIAL__; 108, if_statement; 108, 109; 108, 112; 109, comparison_operator:==; 109, 110; 109, 111; 110, identifier:ntasks; 111, integer:0; 112, block; 112, 113; 112, 121; 113, if_statement; 113, 114; 113, 115; 114, identifier:verbose; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 119; 118, identifier:print; 119, argument_list; 119, 120; 120, string:'[ut.generate2] submitted 0 tasks'; 121, raise_statement; 121, 122; 122, identifier:StopIteration; 123, if_statement; 123, 124; 123, 127; 124, comparison_operator:is; 124, 125; 124, 126; 125, identifier:nprocs; 126, None; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:nprocs; 131, call; 131, 132; 131, 133; 132, identifier:min; 133, argument_list; 133, 134; 133, 135; 134, identifier:ntasks; 135, call; 135, 136; 135, 137; 136, identifier:get_default_numprocs; 137, argument_list; 138, if_statement; 138, 139; 138, 142; 139, comparison_operator:==; 139, 140; 139, 141; 140, identifier:nprocs; 141, integer:1; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:force_serial; 146, True; 147, if_statement; 147, 148; 147, 151; 148, comparison_operator:is; 148, 149; 148, 150; 149, identifier:kw_gen; 150, None; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:kw_gen; 155, binary_operator:*; 155, 156; 155, 158; 156, list:[{}]; 156, 157; 157, dictionary; 158, identifier:ntasks; 159, if_statement; 159, 160; 159, 165; 160, call; 160, 161; 160, 162; 161, identifier:isinstance; 162, argument_list; 162, 163; 162, 164; 163, identifier:kw_gen; 164, identifier:dict; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:kw_gen; 169, binary_operator:*; 169, 170; 169, 172; 170, list:[kw_gen]; 170, 171; 171, identifier:kw_gen; 172, identifier:ntasks; 173, if_statement; 173, 174; 173, 175; 173, 197; 174, identifier:force_serial; 175, block; 175, 176; 176, for_statement; 176, 177; 176, 178; 176, 193; 177, identifier:result; 178, call; 178, 179; 178, 180; 179, identifier:_generate_serial2; 180, argument_list; 180, 181; 180, 182; 180, 183; 180, 184; 180, 187; 180, 190; 181, identifier:func; 182, identifier:args_gen; 183, identifier:kw_gen; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:ntasks; 186, identifier:ntasks; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:progkw; 189, identifier:progkw; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:verbose; 192, identifier:verbose; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, yield; 195, 196; 196, identifier:result; 197, else_clause; 197, 198; 198, block; 198, 199; 198, 229; 198, 285; 199, if_statement; 199, 200; 199, 201; 200, identifier:verbose; 201, block; 201, 202; 201, 209; 201, 213; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:gentype; 205, conditional_expression:if; 205, 206; 205, 207; 205, 208; 206, string:'mp'; 207, identifier:use_pool; 208, string:'futures'; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:fmtstr; 212, string:'[generate2] executing {} {} tasks using {} {} procs'; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:print; 216, argument_list; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:fmtstr; 220, identifier:format; 221, argument_list; 221, 222; 221, 223; 221, 227; 221, 228; 222, identifier:ntasks; 223, call; 223, 224; 223, 225; 224, identifier:get_funcname; 225, argument_list; 225, 226; 226, identifier:func; 227, identifier:nprocs; 228, identifier:gentype; 229, if_statement; 229, 230; 229, 233; 230, comparison_operator:>; 230, 231; 230, 232; 231, identifier:verbose; 232, integer:1; 233, block; 233, 234; 233, 244; 233, 262; 233, 269; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:lbl; 237, binary_operator:%; 237, 238; 237, 239; 238, string:'(pargen) %s: '; 239, tuple; 239, 240; 240, call; 240, 241; 240, 242; 241, identifier:get_funcname; 242, argument_list; 242, 243; 243, identifier:func; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 247; 246, identifier:progkw_; 247, call; 247, 248; 247, 249; 248, identifier:dict; 249, argument_list; 249, 250; 249, 253; 249, 256; 249, 259; 250, keyword_argument; 250, 251; 250, 252; 251, identifier:freq; 252, None; 253, keyword_argument; 253, 254; 253, 255; 254, identifier:bs; 255, True; 256, keyword_argument; 256, 257; 256, 258; 257, identifier:adjust; 258, False; 259, keyword_argument; 259, 260; 259, 261; 260, identifier:freq_est; 261, string:'absolute'; 262, expression_statement; 262, 263; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:progkw_; 266, identifier:update; 267, argument_list; 267, 268; 268, identifier:progkw; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:progpart; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:util_progress; 275, identifier:ProgPartial; 276, argument_list; 276, 277; 276, 280; 276, 283; 277, keyword_argument; 277, 278; 277, 279; 278, identifier:length; 279, identifier:ntasks; 280, keyword_argument; 280, 281; 280, 282; 281, identifier:lbl; 282, identifier:lbl; 283, dictionary_splat; 283, 284; 284, identifier:progkw_; 285, if_statement; 285, 286; 285, 287; 285, 399; 286, identifier:use_pool; 287, block; 287, 288; 287, 314; 288, if_statement; 288, 289; 288, 292; 289, comparison_operator:is; 289, 290; 289, 291; 290, identifier:chunksize; 291, None; 292, block; 292, 293; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 296; 295, identifier:chunksize; 296, call; 296, 297; 296, 298; 297, identifier:max; 298, argument_list; 298, 299; 298, 304; 299, call; 299, 300; 299, 301; 300, identifier:min; 301, argument_list; 301, 302; 301, 303; 302, integer:4; 303, identifier:ntasks; 304, call; 304, 305; 304, 306; 305, identifier:min; 306, argument_list; 306, 307; 306, 308; 307, integer:8; 308, binary_operator://; 308, 309; 308, 310; 309, identifier:ntasks; 310, parenthesized_expression; 310, 311; 311, binary_operator:**; 311, 312; 311, 313; 312, identifier:nprocs; 313, integer:2; 314, try_statement; 314, 315; 314, 385; 315, block; 315, 316; 315, 325; 315, 342; 315, 357; 315, 366; 315, 378; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 319; 318, identifier:pool; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:multiprocessing; 322, identifier:Pool; 323, argument_list; 323, 324; 324, identifier:nprocs; 325, if_statement; 325, 326; 325, 327; 325, 334; 326, identifier:ordered; 327, block; 327, 328; 328, expression_statement; 328, 329; 329, assignment; 329, 330; 329, 331; 330, identifier:pmap_func; 331, attribute; 331, 332; 331, 333; 332, identifier:pool; 333, identifier:imap; 334, else_clause; 334, 335; 335, block; 335, 336; 336, expression_statement; 336, 337; 337, assignment; 337, 338; 337, 339; 338, identifier:pmap_func; 339, attribute; 339, 340; 339, 341; 340, identifier:pool; 341, identifier:imap_unordered; 342, expression_statement; 342, 343; 343, assignment; 343, 344; 343, 345; 344, identifier:wrapped_arg_gen; 345, call; 345, 346; 345, 347; 346, identifier:zip; 347, argument_list; 347, 348; 347, 355; 347, 356; 348, binary_operator:*; 348, 349; 348, 351; 349, list:[func]; 349, 350; 350, identifier:func; 351, call; 351, 352; 351, 353; 352, identifier:len; 353, argument_list; 353, 354; 354, identifier:args_gen; 355, identifier:args_gen; 356, identifier:kw_gen; 357, expression_statement; 357, 358; 358, assignment; 358, 359; 358, 360; 359, identifier:res_gen; 360, call; 360, 361; 360, 362; 361, identifier:pmap_func; 362, argument_list; 362, 363; 362, 364; 362, 365; 363, identifier:_kw_wrap_worker; 364, identifier:wrapped_arg_gen; 365, identifier:chunksize; 366, if_statement; 366, 367; 366, 370; 367, comparison_operator:>; 367, 368; 367, 369; 368, identifier:verbose; 369, integer:1; 370, block; 370, 371; 371, expression_statement; 371, 372; 372, assignment; 372, 373; 372, 374; 373, identifier:res_gen; 374, call; 374, 375; 374, 376; 375, identifier:progpart; 376, argument_list; 376, 377; 377, identifier:res_gen; 378, for_statement; 378, 379; 378, 380; 378, 381; 379, identifier:res; 380, identifier:res_gen; 381, block; 381, 382; 382, expression_statement; 382, 383; 383, yield; 383, 384; 384, identifier:res; 385, finally_clause; 385, 386; 386, block; 386, 387; 386, 393; 387, expression_statement; 387, 388; 388, call; 388, 389; 388, 392; 389, attribute; 389, 390; 389, 391; 390, identifier:pool; 391, identifier:close; 392, argument_list; 393, expression_statement; 393, 394; 394, call; 394, 395; 394, 398; 395, attribute; 395, 396; 395, 397; 396, identifier:pool; 397, identifier:join; 398, argument_list; 399, else_clause; 399, 400; 400, block; 400, 401; 400, 410; 401, expression_statement; 401, 402; 402, assignment; 402, 403; 402, 404; 403, identifier:executor; 404, call; 404, 405; 404, 408; 405, attribute; 405, 406; 405, 407; 406, identifier:futures; 407, identifier:ProcessPoolExecutor; 408, argument_list; 408, 409; 409, identifier:nprocs; 410, try_statement; 410, 411; 410, 475; 411, block; 411, 412; 411, 435; 411, 439; 411, 452; 411, 464; 412, expression_statement; 412, 413; 413, assignment; 413, 414; 413, 415; 414, identifier:fs_list; 415, list_comprehension; 415, 416; 415, 426; 416, call; 416, 417; 416, 420; 417, attribute; 417, 418; 417, 419; 418, identifier:executor; 419, identifier:submit; 420, argument_list; 420, 421; 420, 422; 420, 424; 421, identifier:func; 422, list_splat; 422, 423; 423, identifier:a; 424, dictionary_splat; 424, 425; 425, identifier:k; 426, for_in_clause; 426, 427; 426, 430; 427, pattern_list; 427, 428; 427, 429; 428, identifier:a; 429, identifier:k; 430, call; 430, 431; 430, 432; 431, identifier:zip; 432, argument_list; 432, 433; 432, 434; 433, identifier:args_gen; 434, identifier:kw_gen; 435, expression_statement; 435, 436; 436, assignment; 436, 437; 436, 438; 437, identifier:fs_gen; 438, identifier:fs_list; 439, if_statement; 439, 440; 439, 442; 440, not_operator; 440, 441; 441, identifier:ordered; 442, block; 442, 443; 443, expression_statement; 443, 444; 444, assignment; 444, 445; 444, 446; 445, identifier:fs_gen; 446, call; 446, 447; 446, 450; 447, attribute; 447, 448; 447, 449; 448, identifier:futures; 449, identifier:as_completed; 450, argument_list; 450, 451; 451, identifier:fs_gen; 452, if_statement; 452, 453; 452, 456; 453, comparison_operator:>; 453, 454; 453, 455; 454, identifier:verbose; 455, integer:1; 456, block; 456, 457; 457, expression_statement; 457, 458; 458, assignment; 458, 459; 458, 460; 459, identifier:fs_gen; 460, call; 460, 461; 460, 462; 461, identifier:progpart; 462, argument_list; 462, 463; 463, identifier:fs_gen; 464, for_statement; 464, 465; 464, 466; 464, 467; 465, identifier:fs; 466, identifier:fs_gen; 467, block; 467, 468; 468, expression_statement; 468, 469; 469, yield; 469, 470; 470, call; 470, 471; 470, 474; 471, attribute; 471, 472; 471, 473; 472, identifier:fs; 473, identifier:result; 474, argument_list; 475, finally_clause; 475, 476; 476, block; 476, 477; 477, expression_statement; 477, 478; 478, call; 478, 479; 478, 482; 479, attribute; 479, 480; 479, 481; 480, identifier:executor; 481, identifier:shutdown; 482, argument_list; 482, 483; 483, keyword_argument; 483, 484; 483, 485; 484, identifier:wait; 485, True | def generate2(func, args_gen, kw_gen=None, ntasks=None, ordered=True,
force_serial=False, use_pool=False, chunksize=None, nprocs=None,
progkw={}, nTasks=None, verbose=None):
r
if verbose is None:
verbose = 2
if ntasks is None:
ntasks = nTasks
if ntasks is None:
try:
ntasks = len(args_gen)
except TypeError:
args_gen = list(args_gen)
ntasks = len(args_gen)
if ntasks == 1 or ntasks < __MIN_PARALLEL_TASKS__:
force_serial = True
if __FORCE_SERIAL__:
force_serial = __FORCE_SERIAL__
if ntasks == 0:
if verbose:
print('[ut.generate2] submitted 0 tasks')
raise StopIteration
if nprocs is None:
nprocs = min(ntasks, get_default_numprocs())
if nprocs == 1:
force_serial = True
if kw_gen is None:
kw_gen = [{}] * ntasks
if isinstance(kw_gen, dict):
kw_gen = [kw_gen] * ntasks
if force_serial:
for result in _generate_serial2(func, args_gen, kw_gen,
ntasks=ntasks, progkw=progkw,
verbose=verbose):
yield result
else:
if verbose:
gentype = 'mp' if use_pool else 'futures'
fmtstr = '[generate2] executing {} {} tasks using {} {} procs'
print(fmtstr.format(ntasks, get_funcname(func), nprocs, gentype))
if verbose > 1:
lbl = '(pargen) %s: ' % (get_funcname(func),)
progkw_ = dict(freq=None, bs=True, adjust=False, freq_est='absolute')
progkw_.update(progkw)
progpart = util_progress.ProgPartial(length=ntasks, lbl=lbl, **progkw_)
if use_pool:
if chunksize is None:
chunksize = max(min(4, ntasks), min(8, ntasks // (nprocs ** 2)))
try:
pool = multiprocessing.Pool(nprocs)
if ordered:
pmap_func = pool.imap
else:
pmap_func = pool.imap_unordered
wrapped_arg_gen = zip([func] * len(args_gen), args_gen, kw_gen)
res_gen = pmap_func(_kw_wrap_worker, wrapped_arg_gen,
chunksize)
if verbose > 1:
res_gen = progpart(res_gen)
for res in res_gen:
yield res
finally:
pool.close()
pool.join()
else:
executor = futures.ProcessPoolExecutor(nprocs)
try:
fs_list = [executor.submit(func, *a, **k)
for a, k in zip(args_gen, kw_gen)]
fs_gen = fs_list
if not ordered:
fs_gen = futures.as_completed(fs_gen)
if verbose > 1:
fs_gen = progpart(fs_gen)
for fs in fs_gen:
yield fs.result()
finally:
executor.shutdown(wait=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:buffered_generator; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:source_gen; 5, default_parameter; 5, 6; 5, 7; 6, identifier:buffer_size; 7, integer:2; 8, default_parameter; 8, 9; 8, 10; 9, identifier:use_multiprocessing; 10, False; 11, block; 11, 12; 11, 14; 11, 24; 11, 94; 11, 105; 11, 109; 11, 127; 11, 133; 11, 139; 12, expression_statement; 12, 13; 13, identifier:r; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:<; 15, 16; 15, 17; 16, identifier:buffer_size; 17, integer:2; 18, block; 18, 19; 19, raise_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:RuntimeError; 22, argument_list; 22, 23; 23, string:"Minimal buffer_ size is 2!"; 24, if_statement; 24, 25; 24, 26; 24, 78; 25, identifier:use_multiprocessing; 26, block; 26, 27; 26, 32; 26, 68; 26, 74; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:print; 30, argument_list; 30, 31; 31, string:'WARNING seems to freeze if passed in a generator'; 32, if_statement; 32, 33; 32, 34; 32, 60; 33, False; 34, block; 34, 35; 34, 54; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:pool; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:multiprocessing; 41, identifier:Pool; 42, argument_list; 42, 43; 42, 48; 42, 51; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:processes; 45, call; 45, 46; 45, 47; 46, identifier:get_default_numprocs; 47, argument_list; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:initializer; 50, identifier:init_worker; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:maxtasksperchild; 53, None; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:Process; 57, attribute; 57, 58; 57, 59; 58, identifier:pool; 59, identifier:Process; 60, else_clause; 60, 61; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:Process; 65, attribute; 65, 66; 65, 67; 66, identifier:multiprocessing; 67, identifier:Process; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:_Queue; 71, attribute; 71, 72; 71, 73; 72, identifier:multiprocessing; 73, identifier:Queue; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:target; 77, identifier:_buffered_generation_process; 78, else_clause; 78, 79; 79, block; 79, 80; 79, 86; 79, 90; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:_Queue; 83, attribute; 83, 84; 83, 85; 84, identifier:queue; 85, identifier:Queue; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:Process; 89, identifier:KillableThread; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:target; 93, identifier:_buffered_generation_thread; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:buffer_; 97, call; 97, 98; 97, 99; 98, identifier:_Queue; 99, argument_list; 99, 100; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:maxsize; 102, binary_operator:-; 102, 103; 102, 104; 103, identifier:buffer_size; 104, integer:1; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:sentinal; 108, identifier:StopIteration; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:process; 112, call; 112, 113; 112, 114; 113, identifier:Process; 114, argument_list; 114, 115; 114, 118; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:target; 117, identifier:target; 118, keyword_argument; 118, 119; 118, 120; 119, identifier:args; 120, tuple; 120, 121; 120, 125; 120, 126; 121, call; 121, 122; 121, 123; 122, identifier:iter; 123, argument_list; 123, 124; 124, identifier:source_gen; 125, identifier:buffer_; 126, identifier:sentinal; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:process; 131, identifier:daemon; 132, True; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:process; 137, identifier:start; 138, argument_list; 139, while_statement; 139, 140; 139, 141; 140, True; 141, block; 141, 142; 141, 150; 141, 157; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:output; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:buffer_; 148, identifier:get; 149, argument_list; 150, if_statement; 150, 151; 150, 154; 151, comparison_operator:is; 151, 152; 151, 153; 152, identifier:output; 153, identifier:sentinal; 154, block; 154, 155; 155, raise_statement; 155, 156; 156, identifier:StopIteration; 157, expression_statement; 157, 158; 158, yield; 158, 159; 159, identifier:output | def buffered_generator(source_gen, buffer_size=2, use_multiprocessing=False):
r
if buffer_size < 2:
raise RuntimeError("Minimal buffer_ size is 2!")
if use_multiprocessing:
print('WARNING seems to freeze if passed in a generator')
if False:
pool = multiprocessing.Pool(processes=get_default_numprocs(),
initializer=init_worker,
maxtasksperchild=None)
Process = pool.Process
else:
Process = multiprocessing.Process
_Queue = multiprocessing.Queue
target = _buffered_generation_process
else:
_Queue = queue.Queue
Process = KillableThread
target = _buffered_generation_thread
buffer_ = _Queue(maxsize=buffer_size - 1)
sentinal = StopIteration
process = Process(
target=target,
args=(iter(source_gen), buffer_, sentinal)
)
process.daemon = True
process.start()
while True:
output = buffer_.get()
if output is sentinal:
raise StopIteration
yield output |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_window_ids; 3, parameters; 3, 4; 3, 5; 4, identifier:winid_list; 5, default_parameter; 5, 6; 5, 7; 6, identifier:order; 7, string:'mru'; 8, block; 8, 9; 8, 14; 8, 23; 8, 33; 9, import_statement; 9, 10; 10, aliased_import; 10, 11; 10, 13; 11, dotted_name; 11, 12; 12, identifier:utool; 13, identifier:ut; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:winid_order; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:XCtrl; 20, identifier:sorted_window_ids; 21, argument_list; 21, 22; 22, identifier:order; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:sorted_win_ids; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:ut; 29, identifier:isect; 30, argument_list; 30, 31; 30, 32; 31, identifier:winid_order; 32, identifier:winid_list; 33, return_statement; 33, 34; 34, identifier:sorted_win_ids | def sort_window_ids(winid_list, order='mru'):
import utool as ut
winid_order = XCtrl.sorted_window_ids(order)
sorted_win_ids = ut.isect(winid_order, winid_list)
return sorted_win_ids |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:__infer_setup_kwargs; 3, parameters; 3, 4; 3, 5; 4, identifier:module; 5, identifier:kwargs; 6, block; 6, 7; 6, 13; 6, 23; 6, 41; 6, 59; 6, 79; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:name; 10, subscript; 10, 11; 10, 12; 11, identifier:kwargs; 12, string:'name'; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:packages; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:kwargs; 19, identifier:get; 20, argument_list; 20, 21; 20, 22; 21, string:'packages'; 22, list:[]; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:not; 24, 25; 24, 26; 25, identifier:name; 26, identifier:packages; 27, block; 27, 28; 27, 35; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:packages; 32, identifier:append; 33, argument_list; 33, 34; 34, identifier:name; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:kwargs; 39, string:'packages'; 40, identifier:packages; 41, if_statement; 41, 42; 41, 45; 42, comparison_operator:not; 42, 43; 42, 44; 43, string:'version'; 44, identifier:kwargs; 45, block; 45, 46; 45, 53; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:version; 49, call; 49, 50; 49, 51; 50, identifier:parse_package_for_version; 51, argument_list; 51, 52; 52, identifier:name; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:kwargs; 57, string:'version'; 58, identifier:version; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:not; 60, 61; 60, 62; 61, string:'license'; 62, identifier:kwargs; 63, block; 63, 64; 64, try_statement; 64, 65; 64, 75; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:kwargs; 70, string:'license'; 71, call; 71, 72; 71, 73; 72, identifier:read_license; 73, argument_list; 73, 74; 74, string:'LICENSE'; 75, except_clause; 75, 76; 75, 77; 76, identifier:IOError; 77, block; 77, 78; 78, pass_statement; 79, if_statement; 79, 80; 79, 83; 80, comparison_operator:not; 80, 81; 80, 82; 81, string:'long_description'; 82, identifier:kwargs; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:kwargs; 88, string:'long_description'; 89, call; 89, 90; 89, 91; 90, identifier:parse_readme; 91, argument_list | def __infer_setup_kwargs(module, kwargs):
name = kwargs['name']
packages = kwargs.get('packages', [])
if name not in packages:
packages.append(name)
kwargs['packages'] = packages
if 'version' not in kwargs:
version = parse_package_for_version(name)
kwargs['version'] = version
if 'license' not in kwargs:
try:
kwargs['license'] = read_license('LICENSE')
except IOError:
pass
if 'long_description' not in kwargs:
kwargs['long_description'] = parse_readme() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:on_exception_report_input; 3, parameters; 3, 4; 3, 7; 3, 10; 4, default_parameter; 4, 5; 4, 6; 5, identifier:func_; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:force; 9, False; 10, default_parameter; 10, 11; 10, 12; 11, identifier:keys; 12, None; 13, block; 13, 14; 13, 376; 14, function_definition; 14, 15; 14, 16; 14, 18; 15, function_name:_closure_onexceptreport; 16, parameters; 16, 17; 17, identifier:func; 18, block; 18, 19; 18, 28; 18, 366; 18, 374; 19, if_statement; 19, 20; 19, 25; 20, boolean_operator:and; 20, 21; 20, 23; 21, not_operator; 21, 22; 22, identifier:ONEX_REPORT_INPUT; 23, not_operator; 23, 24; 24, identifier:force; 25, block; 25, 26; 26, return_statement; 26, 27; 27, identifier:func; 28, decorated_definition; 28, 29; 28, 36; 29, decorator; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:ignores_exc_tb; 32, argument_list; 32, 33; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:outer_wrapper; 35, False; 36, function_definition; 36, 37; 36, 38; 36, 43; 37, function_name:wrp_onexceptreport; 38, parameters; 38, 39; 38, 41; 39, list_splat_pattern; 39, 40; 40, identifier:args; 41, dictionary_splat_pattern; 41, 42; 42, identifier:kwargs; 43, block; 43, 44; 44, try_statement; 44, 45; 44, 54; 45, block; 45, 46; 46, return_statement; 46, 47; 47, call; 47, 48; 47, 49; 48, identifier:func; 49, argument_list; 49, 50; 49, 52; 50, list_splat; 50, 51; 51, identifier:args; 52, dictionary_splat; 52, 53; 53, identifier:kwargs; 54, except_clause; 54, 55; 54, 59; 55, as_pattern; 55, 56; 55, 57; 56, identifier:Exception; 57, as_pattern_target; 57, 58; 58, identifier:ex; 59, block; 59, 60; 59, 65; 59, 70; 59, 268; 59, 292; 59, 321; 59, 336; 59, 345; 59, 354; 59, 365; 60, import_from_statement; 60, 61; 60, 63; 61, dotted_name; 61, 62; 62, identifier:utool; 63, dotted_name; 63, 64; 64, identifier:util_str; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:print; 68, argument_list; 68, 69; 69, string:'ERROR occured! Reporting input to function'; 70, if_statement; 70, 71; 70, 74; 71, comparison_operator:is; 71, 72; 71, 73; 72, identifier:keys; 73, None; 74, block; 74, 75; 74, 80; 74, 85; 74, 90; 74, 99; 74, 109; 74, 119; 74, 132; 74, 141; 74, 151; 74, 166; 74, 182; 74, 199; 74, 217; 74, 227; 74, 249; 74, 267; 75, import_from_statement; 75, 76; 75, 78; 76, dotted_name; 76, 77; 77, identifier:utool; 78, dotted_name; 78, 79; 79, identifier:util_inspect; 80, import_from_statement; 80, 81; 80, 83; 81, dotted_name; 81, 82; 82, identifier:utool; 83, dotted_name; 83, 84; 84, identifier:util_list; 85, import_from_statement; 85, 86; 85, 88; 86, dotted_name; 86, 87; 87, identifier:utool; 88, dotted_name; 88, 89; 89, identifier:util_dict; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:argspec; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:util_inspect; 96, identifier:get_func_argspec; 97, argument_list; 97, 98; 98, identifier:func; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:in_kwargs_flags; 102, list_comprehension; 102, 103; 102, 106; 103, comparison_operator:in; 103, 104; 103, 105; 104, identifier:key; 105, identifier:kwargs; 106, for_in_clause; 106, 107; 106, 108; 107, identifier:key; 108, identifier:keys; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:kwarg_keys; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:util_list; 115, identifier:compress; 116, argument_list; 116, 117; 116, 118; 117, identifier:keys; 118, identifier:in_kwargs_flags; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:kwarg_vals; 122, list_comprehension; 122, 123; 122, 129; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:kwargs; 126, identifier:get; 127, argument_list; 127, 128; 128, identifier:key; 129, for_in_clause; 129, 130; 129, 131; 130, identifier:key; 131, identifier:kwarg_keys; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:flags; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:util_list; 138, identifier:not_list; 139, argument_list; 139, 140; 140, identifier:in_kwargs_flags; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:arg_keys; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:util_list; 147, identifier:compress; 148, argument_list; 148, 149; 148, 150; 149, identifier:keys; 150, identifier:flags; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:arg_idxs; 154, list_comprehension; 154, 155; 154, 163; 155, call; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:argspec; 159, identifier:args; 160, identifier:index; 161, argument_list; 161, 162; 162, identifier:key; 163, for_in_clause; 163, 164; 163, 165; 164, identifier:key; 165, identifier:arg_keys; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:num_nodefault; 169, binary_operator:-; 169, 170; 169, 176; 170, call; 170, 171; 170, 172; 171, identifier:len; 172, argument_list; 172, 173; 173, attribute; 173, 174; 173, 175; 174, identifier:argspec; 175, identifier:args; 176, call; 176, 177; 176, 178; 177, identifier:len; 178, argument_list; 178, 179; 179, attribute; 179, 180; 179, 181; 180, identifier:argspec; 181, identifier:defaults; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:default_vals; 185, parenthesized_expression; 185, 186; 186, binary_operator:+; 186, 187; 186, 193; 187, parenthesized_expression; 187, 188; 188, binary_operator:*; 188, 189; 188, 191; 189, list:[None]; 189, 190; 190, None; 191, parenthesized_expression; 191, 192; 192, identifier:num_nodefault; 193, call; 193, 194; 193, 195; 194, identifier:list; 195, argument_list; 195, 196; 196, attribute; 196, 197; 196, 198; 197, identifier:argspec; 198, identifier:defaults; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:args_; 202, binary_operator:+; 202, 203; 202, 207; 203, call; 203, 204; 203, 205; 204, identifier:list; 205, argument_list; 205, 206; 206, identifier:args; 207, subscript; 207, 208; 207, 209; 208, identifier:default_vals; 209, slice; 209, 210; 209, 216; 210, binary_operator:+; 210, 211; 210, 215; 211, call; 211, 212; 211, 213; 212, identifier:len; 213, argument_list; 213, 214; 214, identifier:args; 215, integer:1; 216, colon; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:arg_vals; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:util_list; 223, identifier:take; 224, argument_list; 224, 225; 224, 226; 225, identifier:args_; 226, identifier:arg_idxs; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:requested_dict; 230, call; 230, 231; 230, 232; 231, identifier:dict; 232, argument_list; 232, 233; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:util_list; 236, identifier:flatten; 237, argument_list; 237, 238; 238, list:[zip(kwarg_keys, kwarg_vals), zip(arg_keys, arg_vals)]; 238, 239; 238, 244; 239, call; 239, 240; 239, 241; 240, identifier:zip; 241, argument_list; 241, 242; 241, 243; 242, identifier:kwarg_keys; 243, identifier:kwarg_vals; 244, call; 244, 245; 244, 246; 245, identifier:zip; 246, argument_list; 246, 247; 246, 248; 247, identifier:arg_keys; 248, identifier:arg_vals; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 252; 251, identifier:print; 252, argument_list; 252, 253; 253, binary_operator:+; 253, 254; 253, 255; 254, string:'input dict = '; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:util_str; 258, identifier:repr4; 259, argument_list; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:util_dict; 263, identifier:dict_subset; 264, argument_list; 264, 265; 264, 266; 265, identifier:requested_dict; 266, identifier:keys; 267, pass_statement; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:arg_strs; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, string:', '; 274, identifier:join; 275, argument_list; 275, 276; 276, list_comprehension; 276, 277; 276, 289; 277, call; 277, 278; 277, 279; 278, identifier:repr; 279, argument_list; 279, 280; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:util_str; 283, identifier:truncate_str; 284, argument_list; 284, 285; 285, call; 285, 286; 285, 287; 286, identifier:str; 287, argument_list; 287, 288; 288, identifier:arg; 289, for_in_clause; 289, 290; 289, 291; 290, identifier:arg; 291, identifier:args; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:kwarg_strs; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, string:', '; 298, identifier:join; 299, argument_list; 299, 300; 300, list_comprehension; 300, 301; 300, 311; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:util_str; 304, identifier:truncate_str; 305, argument_list; 305, 306; 306, binary_operator:%; 306, 307; 306, 308; 307, string:'%s=%r'; 308, tuple; 308, 309; 308, 310; 309, identifier:key; 310, identifier:val; 311, for_in_clause; 311, 312; 311, 315; 312, pattern_list; 312, 313; 312, 314; 313, identifier:key; 314, identifier:val; 315, call; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:six; 318, identifier:iteritems; 319, argument_list; 319, 320; 320, identifier:kwargs; 321, expression_statement; 321, 322; 322, assignment; 322, 323; 322, 324; 323, identifier:msg; 324, parenthesized_expression; 324, 325; 325, binary_operator:%; 325, 326; 325, 327; 326, string:'\nERROR: funcname=%r,\n * args=%s,\n * kwargs=%r\n'; 327, tuple; 327, 328; 327, 334; 327, 335; 328, call; 328, 329; 328, 332; 329, attribute; 329, 330; 329, 331; 330, identifier:meta_util_six; 331, identifier:get_funcname; 332, argument_list; 332, 333; 333, identifier:func; 334, identifier:arg_strs; 335, identifier:kwarg_strs; 336, expression_statement; 336, 337; 337, augmented_assignment:+=; 337, 338; 337, 339; 338, identifier:msg; 339, binary_operator:%; 339, 340; 339, 341; 340, string:' * len(args) = %r\n'; 341, call; 341, 342; 341, 343; 342, identifier:len; 343, argument_list; 343, 344; 344, identifier:args; 345, expression_statement; 345, 346; 346, augmented_assignment:+=; 346, 347; 346, 348; 347, identifier:msg; 348, binary_operator:%; 348, 349; 348, 350; 349, string:' * len(kwargs) = %r\n'; 350, call; 350, 351; 350, 352; 351, identifier:len; 352, argument_list; 352, 353; 353, identifier:kwargs; 354, expression_statement; 354, 355; 355, call; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, identifier:util_dbg; 358, identifier:printex; 359, argument_list; 359, 360; 359, 361; 359, 362; 360, identifier:ex; 361, identifier:msg; 362, keyword_argument; 362, 363; 362, 364; 363, identifier:pad_stdout; 364, True; 365, raise_statement; 366, expression_statement; 366, 367; 367, assignment; 367, 368; 367, 369; 368, identifier:wrp_onexceptreport; 369, call; 369, 370; 369, 371; 370, identifier:preserve_sig; 371, argument_list; 371, 372; 371, 373; 372, identifier:wrp_onexceptreport; 373, identifier:func; 374, return_statement; 374, 375; 375, identifier:wrp_onexceptreport; 376, if_statement; 376, 377; 376, 380; 376, 383; 377, comparison_operator:is; 377, 378; 377, 379; 378, identifier:func_; 379, None; 380, block; 380, 381; 381, return_statement; 381, 382; 382, identifier:_closure_onexceptreport; 383, else_clause; 383, 384; 384, block; 384, 385; 385, return_statement; 385, 386; 386, call; 386, 387; 386, 388; 387, identifier:_closure_onexceptreport; 388, argument_list; 388, 389; 389, identifier:func_ | def on_exception_report_input(func_=None, force=False, keys=None):
def _closure_onexceptreport(func):
if not ONEX_REPORT_INPUT and not force:
return func
@ignores_exc_tb(outer_wrapper=False)
def wrp_onexceptreport(*args, **kwargs):
try:
return func(*args, **kwargs)
except Exception as ex:
from utool import util_str
print('ERROR occured! Reporting input to function')
if keys is not None:
from utool import util_inspect
from utool import util_list
from utool import util_dict
argspec = util_inspect.get_func_argspec(func)
in_kwargs_flags = [key in kwargs for key in keys]
kwarg_keys = util_list.compress(keys, in_kwargs_flags)
kwarg_vals = [kwargs.get(key) for key in kwarg_keys]
flags = util_list.not_list(in_kwargs_flags)
arg_keys = util_list.compress(keys, flags)
arg_idxs = [argspec.args.index(key) for key in arg_keys]
num_nodefault = len(argspec.args) - len(argspec.defaults)
default_vals = (([None] * (num_nodefault)) +
list(argspec.defaults))
args_ = list(args) + default_vals[len(args) + 1:]
arg_vals = util_list.take(args_, arg_idxs)
requested_dict = dict(util_list.flatten(
[zip(kwarg_keys, kwarg_vals), zip(arg_keys, arg_vals)]))
print('input dict = ' + util_str.repr4(
util_dict.dict_subset(requested_dict, keys)))
pass
arg_strs = ', '.join([repr(util_str.truncate_str(str(arg)))
for arg in args])
kwarg_strs = ', '.join([
util_str.truncate_str('%s=%r' % (key, val))
for key, val in six.iteritems(kwargs)])
msg = ('\nERROR: funcname=%r,\n * args=%s,\n * kwargs=%r\n' % (
meta_util_six.get_funcname(func), arg_strs, kwarg_strs))
msg += ' * len(args) = %r\n' % len(args)
msg += ' * len(kwargs) = %r\n' % len(kwargs)
util_dbg.printex(ex, msg, pad_stdout=True)
raise
wrp_onexceptreport = preserve_sig(wrp_onexceptreport, func)
return wrp_onexceptreport
if func_ is None:
return _closure_onexceptreport
else:
return _closure_onexceptreport(func_) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:accepts_scalar_input; 3, parameters; 3, 4; 4, identifier:func; 5, block; 5, 6; 5, 66; 5, 74; 6, decorated_definition; 6, 7; 6, 14; 7, decorator; 7, 8; 8, call; 8, 9; 8, 10; 9, identifier:ignores_exc_tb; 10, argument_list; 10, 11; 11, keyword_argument; 11, 12; 11, 13; 12, identifier:outer_wrapper; 13, False; 14, function_definition; 14, 15; 14, 16; 14, 23; 15, function_name:wrp_asi; 16, parameters; 16, 17; 16, 18; 16, 19; 16, 21; 17, identifier:self; 18, identifier:input_; 19, list_splat_pattern; 19, 20; 20, identifier:args; 21, dictionary_splat_pattern; 21, 22; 22, identifier:kwargs; 23, block; 23, 24; 24, if_statement; 24, 25; 24, 31; 24, 42; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:util_iter; 28, identifier:isiterable; 29, argument_list; 29, 30; 30, identifier:input_; 31, block; 31, 32; 32, return_statement; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:func; 35, argument_list; 35, 36; 35, 37; 35, 38; 35, 40; 36, identifier:self; 37, identifier:input_; 38, list_splat; 38, 39; 39, identifier:args; 40, dictionary_splat; 40, 41; 41, identifier:kwargs; 42, else_clause; 42, 43; 43, block; 43, 44; 43, 57; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:ret; 47, call; 47, 48; 47, 49; 48, identifier:func; 49, argument_list; 49, 50; 49, 51; 49, 53; 49, 55; 50, identifier:self; 51, list:[input_]; 51, 52; 52, identifier:input_; 53, list_splat; 53, 54; 54, identifier:args; 55, dictionary_splat; 55, 56; 56, identifier:kwargs; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:ret; 60, None; 61, block; 61, 62; 62, return_statement; 62, 63; 63, subscript; 63, 64; 63, 65; 64, identifier:ret; 65, integer:0; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:wrp_asi; 69, call; 69, 70; 69, 71; 70, identifier:preserve_sig; 71, argument_list; 71, 72; 71, 73; 72, identifier:wrp_asi; 73, identifier:func; 74, return_statement; 74, 75; 75, identifier:wrp_asi | def accepts_scalar_input(func):
@ignores_exc_tb(outer_wrapper=False)
def wrp_asi(self, input_, *args, **kwargs):
if util_iter.isiterable(input_):
return func(self, input_, *args, **kwargs)
else:
ret = func(self, [input_], *args, **kwargs)
if ret is not None:
return ret[0]
wrp_asi = preserve_sig(wrp_asi, func)
return wrp_asi |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:preserve_sig; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:wrapper; 5, identifier:orig_func; 6, default_parameter; 6, 7; 6, 8; 7, identifier:force; 8, False; 9, block; 9, 10; 9, 16; 9, 21; 9, 26; 9, 33; 9, 42; 9, 51; 9, 60; 9, 71; 9, 80; 9, 84; 9, 90; 9, 96; 9, 102; 9, 108; 9, 127; 9, 146; 9, 160; 9, 302; 9, 306; 9, 329; 9, 349; 9, 357; 9, 363; 10, import_from_statement; 10, 11; 10, 14; 11, dotted_name; 11, 12; 11, 13; 12, identifier:utool; 13, identifier:_internal; 14, dotted_name; 14, 15; 15, identifier:meta_util_six; 16, import_from_statement; 16, 17; 16, 19; 17, dotted_name; 17, 18; 18, identifier:utool; 19, dotted_name; 19, 20; 20, identifier:util_str; 21, import_from_statement; 21, 22; 21, 24; 22, dotted_name; 22, 23; 23, identifier:utool; 24, dotted_name; 24, 25; 25, identifier:util_inspect; 26, if_statement; 26, 27; 26, 30; 27, comparison_operator:is; 27, 28; 27, 29; 28, identifier:wrapper; 29, identifier:orig_func; 30, block; 30, 31; 31, return_statement; 31, 32; 32, identifier:orig_func; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:orig_docstr; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:meta_util_six; 39, identifier:get_funcdoc; 40, argument_list; 40, 41; 41, identifier:orig_func; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:orig_docstr; 45, conditional_expression:if; 45, 46; 45, 47; 45, 50; 46, string:''; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:orig_docstr; 49, None; 50, identifier:orig_docstr; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:orig_argspec; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:util_inspect; 57, identifier:get_func_argspec; 58, argument_list; 58, 59; 59, identifier:orig_func; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:wrap_name; 63, attribute; 63, 64; 63, 70; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:meta_util_six; 67, identifier:get_funccode; 68, argument_list; 68, 69; 69, identifier:wrapper; 70, identifier:co_name; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:orig_name; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:meta_util_six; 77, identifier:get_funcname; 78, argument_list; 78, 79; 79, identifier:orig_func; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:_utinfo; 83, dictionary; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:_utinfo; 88, string:'orig_func'; 89, identifier:orig_func; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 95; 92, subscript; 92, 93; 92, 94; 93, identifier:_utinfo; 94, string:'wrap_name'; 95, identifier:wrap_name; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, subscript; 98, 99; 98, 100; 99, identifier:_utinfo; 100, string:'orig_name'; 101, identifier:orig_name; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:_utinfo; 106, string:'orig_argspec'; 107, identifier:orig_argspec; 108, if_statement; 108, 109; 108, 114; 109, call; 109, 110; 109, 111; 110, identifier:hasattr; 111, argument_list; 111, 112; 111, 113; 112, identifier:wrapper; 113, string:'_utinfo'; 114, block; 114, 115; 114, 121; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:parent_wrapper_utinfo; 118, attribute; 118, 119; 118, 120; 119, identifier:wrapper; 120, identifier:_utinfo; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 126; 123, subscript; 123, 124; 123, 125; 124, identifier:_utinfo; 125, string:'parent_wrapper_utinfo'; 126, identifier:parent_wrapper_utinfo; 127, if_statement; 127, 128; 127, 133; 128, call; 128, 129; 128, 130; 129, identifier:hasattr; 130, argument_list; 130, 131; 130, 132; 131, identifier:orig_func; 132, string:'_utinfo'; 133, block; 133, 134; 133, 140; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:parent_orig_utinfo; 137, attribute; 137, 138; 137, 139; 138, identifier:orig_func; 139, identifier:_utinfo; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:_utinfo; 144, string:'parent_orig_utinfo'; 145, identifier:parent_orig_utinfo; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:building_docs; 149, comparison_operator:==; 149, 150; 149, 159; 150, call; 150, 151; 150, 156; 151, attribute; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:os; 154, identifier:environ; 155, identifier:get; 156, argument_list; 156, 157; 156, 158; 157, string:'UTOOL_AUTOGEN_SPHINX_RUNNING'; 158, string:'OFF'; 159, string:'ON'; 160, if_statement; 160, 161; 160, 166; 160, 290; 161, boolean_operator:or; 161, 162; 161, 165; 162, boolean_operator:or; 162, 163; 162, 164; 163, identifier:force; 164, identifier:SIG_PRESERVE; 165, identifier:building_docs; 166, block; 166, 167; 166, 171; 166, 178; 166, 182; 166, 191; 166, 199; 166, 209; 166, 224; 166, 239; 166, 254; 166, 263; 166, 272; 166, 284; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:src_fmt; 170, string:r'''
def _wrp_preserve{defsig}:
try:
return wrapper{callsig}
except Exception as ex:
import utool as ut
msg = ('Failure in signature preserving wrapper:\n')
ut.printex(ex, msg)
raise
'''; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:globals_; 174, dictionary; 174, 175; 175, pair; 175, 176; 175, 177; 176, string:'wrapper'; 177, identifier:wrapper; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:locals_; 181, dictionary; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:argspec; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:inspect; 188, identifier:getargspec; 189, argument_list; 189, 190; 190, identifier:orig_func; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 198; 193, tuple_pattern; 193, 194; 193, 195; 193, 196; 193, 197; 194, identifier:args; 195, identifier:varargs; 196, identifier:varkw; 197, identifier:defaults; 198, identifier:argspec; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:defsig; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:inspect; 205, identifier:formatargspec; 206, argument_list; 206, 207; 207, list_splat; 207, 208; 208, identifier:argspec; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:callsig; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:inspect; 215, identifier:formatargspec; 216, argument_list; 216, 217; 217, list_splat; 217, 218; 218, subscript; 218, 219; 218, 220; 219, identifier:argspec; 220, slice; 220, 221; 220, 222; 220, 223; 221, integer:0; 222, colon; 223, integer:3; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:src_fmtdict; 227, call; 227, 228; 227, 229; 228, identifier:dict; 229, argument_list; 229, 230; 229, 233; 229, 236; 230, keyword_argument; 230, 231; 230, 232; 231, identifier:defsig; 232, identifier:defsig; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:callsig; 235, identifier:callsig; 236, keyword_argument; 236, 237; 236, 238; 237, identifier:orig_docstr; 238, identifier:orig_docstr; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:src; 242, call; 242, 243; 242, 251; 243, attribute; 243, 244; 243, 250; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:textwrap; 247, identifier:dedent; 248, argument_list; 248, 249; 249, identifier:src_fmt; 250, identifier:format; 251, argument_list; 251, 252; 252, dictionary_splat; 252, 253; 253, identifier:src_fmtdict; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:code; 257, call; 257, 258; 257, 259; 258, identifier:compile; 259, argument_list; 259, 260; 259, 261; 259, 262; 260, identifier:src; 261, string:'<string>'; 262, string:'exec'; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:six; 267, identifier:exec_; 268, argument_list; 268, 269; 268, 270; 268, 271; 269, identifier:code; 270, identifier:globals_; 271, identifier:locals_; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:_wrp_preserve; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:functools; 278, identifier:update_wrapper; 279, argument_list; 279, 280; 279, 283; 280, subscript; 280, 281; 280, 282; 281, identifier:locals_; 282, string:'_wrp_preserve'; 283, identifier:orig_func; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 289; 286, subscript; 286, 287; 286, 288; 287, identifier:_utinfo; 288, string:'src'; 289, identifier:src; 290, else_clause; 290, 291; 291, block; 291, 292; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:_wrp_preserve; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:functools; 298, identifier:update_wrapper; 299, argument_list; 299, 300; 299, 301; 300, identifier:wrapper; 301, identifier:orig_func; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 305; 304, identifier:DEBUG_WRAPPED_DOCSTRING; 305, False; 306, if_statement; 306, 307; 306, 308; 306, 318; 307, identifier:DEBUG_WRAPPED_DOCSTRING; 308, block; 308, 309; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 312; 311, identifier:new_docstr_fmtstr; 312, call; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:util_str; 315, identifier:codeblock; 316, argument_list; 316, 317; 317, string:'''
Wrapped function {wrap_name}({orig_name})
orig_argspec = {orig_argspec}
orig_docstr = {orig_docstr}
'''; 318, else_clause; 318, 319; 319, block; 319, 320; 320, expression_statement; 320, 321; 321, assignment; 321, 322; 321, 323; 322, identifier:new_docstr_fmtstr; 323, call; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:util_str; 326, identifier:codeblock; 327, argument_list; 327, 328; 328, string:'''
{orig_docstr}
'''; 329, expression_statement; 329, 330; 330, assignment; 330, 331; 330, 332; 331, identifier:new_docstr; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:new_docstr_fmtstr; 335, identifier:format; 336, argument_list; 336, 337; 336, 340; 336, 343; 336, 346; 337, keyword_argument; 337, 338; 337, 339; 338, identifier:wrap_name; 339, identifier:wrap_name; 340, keyword_argument; 340, 341; 340, 342; 341, identifier:orig_name; 342, identifier:orig_name; 343, keyword_argument; 343, 344; 343, 345; 344, identifier:orig_docstr; 345, identifier:orig_docstr; 346, keyword_argument; 346, 347; 346, 348; 347, identifier:orig_argspec; 348, identifier:orig_argspec; 349, expression_statement; 349, 350; 350, call; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:meta_util_six; 353, identifier:set_funcdoc; 354, argument_list; 354, 355; 354, 356; 355, identifier:_wrp_preserve; 356, identifier:new_docstr; 357, expression_statement; 357, 358; 358, assignment; 358, 359; 358, 362; 359, attribute; 359, 360; 359, 361; 360, identifier:_wrp_preserve; 361, identifier:_utinfo; 362, identifier:_utinfo; 363, return_statement; 363, 364; 364, identifier:_wrp_preserve | def preserve_sig(wrapper, orig_func, force=False):
from utool._internal import meta_util_six
from utool import util_str
from utool import util_inspect
if wrapper is orig_func:
return orig_func
orig_docstr = meta_util_six.get_funcdoc(orig_func)
orig_docstr = '' if orig_docstr is None else orig_docstr
orig_argspec = util_inspect.get_func_argspec(orig_func)
wrap_name = meta_util_six.get_funccode(wrapper).co_name
orig_name = meta_util_six.get_funcname(orig_func)
_utinfo = {}
_utinfo['orig_func'] = orig_func
_utinfo['wrap_name'] = wrap_name
_utinfo['orig_name'] = orig_name
_utinfo['orig_argspec'] = orig_argspec
if hasattr(wrapper, '_utinfo'):
parent_wrapper_utinfo = wrapper._utinfo
_utinfo['parent_wrapper_utinfo'] = parent_wrapper_utinfo
if hasattr(orig_func, '_utinfo'):
parent_orig_utinfo = orig_func._utinfo
_utinfo['parent_orig_utinfo'] = parent_orig_utinfo
building_docs = os.environ.get('UTOOL_AUTOGEN_SPHINX_RUNNING', 'OFF') == 'ON'
if force or SIG_PRESERVE or building_docs:
src_fmt = r'''
def _wrp_preserve{defsig}:
try:
return wrapper{callsig}
except Exception as ex:
import utool as ut
msg = ('Failure in signature preserving wrapper:\n')
ut.printex(ex, msg)
raise
'''
globals_ = {'wrapper': wrapper}
locals_ = {}
argspec = inspect.getargspec(orig_func)
(args, varargs, varkw, defaults) = argspec
defsig = inspect.formatargspec(*argspec)
callsig = inspect.formatargspec(*argspec[0:3])
src_fmtdict = dict(defsig=defsig, callsig=callsig, orig_docstr=orig_docstr)
src = textwrap.dedent(src_fmt).format(**src_fmtdict)
code = compile(src, '<string>', 'exec')
six.exec_(code, globals_, locals_)
_wrp_preserve = functools.update_wrapper(locals_['_wrp_preserve'], orig_func)
_utinfo['src'] = src
else:
_wrp_preserve = functools.update_wrapper(wrapper, orig_func)
DEBUG_WRAPPED_DOCSTRING = False
if DEBUG_WRAPPED_DOCSTRING:
new_docstr_fmtstr = util_str.codeblock(
'''
Wrapped function {wrap_name}({orig_name})
orig_argspec = {orig_argspec}
orig_docstr = {orig_docstr}
'''
)
else:
new_docstr_fmtstr = util_str.codeblock(
'''
{orig_docstr}
'''
)
new_docstr = new_docstr_fmtstr.format(
wrap_name=wrap_name, orig_name=orig_name, orig_docstr=orig_docstr,
orig_argspec=orig_argspec)
meta_util_six.set_funcdoc(_wrp_preserve, new_docstr)
_wrp_preserve._utinfo = _utinfo
return _wrp_preserve |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:parse_timestamp; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:timestamp; 5, default_parameter; 5, 6; 5, 7; 6, identifier:zone; 7, string:'UTC'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:timestamp_format; 10, None; 11, block; 11, 12; 11, 14; 11, 21; 11, 29; 11, 35; 11, 53; 11, 74; 11, 96; 11, 100; 11, 172; 11, 184; 11, 229; 11, 353; 12, expression_statement; 12, 13; 13, identifier:r; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:is; 15, 16; 15, 17; 16, identifier:timestamp; 17, None; 18, block; 18, 19; 19, return_statement; 19, 20; 20, None; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:use_delorean; 24, boolean_operator:or; 24, 25; 24, 26; 25, True; 26, attribute; 26, 27; 26, 28; 27, identifier:six; 28, identifier:PY2; 29, if_statement; 29, 30; 29, 31; 30, identifier:use_delorean; 31, block; 31, 32; 32, import_statement; 32, 33; 33, dotted_name; 33, 34; 34, identifier:delorean; 35, if_statement; 35, 36; 35, 44; 36, not_operator; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:isinstance; 39, argument_list; 39, 40; 39, 41; 40, identifier:timestamp; 41, attribute; 41, 42; 41, 43; 42, identifier:six; 43, identifier:string_types; 44, block; 44, 45; 45, raise_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:NotImplementedError; 48, argument_list; 48, 49; 49, binary_operator:%; 49, 50; 49, 51; 50, string:'Unknown format: timestamp=%r'; 51, tuple; 51, 52; 52, identifier:timestamp; 53, if_statement; 53, 54; 53, 57; 53, 68; 54, comparison_operator:is; 54, 55; 54, 56; 55, identifier:timestamp_format; 56, None; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:timefmt; 61, call; 61, 62; 61, 63; 62, identifier:determine_timestamp_format; 63, argument_list; 63, 64; 63, 65; 64, identifier:timestamp; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:warn; 67, False; 68, else_clause; 68, 69; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:timefmt; 73, identifier:timestamp_format; 74, if_statement; 74, 75; 74, 87; 75, boolean_operator:or; 75, 76; 75, 79; 76, comparison_operator:is; 76, 77; 76, 78; 77, identifier:timefmt; 78, None; 79, not_operator; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:isinstance; 82, argument_list; 82, 83; 82, 84; 83, identifier:timefmt; 84, attribute; 84, 85; 84, 86; 85, identifier:six; 86, identifier:string_types; 87, block; 87, 88; 88, raise_statement; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:AssertionError; 91, argument_list; 91, 92; 92, binary_operator:%; 92, 93; 92, 94; 93, string:'unknown timestamp_format=%r'; 94, tuple; 94, 95; 95, identifier:timestamp_format; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:utc_offset; 99, None; 100, if_statement; 100, 101; 100, 111; 100, 131; 100, 166; 101, boolean_operator:and; 101, 102; 101, 108; 102, comparison_operator:==; 102, 103; 102, 107; 103, call; 103, 104; 103, 105; 104, identifier:len; 105, argument_list; 105, 106; 106, identifier:timestamp; 107, integer:20; 108, comparison_operator:in; 108, 109; 108, 110; 109, string:'\x00'; 110, identifier:timestamp; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:timestamp_; 115, call; 115, 116; 115, 130; 116, attribute; 116, 117; 116, 129; 117, call; 117, 118; 117, 127; 118, attribute; 118, 119; 118, 126; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:timestamp; 122, identifier:replace; 123, argument_list; 123, 124; 123, 125; 124, string:'\x00'; 125, string:' '; 126, identifier:strip; 127, argument_list; 127, 128; 128, string:';'; 129, identifier:strip; 130, argument_list; 131, elif_clause; 131, 132; 131, 140; 132, boolean_operator:and; 132, 133; 132, 134; 133, identifier:use_delorean; 134, comparison_operator:>; 134, 135; 134, 139; 135, call; 135, 136; 135, 137; 136, identifier:len; 137, argument_list; 137, 138; 138, identifier:timestamp; 139, integer:19; 140, block; 140, 141; 140, 158; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:timestamp_; 144, call; 144, 145; 144, 157; 145, attribute; 145, 146; 145, 156; 146, call; 146, 147; 146, 154; 147, attribute; 147, 148; 147, 153; 148, subscript; 148, 149; 148, 150; 149, identifier:timestamp; 150, slice; 150, 151; 150, 152; 151, colon; 152, integer:19; 153, identifier:strip; 154, argument_list; 154, 155; 155, string:';'; 156, identifier:strip; 157, argument_list; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:utc_offset; 161, subscript; 161, 162; 161, 163; 162, identifier:timestamp; 163, slice; 163, 164; 163, 165; 164, integer:19; 165, colon; 166, else_clause; 166, 167; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:timestamp_; 171, identifier:timestamp; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:dt_; 175, call; 175, 176; 175, 181; 176, attribute; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:datetime; 179, identifier:datetime; 180, identifier:strptime; 181, argument_list; 181, 182; 181, 183; 182, identifier:timestamp_; 183, identifier:timefmt; 184, if_statement; 184, 185; 184, 186; 184, 223; 185, identifier:use_delorean; 186, block; 186, 187; 186, 200; 186, 213; 187, if_statement; 187, 188; 187, 191; 188, comparison_operator:is; 188, 189; 188, 190; 189, identifier:zone; 190, None; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:zone; 195, subscript; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:time; 198, identifier:tzname; 199, integer:0; 200, if_statement; 200, 201; 200, 204; 201, comparison_operator:==; 201, 202; 201, 203; 202, identifier:zone; 203, string:'local'; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:zone; 208, subscript; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:time; 211, identifier:tzname; 212, integer:0; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:dn_; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:delorean; 219, identifier:Delorean; 220, argument_list; 220, 221; 220, 222; 221, identifier:dt_; 222, identifier:zone; 223, else_clause; 223, 224; 224, block; 224, 225; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:dn_; 228, identifier:dt_; 229, if_statement; 229, 230; 229, 237; 229, 347; 230, boolean_operator:and; 230, 231; 230, 234; 231, comparison_operator:is; 231, 232; 231, 233; 232, identifier:utc_offset; 233, None; 234, comparison_operator:==; 234, 235; 234, 236; 235, identifier:zone; 236, string:'UTC'; 237, block; 237, 238; 238, if_statement; 238, 239; 238, 240; 238, 340; 239, identifier:use_delorean; 240, block; 240, 241; 240, 334; 241, if_statement; 241, 242; 241, 245; 241, 307; 242, comparison_operator:in; 242, 243; 242, 244; 243, string:':'; 244, identifier:utc_offset; 245, block; 245, 246; 245, 266; 245, 281; 245, 301; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:sign; 249, subscript; 249, 250; 249, 263; 250, dictionary; 250, 251; 250, 255; 250, 259; 251, pair; 251, 252; 251, 253; 252, string:' '; 253, unary_operator:+; 253, 254; 254, integer:1; 255, pair; 255, 256; 255, 257; 256, string:'+'; 257, unary_operator:+; 257, 258; 258, integer:1; 259, pair; 259, 260; 259, 261; 260, string:'-'; 261, unary_operator:-; 261, 262; 262, integer:1; 263, subscript; 263, 264; 263, 265; 264, identifier:utc_offset; 265, integer:0; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 271; 268, pattern_list; 268, 269; 268, 270; 269, identifier:hours; 270, identifier:seconds; 271, call; 271, 272; 271, 279; 272, attribute; 272, 273; 272, 278; 273, subscript; 273, 274; 273, 275; 274, identifier:utc_offset; 275, slice; 275, 276; 275, 277; 276, integer:1; 277, colon; 278, identifier:split; 279, argument_list; 279, 280; 280, string:':'; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:delta_; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:datetime; 287, identifier:timedelta; 288, argument_list; 288, 289; 288, 295; 289, keyword_argument; 289, 290; 289, 291; 290, identifier:hours; 291, call; 291, 292; 291, 293; 292, identifier:int; 293, argument_list; 293, 294; 294, identifier:hours; 295, keyword_argument; 295, 296; 295, 297; 296, identifier:seconds; 297, call; 297, 298; 297, 299; 298, identifier:int; 299, argument_list; 299, 300; 300, identifier:seconds; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:delta; 304, binary_operator:*; 304, 305; 304, 306; 305, identifier:sign; 306, identifier:delta_; 307, else_clause; 307, 308; 308, block; 308, 309; 308, 312; 308, 320; 309, import_statement; 309, 310; 310, dotted_name; 310, 311; 311, identifier:pytz; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 315; 314, identifier:tzname; 315, call; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:utc_offset; 318, identifier:strip; 319, argument_list; 320, expression_statement; 320, 321; 321, assignment; 321, 322; 321, 323; 322, identifier:delta; 323, call; 323, 324; 323, 332; 324, attribute; 324, 325; 324, 331; 325, call; 325, 326; 325, 329; 326, attribute; 326, 327; 326, 328; 327, identifier:pytz; 328, identifier:timezone; 329, argument_list; 329, 330; 330, identifier:tzname; 331, identifier:utcoffset; 332, argument_list; 332, 333; 333, identifier:dt_; 334, expression_statement; 334, 335; 335, assignment; 335, 336; 335, 337; 336, identifier:dn; 337, binary_operator:-; 337, 338; 337, 339; 338, identifier:dn_; 339, identifier:delta; 340, else_clause; 340, 341; 341, block; 341, 342; 342, raise_statement; 342, 343; 343, call; 343, 344; 343, 345; 344, identifier:AssertionError; 345, argument_list; 345, 346; 346, string:'python3 should take care of timezone'; 347, else_clause; 347, 348; 348, block; 348, 349; 349, expression_statement; 349, 350; 350, assignment; 350, 351; 350, 352; 351, identifier:dn; 352, identifier:dn_; 353, if_statement; 353, 354; 353, 355; 354, identifier:use_delorean; 355, block; 355, 356; 355, 369; 356, if_statement; 356, 357; 356, 361; 357, not_operator; 357, 358; 358, comparison_operator:!=; 358, 359; 358, 360; 359, identifier:zone; 360, string:'UTC'; 361, block; 361, 362; 362, expression_statement; 362, 363; 363, call; 363, 364; 363, 367; 364, attribute; 364, 365; 364, 366; 365, identifier:dn; 366, identifier:shift; 367, argument_list; 367, 368; 368, identifier:zone; 369, return_statement; 369, 370; 370, attribute; 370, 371; 370, 372; 371, identifier:dn; 372, identifier:datetime | def parse_timestamp(timestamp, zone='UTC', timestamp_format=None):
r
if timestamp is None:
return None
use_delorean = True or six.PY2
if use_delorean:
import delorean
if not isinstance(timestamp, six.string_types):
raise NotImplementedError('Unknown format: timestamp=%r' % (timestamp,))
if timestamp_format is None:
timefmt = determine_timestamp_format(timestamp, warn=False)
else:
timefmt = timestamp_format
if timefmt is None or not isinstance(timefmt, six.string_types):
raise AssertionError('unknown timestamp_format=%r' % (timestamp_format,))
utc_offset = None
if len(timestamp) == 20 and '\x00' in timestamp:
timestamp_ = timestamp.replace('\x00', ' ').strip(';').strip()
elif use_delorean and len(timestamp) > 19:
timestamp_ = timestamp[:19].strip(';').strip()
utc_offset = timestamp[19:]
else:
timestamp_ = timestamp
dt_ = datetime.datetime.strptime(timestamp_, timefmt)
if use_delorean:
if zone is None:
zone = time.tzname[0]
if zone == 'local':
zone = time.tzname[0]
dn_ = delorean.Delorean(dt_, zone)
else:
dn_ = dt_
if utc_offset is not None and zone == 'UTC':
if use_delorean:
if ':' in utc_offset:
sign = {' ': +1, '+': +1, '-': -1}[utc_offset[0]]
hours, seconds = utc_offset[1:].split(':')
delta_ = datetime.timedelta(hours=int(hours), seconds=int(seconds))
delta = sign * delta_
else:
import pytz
tzname = utc_offset.strip()
delta = pytz.timezone(tzname).utcoffset(dt_)
dn = dn_ - delta
else:
raise AssertionError('python3 should take care of timezone')
else:
dn = dn_
if use_delorean:
if not zone != 'UTC':
dn.shift(zone)
return dn.datetime |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:load_cache; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 4, identifier:dpath; 5, identifier:fname; 6, identifier:cfgstr; 7, default_parameter; 7, 8; 7, 9; 8, identifier:ext; 9, string:'.cPkl'; 10, default_parameter; 10, 11; 10, 12; 11, identifier:verbose; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:enabled; 15, True; 16, block; 16, 17; 16, 26; 16, 56; 16, 66; 16, 165; 16, 264; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:verbose; 20, None; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:verbose; 25, identifier:VERBOSE_CACHE; 26, if_statement; 26, 27; 26, 32; 27, boolean_operator:or; 27, 28; 27, 30; 28, not_operator; 28, 29; 29, identifier:USE_CACHE; 30, not_operator; 30, 31; 31, identifier:enabled; 32, block; 32, 33; 32, 50; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:>; 34, 35; 34, 36; 35, identifier:verbose; 36, integer:1; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:print; 41, argument_list; 41, 42; 42, binary_operator:%; 42, 43; 42, 44; 43, string:'[util_cache] ... cache disabled: dpath=%s cfgstr=%r'; 44, tuple; 44, 45; 44, 49; 45, call; 45, 46; 45, 47; 46, identifier:basename; 47, argument_list; 47, 48; 48, identifier:dpath; 49, identifier:cfgstr; 50, raise_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:IOError; 53, argument_list; 53, 54; 53, 55; 54, integer:3; 55, string:'Cache Loading Is Disabled'; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:fpath; 59, call; 59, 60; 59, 61; 60, identifier:_args2_fpath; 61, argument_list; 61, 62; 61, 63; 61, 64; 61, 65; 62, identifier:dpath; 63, identifier:fname; 64, identifier:cfgstr; 65, identifier:ext; 66, if_statement; 66, 67; 66, 72; 66, 100; 67, not_operator; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:exists; 70, argument_list; 70, 71; 71, identifier:fpath; 72, block; 72, 73; 72, 91; 73, if_statement; 73, 74; 73, 77; 74, comparison_operator:>; 74, 75; 74, 76; 75, identifier:verbose; 76, integer:0; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:print; 81, argument_list; 81, 82; 82, binary_operator:%; 82, 83; 82, 84; 83, string:'[util_cache] ... cache does not exist: dpath=%r fname=%r cfgstr=%r'; 84, tuple; 84, 85; 84, 89; 84, 90; 85, call; 85, 86; 85, 87; 86, identifier:basename; 87, argument_list; 87, 88; 88, identifier:dpath; 89, identifier:fname; 90, identifier:cfgstr; 91, raise_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:IOError; 94, argument_list; 94, 95; 94, 96; 95, integer:2; 96, binary_operator:%; 96, 97; 96, 98; 97, string:'No such file or directory: %r'; 98, tuple; 98, 99; 99, identifier:fpath; 100, else_clause; 100, 101; 101, block; 101, 102; 101, 120; 101, 125; 101, 134; 101, 149; 102, if_statement; 102, 103; 102, 106; 103, comparison_operator:>; 103, 104; 103, 105; 104, identifier:verbose; 105, integer:2; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:print; 110, argument_list; 110, 111; 111, binary_operator:%; 111, 112; 111, 113; 112, string:'[util_cache] ... cache exists: dpath=%r fname=%r cfgstr=%r'; 113, tuple; 113, 114; 113, 118; 113, 119; 114, call; 114, 115; 114, 116; 115, identifier:basename; 116, argument_list; 116, 117; 117, identifier:dpath; 118, identifier:fname; 119, identifier:cfgstr; 120, import_statement; 120, 121; 121, aliased_import; 121, 122; 121, 124; 122, dotted_name; 122, 123; 123, identifier:utool; 124, identifier:ut; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:nbytes; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:ut; 131, identifier:get_file_nBytes; 132, argument_list; 132, 133; 133, identifier:fpath; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:big_verbose; 137, boolean_operator:or; 137, 138; 137, 146; 138, parenthesized_expression; 138, 139; 139, boolean_operator:and; 139, 140; 139, 143; 140, comparison_operator:>; 140, 141; 140, 142; 141, identifier:nbytes; 142, float:1E6; 143, comparison_operator:>; 143, 144; 143, 145; 144, identifier:verbose; 145, integer:2; 146, comparison_operator:>; 146, 147; 146, 148; 147, identifier:verbose; 148, integer:2; 149, if_statement; 149, 150; 149, 151; 150, identifier:big_verbose; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 155; 154, identifier:print; 155, argument_list; 155, 156; 156, binary_operator:%; 156, 157; 156, 158; 157, string:'[util_cache] About to read file of size %s'; 158, tuple; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:ut; 162, identifier:byte_str2; 163, argument_list; 163, 164; 164, identifier:nbytes; 165, try_statement; 165, 166; 165, 198; 165, 240; 165, 252; 166, block; 166, 167; 167, with_statement; 167, 168; 167, 183; 168, with_clause; 168, 169; 169, with_item; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:ut; 173, identifier:Timer; 174, argument_list; 174, 175; 174, 176; 175, identifier:fpath; 176, keyword_argument; 176, 177; 176, 178; 177, identifier:verbose; 178, boolean_operator:and; 178, 179; 178, 180; 179, identifier:big_verbose; 180, comparison_operator:>; 180, 181; 180, 182; 181, identifier:verbose; 182, integer:3; 183, block; 183, 184; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:data; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:util_io; 190, identifier:load_data; 191, argument_list; 191, 192; 191, 193; 192, identifier:fpath; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:verbose; 195, comparison_operator:>; 195, 196; 195, 197; 196, identifier:verbose; 197, integer:2; 198, except_clause; 198, 199; 198, 206; 199, as_pattern; 199, 200; 199, 204; 200, tuple; 200, 201; 200, 202; 200, 203; 201, identifier:EOFError; 202, identifier:IOError; 203, identifier:ImportError; 204, as_pattern_target; 204, 205; 205, identifier:ex; 206, block; 206, 207; 206, 215; 206, 232; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 210; 209, identifier:print; 210, argument_list; 210, 211; 211, binary_operator:%; 211, 212; 211, 213; 212, string:'CORRUPTED? fpath = %s'; 213, tuple; 213, 214; 214, identifier:fpath; 215, if_statement; 215, 216; 215, 219; 216, comparison_operator:>; 216, 217; 216, 218; 217, identifier:verbose; 218, integer:1; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 223; 222, identifier:print; 223, argument_list; 223, 224; 224, binary_operator:%; 224, 225; 224, 226; 225, string:'[util_cache] ... cache miss dpath=%s cfgstr=%r'; 226, tuple; 226, 227; 226, 231; 227, call; 227, 228; 227, 229; 228, identifier:basename; 229, argument_list; 229, 230; 230, identifier:dpath; 231, identifier:cfgstr; 232, raise_statement; 232, 233; 233, call; 233, 234; 233, 235; 234, identifier:IOError; 235, argument_list; 235, 236; 236, call; 236, 237; 236, 238; 237, identifier:str; 238, argument_list; 238, 239; 239, identifier:ex; 240, except_clause; 240, 241; 240, 242; 241, identifier:Exception; 242, block; 242, 243; 242, 251; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 246; 245, identifier:print; 246, argument_list; 246, 247; 247, binary_operator:%; 247, 248; 247, 249; 248, string:'CORRUPTED? fpath = %s'; 249, tuple; 249, 250; 250, identifier:fpath; 251, raise_statement; 252, else_clause; 252, 253; 253, block; 253, 254; 254, if_statement; 254, 255; 254, 258; 255, comparison_operator:>; 255, 256; 255, 257; 256, identifier:verbose; 257, integer:2; 258, block; 258, 259; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 262; 261, identifier:print; 262, argument_list; 262, 263; 263, string:'[util_cache] ... cache hit'; 264, return_statement; 264, 265; 265, identifier:data | def load_cache(dpath, fname, cfgstr, ext='.cPkl', verbose=None, enabled=True):
if verbose is None:
verbose = VERBOSE_CACHE
if not USE_CACHE or not enabled:
if verbose > 1:
print('[util_cache] ... cache disabled: dpath=%s cfgstr=%r' %
(basename(dpath), cfgstr,))
raise IOError(3, 'Cache Loading Is Disabled')
fpath = _args2_fpath(dpath, fname, cfgstr, ext)
if not exists(fpath):
if verbose > 0:
print('[util_cache] ... cache does not exist: dpath=%r fname=%r cfgstr=%r' % (
basename(dpath), fname, cfgstr,))
raise IOError(2, 'No such file or directory: %r' % (fpath,))
else:
if verbose > 2:
print('[util_cache] ... cache exists: dpath=%r fname=%r cfgstr=%r' % (
basename(dpath), fname, cfgstr,))
import utool as ut
nbytes = ut.get_file_nBytes(fpath)
big_verbose = (nbytes > 1E6 and verbose > 2) or verbose > 2
if big_verbose:
print('[util_cache] About to read file of size %s' % (ut.byte_str2(nbytes),))
try:
with ut.Timer(fpath, verbose=big_verbose and verbose > 3):
data = util_io.load_data(fpath, verbose=verbose > 2)
except (EOFError, IOError, ImportError) as ex:
print('CORRUPTED? fpath = %s' % (fpath,))
if verbose > 1:
print('[util_cache] ... cache miss dpath=%s cfgstr=%r' % (
basename(dpath), cfgstr,))
raise IOError(str(ex))
except Exception:
print('CORRUPTED? fpath = %s' % (fpath,))
raise
else:
if verbose > 2:
print('[util_cache] ... cache hit')
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 25; 2, function_name:cached_func; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 4, default_parameter; 4, 5; 4, 6; 5, identifier:fname; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:cache_dir; 9, string:'default'; 10, default_parameter; 10, 11; 10, 12; 11, identifier:appname; 12, string:'utool'; 13, default_parameter; 13, 14; 13, 15; 14, identifier:key_argx; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:key_kwds; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:use_cache; 21, None; 22, default_parameter; 22, 23; 22, 24; 23, identifier:verbose; 24, None; 25, block; 25, 26; 25, 28; 25, 37; 25, 325; 26, expression_statement; 26, 27; 27, identifier:r; 28, if_statement; 28, 29; 28, 32; 29, comparison_operator:is; 29, 30; 29, 31; 30, identifier:verbose; 31, None; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:verbose; 36, identifier:VERBOSE_CACHE; 37, function_definition; 37, 38; 37, 39; 37, 41; 38, function_name:cached_closure; 39, parameters; 39, 40; 40, identifier:func; 41, block; 41, 42; 41, 47; 41, 52; 41, 66; 41, 75; 41, 84; 41, 100; 41, 116; 41, 139; 41, 307; 41, 317; 41, 323; 42, import_from_statement; 42, 43; 42, 45; 43, dotted_name; 43, 44; 44, identifier:utool; 45, dotted_name; 45, 46; 46, identifier:util_decor; 47, import_statement; 47, 48; 48, aliased_import; 48, 49; 48, 51; 49, dotted_name; 49, 50; 50, identifier:utool; 51, identifier:ut; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:fname_; 55, conditional_expression:if; 55, 56; 55, 62; 55, 65; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:util_inspect; 59, identifier:get_funcname; 60, argument_list; 60, 61; 61, identifier:func; 62, comparison_operator:is; 62, 63; 62, 64; 63, identifier:fname; 64, None; 65, identifier:fname; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:kwdefaults; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:util_inspect; 72, identifier:get_kwdefaults; 73, argument_list; 73, 74; 74, identifier:func; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:argnames; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:util_inspect; 81, identifier:get_argnames; 82, argument_list; 82, 83; 83, identifier:func; 84, if_statement; 84, 85; 84, 91; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:ut; 88, identifier:is_method; 89, argument_list; 89, 90; 90, identifier:func; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:argnames; 95, subscript; 95, 96; 95, 97; 96, identifier:argnames; 97, slice; 97, 98; 97, 99; 98, integer:1; 99, colon; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:cacher; 103, call; 103, 104; 103, 105; 104, identifier:Cacher; 105, argument_list; 105, 106; 105, 107; 105, 110; 105, 113; 106, identifier:fname_; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:cache_dir; 109, identifier:cache_dir; 110, keyword_argument; 110, 111; 110, 112; 111, identifier:appname; 112, identifier:appname; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:verbose; 115, identifier:verbose; 116, if_statement; 116, 117; 116, 120; 116, 133; 117, comparison_operator:is; 117, 118; 117, 119; 118, identifier:use_cache; 119, None; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:use_cache_; 124, not_operator; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:util_arg; 128, identifier:get_argflag; 129, argument_list; 129, 130; 130, binary_operator:+; 130, 131; 130, 132; 131, string:'--nocache-'; 132, identifier:fname_; 133, else_clause; 133, 134; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:use_cache_; 138, identifier:use_cache; 139, function_definition; 139, 140; 139, 141; 139, 146; 140, function_name:cached_wraper; 141, parameters; 141, 142; 141, 144; 142, list_splat_pattern; 142, 143; 143, identifier:args; 144, dictionary_splat_pattern; 144, 145; 145, identifier:kwargs; 146, block; 146, 147; 147, try_statement; 147, 148; 147, 248; 148, block; 148, 149; 148, 162; 148, 175; 148, 191; 148, 199; 148, 209; 148, 228; 148, 238; 148, 246; 149, if_statement; 149, 150; 149, 153; 150, comparison_operator:>; 150, 151; 150, 152; 151, identifier:verbose; 152, integer:2; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, call; 155, 156; 155, 157; 156, identifier:print; 157, argument_list; 157, 158; 158, binary_operator:%; 158, 159; 158, 160; 159, string:'[util_cache] computing cached function fname_=%s'; 160, tuple; 160, 161; 161, identifier:fname_; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:cfgstr; 165, call; 165, 166; 165, 167; 166, identifier:get_cfgstr_from_args; 167, argument_list; 167, 168; 167, 169; 167, 170; 167, 171; 167, 172; 167, 173; 167, 174; 168, identifier:func; 169, identifier:args; 170, identifier:kwargs; 171, identifier:key_argx; 172, identifier:key_kwds; 173, identifier:kwdefaults; 174, identifier:argnames; 175, if_statement; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:util_cplat; 178, identifier:WIN32; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:cfgstr; 183, binary_operator:+; 183, 184; 183, 185; 184, string:'_'; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:util_hash; 188, identifier:hashstr27; 189, argument_list; 189, 190; 190, identifier:cfgstr; 191, assert_statement; 191, 192; 191, 195; 192, comparison_operator:is; 192, 193; 192, 194; 193, identifier:cfgstr; 194, None; 195, binary_operator:%; 195, 196; 195, 197; 196, string:'cfgstr=%r cannot be None'; 197, tuple; 197, 198; 198, identifier:cfgstr; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:use_cache__; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:kwargs; 205, identifier:pop; 206, argument_list; 206, 207; 206, 208; 207, string:'use_cache'; 208, identifier:use_cache_; 209, if_statement; 209, 210; 209, 211; 210, identifier:use_cache__; 211, block; 211, 212; 211, 221; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:data; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:cacher; 218, identifier:tryload; 219, argument_list; 219, 220; 220, identifier:cfgstr; 221, if_statement; 221, 222; 221, 225; 222, comparison_operator:is; 222, 223; 222, 224; 223, identifier:data; 224, None; 225, block; 225, 226; 226, return_statement; 226, 227; 227, identifier:data; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:data; 231, call; 231, 232; 231, 233; 232, identifier:func; 233, argument_list; 233, 234; 233, 236; 234, list_splat; 234, 235; 235, identifier:args; 236, dictionary_splat; 236, 237; 237, identifier:kwargs; 238, expression_statement; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:cacher; 242, identifier:save; 243, argument_list; 243, 244; 243, 245; 244, identifier:data; 245, identifier:cfgstr; 246, return_statement; 246, 247; 247, identifier:data; 248, except_clause; 248, 249; 248, 253; 249, as_pattern; 249, 250; 249, 251; 250, identifier:Exception; 251, as_pattern_target; 251, 252; 252, identifier:ex; 253, block; 253, 254; 253, 259; 253, 280; 253, 298; 253, 306; 254, import_from_statement; 254, 255; 254, 257; 255, dotted_name; 255, 256; 256, identifier:utool; 257, dotted_name; 257, 258; 258, identifier:util_dbg; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:_dbgdict2; 262, call; 262, 263; 262, 264; 263, identifier:dict; 264, argument_list; 264, 265; 264, 268; 264, 274; 265, keyword_argument; 265, 266; 265, 267; 266, identifier:key_argx; 267, identifier:key_argx; 268, keyword_argument; 268, 269; 268, 270; 269, identifier:lenargs; 270, call; 270, 271; 270, 272; 271, identifier:len; 272, argument_list; 272, 273; 273, identifier:args; 274, keyword_argument; 274, 275; 274, 276; 275, identifier:lenkw; 276, call; 276, 277; 276, 278; 277, identifier:len; 278, argument_list; 278, 279; 279, identifier:kwargs; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 283; 282, identifier:msg; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, string:'\n'; 286, identifier:join; 287, argument_list; 287, 288; 288, list:[
'+--- UTOOL --- ERROR IN CACHED FUNCTION',
'dbgdict2 = ' + util_str.repr4(_dbgdict2),
]; 288, 289; 288, 290; 289, string:'+--- UTOOL --- ERROR IN CACHED FUNCTION'; 290, binary_operator:+; 290, 291; 290, 292; 291, string:'dbgdict2 = '; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:util_str; 295, identifier:repr4; 296, argument_list; 296, 297; 297, identifier:_dbgdict2; 298, expression_statement; 298, 299; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:util_dbg; 302, identifier:printex; 303, argument_list; 303, 304; 303, 305; 304, identifier:ex; 305, identifier:msg; 306, raise_statement; 307, expression_statement; 307, 308; 308, assignment; 308, 309; 308, 310; 309, identifier:cached_wraper; 310, call; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:util_decor; 313, identifier:preserve_sig; 314, argument_list; 314, 315; 314, 316; 315, identifier:cached_wraper; 316, identifier:func; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:cached_wraper; 321, identifier:cacher; 322, identifier:cacher; 323, return_statement; 323, 324; 324, identifier:cached_wraper; 325, return_statement; 325, 326; 326, identifier:cached_closure | def cached_func(fname=None, cache_dir='default', appname='utool', key_argx=None,
key_kwds=None, use_cache=None, verbose=None):
r
if verbose is None:
verbose = VERBOSE_CACHE
def cached_closure(func):
from utool import util_decor
import utool as ut
fname_ = util_inspect.get_funcname(func) if fname is None else fname
kwdefaults = util_inspect.get_kwdefaults(func)
argnames = util_inspect.get_argnames(func)
if ut.is_method(func):
argnames = argnames[1:]
cacher = Cacher(fname_, cache_dir=cache_dir, appname=appname,
verbose=verbose)
if use_cache is None:
use_cache_ = not util_arg.get_argflag('--nocache-' + fname_)
else:
use_cache_ = use_cache
def cached_wraper(*args, **kwargs):
try:
if verbose > 2:
print('[util_cache] computing cached function fname_=%s' %
( fname_,))
cfgstr = get_cfgstr_from_args(func, args, kwargs, key_argx,
key_kwds, kwdefaults, argnames)
if util_cplat.WIN32:
cfgstr = '_' + util_hash.hashstr27(cfgstr)
assert cfgstr is not None, 'cfgstr=%r cannot be None' % (cfgstr,)
use_cache__ = kwargs.pop('use_cache', use_cache_)
if use_cache__:
data = cacher.tryload(cfgstr)
if data is not None:
return data
data = func(*args, **kwargs)
cacher.save(data, cfgstr)
return data
except Exception as ex:
from utool import util_dbg
_dbgdict2 = dict(key_argx=key_argx, lenargs=len(args),
lenkw=len(kwargs),)
msg = '\n'.join([
'+--- UTOOL --- ERROR IN CACHED FUNCTION',
'dbgdict2 = ' + util_str.repr4(_dbgdict2),
])
util_dbg.printex(ex, msg)
raise
cached_wraper = util_decor.preserve_sig(cached_wraper, func)
cached_wraper.cacher = cacher
return cached_wraper
return cached_closure |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:path_ndir_split; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:path_; 5, identifier:n; 6, default_parameter; 6, 7; 6, 8; 7, identifier:force_unix; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:winroot; 11, string:'C:'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:trailing; 14, True; 15, block; 15, 16; 15, 18; 15, 30; 15, 213; 16, expression_statement; 16, 17; 17, identifier:r; 18, if_statement; 18, 19; 18, 27; 19, not_operator; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:isinstance; 22, argument_list; 22, 23; 22, 24; 23, identifier:path_; 24, attribute; 24, 25; 24, 26; 25, identifier:six; 26, identifier:string_types; 27, block; 27, 28; 28, return_statement; 28, 29; 29, identifier:path_; 30, if_statement; 30, 31; 30, 34; 30, 42; 30, 51; 31, comparison_operator:is; 31, 32; 31, 33; 32, identifier:n; 33, None; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:cplat_path; 38, call; 38, 39; 38, 40; 39, identifier:ensure_crossplat_path; 40, argument_list; 40, 41; 41, identifier:path_; 42, elif_clause; 42, 43; 42, 46; 43, comparison_operator:==; 43, 44; 43, 45; 44, identifier:n; 45, integer:0; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:cplat_path; 50, string:''; 51, else_clause; 51, 52; 52, block; 52, 53; 52, 62; 52, 66; 52, 70; 52, 74; 52, 144; 52, 179; 52, 194; 52, 201; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:sep; 56, conditional_expression:if; 56, 57; 56, 58; 56, 59; 57, string:'/'; 58, identifier:force_unix; 59, attribute; 59, 60; 59, 61; 60, identifier:os; 61, identifier:sep; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:ndirs_list; 65, list:[]; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:head; 69, identifier:path_; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:reached_end; 73, False; 74, for_statement; 74, 75; 74, 76; 74, 80; 75, identifier:nx; 76, call; 76, 77; 76, 78; 77, identifier:range; 78, argument_list; 78, 79; 79, identifier:n; 80, block; 80, 81; 80, 90; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 86; 83, pattern_list; 83, 84; 83, 85; 84, identifier:head; 85, identifier:tail; 86, call; 86, 87; 86, 88; 87, identifier:split; 88, argument_list; 88, 89; 89, identifier:head; 90, if_statement; 90, 91; 90, 94; 90, 135; 91, comparison_operator:==; 91, 92; 91, 93; 92, identifier:tail; 93, string:''; 94, block; 94, 95; 94, 134; 95, if_statement; 95, 96; 95, 99; 95, 104; 96, comparison_operator:==; 96, 97; 96, 98; 97, identifier:head; 98, string:''; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:reached_end; 103, True; 104, else_clause; 104, 105; 105, block; 105, 106; 105, 123; 105, 130; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:root; 109, conditional_expression:if; 109, 110; 109, 111; 109, 117; 110, identifier:head; 111, comparison_operator:==; 111, 112; 111, 116; 112, call; 112, 113; 112, 114; 113, identifier:len; 114, argument_list; 114, 115; 115, identifier:ndirs_list; 116, integer:0; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:head; 120, identifier:strip; 121, argument_list; 121, 122; 122, string:'\\/'; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:ndirs_list; 127, identifier:append; 128, argument_list; 128, 129; 129, identifier:root; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:reached_end; 133, True; 134, break_statement; 135, else_clause; 135, 136; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:ndirs_list; 141, identifier:append; 142, argument_list; 142, 143; 143, identifier:tail; 144, if_statement; 144, 145; 144, 149; 145, boolean_operator:and; 145, 146; 145, 147; 146, identifier:trailing; 147, not_operator; 147, 148; 148, identifier:reached_end; 149, block; 149, 150; 149, 159; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 155; 152, pattern_list; 152, 153; 152, 154; 153, identifier:head; 154, identifier:tail; 155, call; 155, 156; 155, 157; 156, identifier:split; 157, argument_list; 157, 158; 158, identifier:head; 159, if_statement; 159, 160; 159, 166; 160, comparison_operator:==; 160, 161; 160, 165; 161, call; 161, 162; 161, 163; 162, identifier:len; 163, argument_list; 163, 164; 164, identifier:tail; 165, integer:0; 166, block; 166, 167; 167, if_statement; 167, 168; 167, 174; 168, comparison_operator:==; 168, 169; 168, 173; 169, call; 169, 170; 169, 171; 170, identifier:len; 171, argument_list; 171, 172; 172, identifier:head; 173, integer:0; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:reached_end; 178, True; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:ndirs; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:sep; 185, identifier:join; 186, argument_list; 186, 187; 187, subscript; 187, 188; 187, 189; 188, identifier:ndirs_list; 189, slice; 189, 190; 189, 191; 189, 192; 190, colon; 191, colon; 192, unary_operator:-; 192, 193; 193, integer:1; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:cplat_path; 197, call; 197, 198; 197, 199; 198, identifier:ensure_crossplat_path; 199, argument_list; 199, 200; 200, identifier:ndirs; 201, if_statement; 201, 202; 201, 206; 202, boolean_operator:and; 202, 203; 202, 204; 203, identifier:trailing; 204, not_operator; 204, 205; 205, identifier:reached_end; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:cplat_path; 210, binary_operator:+; 210, 211; 210, 212; 211, string:'.../'; 212, identifier:cplat_path; 213, return_statement; 213, 214; 214, identifier:cplat_path | def path_ndir_split(path_, n, force_unix=True, winroot='C:', trailing=True):
r
if not isinstance(path_, six.string_types):
return path_
if n is None:
cplat_path = ensure_crossplat_path(path_)
elif n == 0:
cplat_path = ''
else:
sep = '/' if force_unix else os.sep
ndirs_list = []
head = path_
reached_end = False
for nx in range(n):
head, tail = split(head)
if tail == '':
if head == '':
reached_end = True
else:
root = head if len(ndirs_list) == 0 else head.strip('\\/')
ndirs_list.append(root)
reached_end = True
break
else:
ndirs_list.append(tail)
if trailing and not reached_end:
head, tail = split(head)
if len(tail) == 0:
if len(head) == 0:
reached_end = True
ndirs = sep.join(ndirs_list[::-1])
cplat_path = ensure_crossplat_path(ndirs)
if trailing and not reached_end:
cplat_path = '.../' + cplat_path
return cplat_path |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:remove_files_in_dir; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:dpath; 5, default_parameter; 5, 6; 5, 7; 6, identifier:fname_pattern_list; 7, string:'*'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:recursive; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:verbose; 13, identifier:VERBOSE; 14, default_parameter; 14, 15; 14, 16; 15, identifier:dryrun; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:ignore_errors; 19, False; 20, block; 20, 21; 20, 35; 20, 66; 20, 74; 20, 106; 20, 163; 20, 177; 21, if_statement; 21, 22; 21, 29; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 26; 25, identifier:fname_pattern_list; 26, attribute; 26, 27; 26, 28; 27, identifier:six; 28, identifier:string_types; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:fname_pattern_list; 33, list:[fname_pattern_list]; 33, 34; 34, identifier:fname_pattern_list; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:>; 36, 37; 36, 38; 37, identifier:verbose; 38, integer:2; 39, block; 39, 40; 39, 45; 39, 52; 39, 59; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:print; 43, argument_list; 43, 44; 44, string:'[util_path] Removing files:'; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:print; 48, argument_list; 48, 49; 49, binary_operator:%; 49, 50; 49, 51; 50, string:' * from dpath = %r '; 51, identifier:dpath; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:print; 55, argument_list; 55, 56; 56, binary_operator:%; 56, 57; 56, 58; 57, string:' * with patterns = %r'; 58, identifier:fname_pattern_list; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:print; 62, argument_list; 62, 63; 63, binary_operator:%; 63, 64; 63, 65; 64, string:' * recursive = %r'; 65, identifier:recursive; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 71; 68, pattern_list; 68, 69; 68, 70; 69, identifier:num_removed; 70, identifier:num_matched; 71, tuple; 71, 72; 71, 73; 72, integer:0; 73, integer:0; 74, if_statement; 74, 75; 74, 80; 75, not_operator; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:exists; 78, argument_list; 78, 79; 79, identifier:dpath; 80, block; 80, 81; 80, 88; 80, 96; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:msg; 84, parenthesized_expression; 84, 85; 85, binary_operator:%; 85, 86; 85, 87; 86, string:'!!! dir = %r does not exist!'; 87, identifier:dpath; 88, if_statement; 88, 89; 88, 90; 89, identifier:verbose; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:print; 94, argument_list; 94, 95; 95, identifier:msg; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:warnings; 100, identifier:warn; 101, argument_list; 101, 102; 101, 103; 102, identifier:msg; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:category; 105, identifier:UserWarning; 106, for_statement; 106, 107; 106, 111; 106, 117; 107, pattern_list; 107, 108; 107, 109; 107, 110; 108, identifier:root; 109, identifier:dname_list; 110, identifier:fname_list; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:os; 114, identifier:walk; 115, argument_list; 115, 116; 116, identifier:dpath; 117, block; 117, 118; 117, 158; 118, for_statement; 118, 119; 118, 120; 118, 121; 119, identifier:fname_pattern; 120, identifier:fname_pattern_list; 121, block; 121, 122; 122, for_statement; 122, 123; 122, 124; 122, 131; 123, identifier:fname; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:fnmatch; 127, identifier:filter; 128, argument_list; 128, 129; 128, 130; 129, identifier:fname_list; 130, identifier:fname_pattern; 131, block; 131, 132; 131, 136; 132, expression_statement; 132, 133; 133, augmented_assignment:+=; 133, 134; 133, 135; 134, identifier:num_matched; 135, integer:1; 136, expression_statement; 136, 137; 137, augmented_assignment:+=; 137, 138; 137, 139; 138, identifier:num_removed; 139, call; 139, 140; 139, 141; 140, identifier:remove_file; 141, argument_list; 141, 142; 141, 147; 141, 150; 141, 153; 142, call; 142, 143; 142, 144; 143, identifier:join; 144, argument_list; 144, 145; 144, 146; 145, identifier:root; 146, identifier:fname; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:ignore_errors; 149, identifier:ignore_errors; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:dryrun; 152, identifier:dryrun; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:verbose; 155, comparison_operator:>; 155, 156; 155, 157; 156, identifier:verbose; 157, integer:5; 158, if_statement; 158, 159; 158, 161; 159, not_operator; 159, 160; 160, identifier:recursive; 161, block; 161, 162; 162, break_statement; 163, if_statement; 163, 164; 163, 167; 164, comparison_operator:>; 164, 165; 164, 166; 165, identifier:verbose; 166, integer:0; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:print; 171, argument_list; 171, 172; 172, binary_operator:%; 172, 173; 172, 174; 173, string:'[util_path] ... Removed %d/%d files'; 174, tuple; 174, 175; 174, 176; 175, identifier:num_removed; 176, identifier:num_matched; 177, return_statement; 177, 178; 178, True | def remove_files_in_dir(dpath, fname_pattern_list='*', recursive=False,
verbose=VERBOSE, dryrun=False, ignore_errors=False):
if isinstance(fname_pattern_list, six.string_types):
fname_pattern_list = [fname_pattern_list]
if verbose > 2:
print('[util_path] Removing files:')
print(' * from dpath = %r ' % dpath)
print(' * with patterns = %r' % fname_pattern_list)
print(' * recursive = %r' % recursive)
num_removed, num_matched = (0, 0)
if not exists(dpath):
msg = ('!!! dir = %r does not exist!' % dpath)
if verbose:
print(msg)
warnings.warn(msg, category=UserWarning)
for root, dname_list, fname_list in os.walk(dpath):
for fname_pattern in fname_pattern_list:
for fname in fnmatch.filter(fname_list, fname_pattern):
num_matched += 1
num_removed += remove_file(join(root, fname),
ignore_errors=ignore_errors,
dryrun=dryrun,
verbose=verbose > 5)
if not recursive:
break
if verbose > 0:
print('[util_path] ... Removed %d/%d files' % (num_removed, num_matched))
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:remove_fpaths; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:fpaths; 5, default_parameter; 5, 6; 5, 7; 6, identifier:verbose; 7, identifier:VERBOSE; 8, default_parameter; 8, 9; 8, 10; 9, identifier:quiet; 10, identifier:QUIET; 11, default_parameter; 11, 12; 11, 13; 12, identifier:strict; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:print_caller; 16, identifier:PRINT_CALLER; 17, default_parameter; 17, 18; 17, 19; 18, identifier:lbl; 19, string:'files'; 20, block; 20, 21; 20, 26; 20, 45; 20, 52; 20, 64; 20, 76; 20, 80; 20, 95; 20, 102; 20, 188; 20, 201; 21, import_statement; 21, 22; 22, aliased_import; 22, 23; 22, 25; 23, dotted_name; 23, 24; 24, identifier:utool; 25, identifier:ut; 26, if_statement; 26, 27; 26, 28; 27, identifier:print_caller; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:print; 32, argument_list; 32, 33; 33, binary_operator:+; 33, 34; 33, 44; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:util_dbg; 37, identifier:get_caller_name; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:range; 41, argument_list; 41, 42; 41, 43; 42, integer:1; 43, integer:4; 44, string:' called remove_fpaths'; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:n_total; 48, call; 48, 49; 48, 50; 49, identifier:len; 50, argument_list; 50, 51; 51, identifier:fpaths; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:_verbose; 55, boolean_operator:or; 55, 56; 55, 63; 56, parenthesized_expression; 56, 57; 57, boolean_operator:and; 57, 58; 57, 60; 58, not_operator; 58, 59; 59, identifier:quiet; 60, comparison_operator:>; 60, 61; 60, 62; 61, identifier:n_total; 62, integer:0; 63, identifier:VERYVERBOSE; 64, if_statement; 64, 65; 64, 66; 65, identifier:_verbose; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:print; 70, argument_list; 70, 71; 71, binary_operator:%; 71, 72; 71, 73; 72, string:'[util_path.remove_fpaths] try removing %d %s'; 73, tuple; 73, 74; 73, 75; 74, identifier:n_total; 75, identifier:lbl; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:n_removed; 79, integer:0; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:prog; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:ut; 86, identifier:ProgIter; 87, argument_list; 87, 88; 87, 89; 87, 92; 88, identifier:fpaths; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:label; 91, string:'removing files'; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:enabled; 94, identifier:verbose; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:_iter; 98, call; 98, 99; 98, 100; 99, identifier:iter; 100, argument_list; 100, 101; 101, identifier:prog; 102, try_statement; 102, 103; 102, 119; 103, block; 103, 104; 104, for_statement; 104, 105; 104, 106; 104, 107; 105, identifier:fpath; 106, identifier:_iter; 107, block; 107, 108; 107, 115; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:os; 112, identifier:remove; 113, argument_list; 113, 114; 114, identifier:fpath; 115, expression_statement; 115, 116; 116, augmented_assignment:+=; 116, 117; 116, 118; 117, identifier:n_removed; 118, integer:1; 119, except_clause; 119, 120; 119, 124; 120, as_pattern; 120, 121; 120, 122; 121, identifier:OSError; 122, as_pattern_target; 122, 123; 123, identifier:ex; 124, block; 124, 125; 124, 136; 124, 154; 125, if_statement; 125, 126; 125, 127; 126, identifier:VERYVERBOSE; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:print; 131, argument_list; 131, 132; 132, binary_operator:%; 132, 133; 132, 134; 133, string:'WARNING: Could not remove fpath = %r'; 134, tuple; 134, 135; 135, identifier:fpath; 136, if_statement; 136, 137; 136, 138; 137, identifier:strict; 138, block; 138, 139; 138, 153; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:util_dbg; 143, identifier:printex; 144, argument_list; 144, 145; 144, 146; 144, 150; 145, identifier:ex; 146, binary_operator:%; 146, 147; 146, 148; 147, string:'Could not remove fpath = %r'; 148, tuple; 148, 149; 149, identifier:fpath; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:iswarning; 152, False; 153, raise_statement; 154, for_statement; 154, 155; 154, 156; 154, 157; 155, identifier:fpath; 156, identifier:_iter; 157, block; 157, 158; 158, try_statement; 158, 159; 158, 171; 159, block; 159, 160; 159, 167; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:os; 164, identifier:remove; 165, argument_list; 165, 166; 166, identifier:fpath; 167, expression_statement; 167, 168; 168, augmented_assignment:+=; 168, 169; 168, 170; 169, identifier:n_removed; 170, integer:1; 171, except_clause; 171, 172; 171, 176; 172, as_pattern; 172, 173; 172, 174; 173, identifier:OSError; 174, as_pattern_target; 174, 175; 175, identifier:ex; 176, block; 176, 177; 177, if_statement; 177, 178; 177, 179; 178, identifier:VERYVERBOSE; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 183; 182, identifier:print; 183, argument_list; 183, 184; 184, binary_operator:%; 184, 185; 184, 186; 185, string:'WARNING: Could not remove fpath = %r'; 186, tuple; 186, 187; 187, identifier:fpath; 188, if_statement; 188, 189; 188, 190; 189, identifier:_verbose; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 194; 193, identifier:print; 194, argument_list; 194, 195; 195, binary_operator:%; 195, 196; 195, 197; 196, string:'[util_path.remove_fpaths] ... removed %d / %d %s'; 197, tuple; 197, 198; 197, 199; 197, 200; 198, identifier:n_removed; 199, identifier:n_total; 200, identifier:lbl; 201, return_statement; 201, 202; 202, identifier:n_removed | def remove_fpaths(fpaths, verbose=VERBOSE, quiet=QUIET, strict=False,
print_caller=PRINT_CALLER, lbl='files'):
import utool as ut
if print_caller:
print(util_dbg.get_caller_name(range(1, 4)) + ' called remove_fpaths')
n_total = len(fpaths)
_verbose = (not quiet and n_total > 0) or VERYVERBOSE
if _verbose:
print('[util_path.remove_fpaths] try removing %d %s' % (n_total, lbl))
n_removed = 0
prog = ut.ProgIter(fpaths, label='removing files', enabled=verbose)
_iter = iter(prog)
try:
for fpath in _iter:
os.remove(fpath)
n_removed += 1
except OSError as ex:
if VERYVERBOSE:
print('WARNING: Could not remove fpath = %r' % (fpath,))
if strict:
util_dbg.printex(ex, 'Could not remove fpath = %r' % (fpath,),
iswarning=False)
raise
for fpath in _iter:
try:
os.remove(fpath)
n_removed += 1
except OSError as ex:
if VERYVERBOSE:
print('WARNING: Could not remove fpath = %r' % (fpath,))
if _verbose:
print('[util_path.remove_fpaths] ... removed %d / %d %s' % (
n_removed, n_total, lbl))
return n_removed |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:checkpath; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:path_; 5, default_parameter; 5, 6; 5, 7; 6, identifier:verbose; 7, identifier:VERYVERBOSE; 8, default_parameter; 8, 9; 8, 10; 9, identifier:n; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:info; 13, identifier:VERYVERBOSE; 14, block; 14, 15; 14, 17; 14, 34; 14, 41; 14, 121; 14, 128; 14, 188; 14, 223; 15, expression_statement; 15, 16; 16, identifier:r; 17, assert_statement; 17, 18; 17, 25; 18, call; 18, 19; 18, 20; 19, identifier:isinstance; 20, argument_list; 20, 21; 20, 22; 21, identifier:path_; 22, attribute; 22, 23; 22, 24; 23, identifier:six; 24, identifier:string_types; 25, parenthesized_expression; 25, 26; 26, binary_operator:%; 26, 27; 26, 28; 27, string:'path_=%r is not a string. type(path_) = %r'; 28, tuple; 28, 29; 28, 30; 29, identifier:path_; 30, call; 30, 31; 30, 32; 31, identifier:type; 32, argument_list; 32, 33; 33, identifier:path_; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:path_; 37, call; 37, 38; 37, 39; 38, identifier:normpath; 39, argument_list; 39, 40; 40, identifier:path_; 41, if_statement; 41, 42; 41, 50; 42, call; 42, 43; 42, 48; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:sys; 46, identifier:platform; 47, identifier:startswith; 48, argument_list; 48, 49; 49, string:'win32'; 50, block; 50, 51; 51, if_statement; 51, 52; 51, 58; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:path_; 55, identifier:startswith; 56, argument_list; 56, 57; 57, string:'\\'; 58, block; 58, 59; 58, 68; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:dirs; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:path_; 65, identifier:split; 66, argument_list; 66, 67; 67, string:'\\'; 68, if_statement; 68, 69; 68, 93; 69, boolean_operator:and; 69, 70; 69, 85; 70, boolean_operator:and; 70, 71; 70, 77; 71, comparison_operator:>; 71, 72; 71, 76; 72, call; 72, 73; 72, 74; 73, identifier:len; 74, argument_list; 74, 75; 75, identifier:dirs; 76, integer:1; 77, comparison_operator:==; 77, 78; 77, 84; 78, call; 78, 79; 78, 80; 79, identifier:len; 80, argument_list; 80, 81; 81, subscript; 81, 82; 81, 83; 82, identifier:dirs; 83, integer:0; 84, integer:0; 85, comparison_operator:==; 85, 86; 85, 92; 86, call; 86, 87; 86, 88; 87, identifier:len; 88, argument_list; 88, 89; 89, subscript; 89, 90; 89, 91; 90, identifier:dirs; 91, integer:1; 92, integer:1; 93, block; 93, 94; 93, 108; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 99; 96, subscript; 96, 97; 96, 98; 97, identifier:dirs; 98, integer:1; 99, binary_operator:+; 99, 100; 99, 107; 100, call; 100, 101; 100, 106; 101, attribute; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:dirs; 104, integer:1; 105, identifier:upper; 106, argument_list; 107, string:':'; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:path_; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, string:'\\'; 114, identifier:join; 115, argument_list; 115, 116; 116, subscript; 116, 117; 116, 118; 117, identifier:dirs; 118, slice; 118, 119; 118, 120; 119, integer:1; 120, colon; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:does_exist; 124, call; 124, 125; 124, 126; 125, identifier:exists; 126, argument_list; 126, 127; 127, identifier:path_; 128, if_statement; 128, 129; 128, 130; 129, identifier:verbose; 130, block; 130, 131; 130, 139; 130, 150; 130, 159; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:pretty_path; 134, call; 134, 135; 134, 136; 135, identifier:path_ndir_split; 136, argument_list; 136, 137; 136, 138; 137, identifier:path_; 138, identifier:n; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:caller_name; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:util_dbg; 145, identifier:get_caller_name; 146, argument_list; 146, 147; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:allow_genexpr; 149, False; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 153; 152, identifier:print; 153, argument_list; 153, 154; 154, binary_operator:%; 154, 155; 154, 156; 155, string:'[%s] checkpath(%r)'; 156, tuple; 156, 157; 156, 158; 157, identifier:caller_name; 158, identifier:pretty_path; 159, if_statement; 159, 160; 159, 161; 159, 178; 160, identifier:does_exist; 161, block; 161, 162; 161, 169; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:path_type; 165, call; 165, 166; 165, 167; 166, identifier:get_path_type; 167, argument_list; 167, 168; 168, identifier:path_; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:print; 172, argument_list; 172, 173; 173, binary_operator:%; 173, 174; 173, 175; 174, string:'[%s] ...(%s) exists'; 175, tuple; 175, 176; 175, 177; 176, identifier:caller_name; 177, identifier:path_type; 178, else_clause; 178, 179; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 183; 182, identifier:print; 183, argument_list; 183, 184; 184, binary_operator:%; 184, 185; 184, 186; 185, string:'[%s] ... does not exist'; 186, parenthesized_expression; 186, 187; 187, identifier:caller_name; 188, if_statement; 188, 189; 188, 193; 189, boolean_operator:and; 189, 190; 189, 192; 190, not_operator; 190, 191; 191, identifier:does_exist; 192, identifier:info; 193, block; 193, 194; 193, 201; 193, 208; 193, 215; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:_longest_path; 197, call; 197, 198; 197, 199; 198, identifier:longest_existing_path; 199, argument_list; 199, 200; 200, identifier:path_; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:_longest_path_type; 204, call; 204, 205; 204, 206; 205, identifier:get_path_type; 206, argument_list; 206, 207; 207, identifier:_longest_path; 208, expression_statement; 208, 209; 209, call; 209, 210; 209, 211; 210, identifier:print; 211, argument_list; 211, 212; 212, binary_operator:%; 212, 213; 212, 214; 213, string:'[util_path] ... The longest existing path is: %r'; 214, identifier:_longest_path; 215, expression_statement; 215, 216; 216, call; 216, 217; 216, 218; 217, identifier:print; 218, argument_list; 218, 219; 219, binary_operator:%; 219, 220; 219, 221; 220, string:'[util_path] ... and has type %r'; 221, tuple; 221, 222; 222, identifier:_longest_path_type; 223, return_statement; 223, 224; 224, identifier:does_exist | def checkpath(path_, verbose=VERYVERBOSE, n=None, info=VERYVERBOSE):
r
assert isinstance(path_, six.string_types), (
'path_=%r is not a string. type(path_) = %r' % (path_, type(path_)))
path_ = normpath(path_)
if sys.platform.startswith('win32'):
if path_.startswith('\\'):
dirs = path_.split('\\')
if len(dirs) > 1 and len(dirs[0]) == 0 and len(dirs[1]) == 1:
dirs[1] = dirs[1].upper() + ':'
path_ = '\\'.join(dirs[1:])
does_exist = exists(path_)
if verbose:
pretty_path = path_ndir_split(path_, n)
caller_name = util_dbg.get_caller_name(allow_genexpr=False)
print('[%s] checkpath(%r)' % (caller_name, pretty_path))
if does_exist:
path_type = get_path_type(path_)
print('[%s] ...(%s) exists' % (caller_name, path_type,))
else:
print('[%s] ... does not exist' % (caller_name))
if not does_exist and info:
_longest_path = longest_existing_path(path_)
_longest_path_type = get_path_type(_longest_path)
print('[util_path] ... The longest existing path is: %r' % _longest_path)
print('[util_path] ... and has type %r' % (_longest_path_type,))
return does_exist |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 28; 2, function_name:glob; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 4, identifier:dpath; 5, default_parameter; 5, 6; 5, 7; 6, identifier:pattern; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:recursive; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:with_files; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:with_dirs; 16, True; 17, default_parameter; 17, 18; 17, 19; 18, identifier:maxdepth; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:exclude_dirs; 22, list:[]; 23, default_parameter; 23, 24; 23, 25; 24, identifier:fullpath; 25, True; 26, dictionary_splat_pattern; 26, 27; 27, identifier:kwargs; 28, block; 28, 29; 28, 31; 28, 59; 28, 66; 29, expression_statement; 29, 30; 30, identifier:r; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:gen; 34, call; 34, 35; 34, 36; 35, identifier:iglob; 36, argument_list; 36, 37; 36, 38; 36, 39; 36, 42; 36, 45; 36, 48; 36, 51; 36, 54; 36, 57; 37, identifier:dpath; 38, identifier:pattern; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:recursive; 41, identifier:recursive; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:with_files; 44, identifier:with_files; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:with_dirs; 47, identifier:with_dirs; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:maxdepth; 50, identifier:maxdepth; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:fullpath; 53, identifier:fullpath; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:exclude_dirs; 56, identifier:exclude_dirs; 57, dictionary_splat; 57, 58; 58, identifier:kwargs; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:path_list; 62, call; 62, 63; 62, 64; 63, identifier:list; 64, argument_list; 64, 65; 65, identifier:gen; 66, return_statement; 66, 67; 67, identifier:path_list | def glob(dpath, pattern=None, recursive=False, with_files=True, with_dirs=True,
maxdepth=None, exclude_dirs=[], fullpath=True, **kwargs):
r
gen = iglob(dpath, pattern, recursive=recursive,
with_files=with_files, with_dirs=with_dirs, maxdepth=maxdepth,
fullpath=fullpath, exclude_dirs=exclude_dirs, **kwargs)
path_list = list(gen)
return path_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:list_images; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:img_dpath_; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ignore_list; 7, list:[]; 8, default_parameter; 8, 9; 8, 10; 9, identifier:recursive; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:fullpath; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:full; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:sort; 19, True; 20, block; 20, 21; 20, 23; 20, 34; 20, 43; 20, 50; 20, 57; 20, 61; 20, 66; 20, 73; 20, 208; 20, 218; 21, expression_statement; 21, 22; 22, identifier:r; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:full; 26, None; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:fullpath; 31, boolean_operator:or; 31, 32; 31, 33; 32, identifier:fullpath; 33, identifier:full; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:img_dpath_; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:util_str; 40, identifier:ensure_unicode; 41, argument_list; 41, 42; 42, identifier:img_dpath_; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:img_dpath; 46, call; 46, 47; 46, 48; 47, identifier:realpath; 48, argument_list; 48, 49; 49, identifier:img_dpath_; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:ignore_set; 53, call; 53, 54; 53, 55; 54, identifier:set; 55, argument_list; 55, 56; 56, identifier:ignore_list; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:gname_list_; 60, list:[]; 61, expression_statement; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:assertpath; 64, argument_list; 64, 65; 65, identifier:img_dpath; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:true_imgpath; 69, call; 69, 70; 69, 71; 70, identifier:truepath; 71, argument_list; 71, 72; 72, identifier:img_dpath; 73, for_statement; 73, 74; 73, 78; 73, 84; 74, pattern_list; 74, 75; 74, 76; 74, 77; 75, identifier:root; 76, identifier:dlist; 77, identifier:flist; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:os; 81, identifier:walk; 82, argument_list; 82, 83; 83, identifier:true_imgpath; 84, block; 84, 85; 84, 94; 84, 102; 84, 118; 84, 203; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:root; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:util_str; 91, identifier:ensure_unicode; 92, argument_list; 92, 93; 93, identifier:root; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:rel_dpath; 97, call; 97, 98; 97, 99; 98, identifier:relpath; 99, argument_list; 99, 100; 99, 101; 100, identifier:root; 101, identifier:img_dpath; 102, if_statement; 102, 103; 102, 116; 103, call; 103, 104; 103, 105; 104, identifier:any; 105, argument_list; 105, 106; 106, list_comprehension; 106, 107; 106, 110; 107, comparison_operator:in; 107, 108; 107, 109; 108, identifier:dname; 109, identifier:ignore_set; 110, for_in_clause; 110, 111; 110, 112; 111, identifier:dname; 112, call; 112, 113; 112, 114; 113, identifier:dirsplit; 114, argument_list; 114, 115; 115, identifier:rel_dpath; 116, block; 116, 117; 117, continue_statement; 118, for_statement; 118, 119; 118, 120; 118, 124; 119, identifier:fname; 120, call; 120, 121; 120, 122; 121, identifier:iter; 122, argument_list; 122, 123; 123, identifier:flist; 124, block; 124, 125; 124, 134; 124, 148; 124, 164; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:fname; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:util_str; 131, identifier:ensure_unicode; 132, argument_list; 132, 133; 133, identifier:fname; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:gname; 137, call; 137, 138; 137, 145; 138, attribute; 138, 139; 138, 144; 139, call; 139, 140; 139, 141; 140, identifier:join; 141, argument_list; 141, 142; 141, 143; 142, identifier:rel_dpath; 143, identifier:fname; 144, identifier:replace; 145, argument_list; 145, 146; 145, 147; 146, string:'\\'; 147, string:'/'; 148, if_statement; 148, 149; 148, 155; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:gname; 152, identifier:startswith; 153, argument_list; 153, 154; 154, string:'./'; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:gname; 159, subscript; 159, 160; 159, 161; 160, identifier:gname; 161, slice; 161, 162; 161, 163; 162, integer:2; 163, colon; 164, if_statement; 164, 165; 164, 169; 165, call; 165, 166; 165, 167; 166, identifier:fpath_has_imgext; 167, argument_list; 167, 168; 168, identifier:gname; 169, block; 169, 170; 169, 176; 170, if_statement; 170, 171; 170, 174; 171, comparison_operator:in; 171, 172; 171, 173; 172, identifier:gname; 173, identifier:ignore_set; 174, block; 174, 175; 175, continue_statement; 176, if_statement; 176, 177; 176, 178; 176, 194; 177, identifier:fullpath; 178, block; 178, 179; 178, 187; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:gpath; 182, call; 182, 183; 182, 184; 183, identifier:join; 184, argument_list; 184, 185; 184, 186; 185, identifier:img_dpath; 186, identifier:gname; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:gname_list_; 191, identifier:append; 192, argument_list; 192, 193; 193, identifier:gpath; 194, else_clause; 194, 195; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:gname_list_; 200, identifier:append; 201, argument_list; 201, 202; 202, identifier:gname; 203, if_statement; 203, 204; 203, 206; 204, not_operator; 204, 205; 205, identifier:recursive; 206, block; 206, 207; 207, break_statement; 208, if_statement; 208, 209; 208, 210; 209, identifier:sort; 210, block; 210, 211; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:gname_list; 214, call; 214, 215; 214, 216; 215, identifier:sorted; 216, argument_list; 216, 217; 217, identifier:gname_list_; 218, return_statement; 218, 219; 219, identifier:gname_list | def list_images(img_dpath_, ignore_list=[], recursive=False, fullpath=False,
full=None, sort=True):
r
if full is not None:
fullpath = fullpath or full
img_dpath_ = util_str.ensure_unicode(img_dpath_)
img_dpath = realpath(img_dpath_)
ignore_set = set(ignore_list)
gname_list_ = []
assertpath(img_dpath)
true_imgpath = truepath(img_dpath)
for root, dlist, flist in os.walk(true_imgpath):
root = util_str.ensure_unicode(root)
rel_dpath = relpath(root, img_dpath)
if any([dname in ignore_set for dname in dirsplit(rel_dpath)]):
continue
for fname in iter(flist):
fname = util_str.ensure_unicode(fname)
gname = join(rel_dpath, fname).replace('\\', '/')
if gname.startswith('./'):
gname = gname[2:]
if fpath_has_imgext(gname):
if gname in ignore_set:
continue
if fullpath:
gpath = join(img_dpath, gname)
gname_list_.append(gpath)
else:
gname_list_.append(gname)
if not recursive:
break
if sort:
gname_list = sorted(gname_list_)
return gname_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:matching_fpaths; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:dpath_list; 5, identifier:include_patterns; 6, default_parameter; 6, 7; 6, 8; 7, identifier:exclude_dirs; 8, list:[]; 9, default_parameter; 9, 10; 9, 11; 10, identifier:greater_exclude_dirs; 11, list:[]; 12, default_parameter; 12, 13; 12, 14; 13, identifier:exclude_patterns; 14, list:[]; 15, default_parameter; 15, 16; 15, 17; 16, identifier:recursive; 17, True; 18, block; 18, 19; 18, 21; 18, 35; 19, expression_statement; 19, 20; 20, identifier:r; 21, if_statement; 21, 22; 21, 29; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 26; 25, identifier:dpath_list; 26, attribute; 26, 27; 26, 28; 27, identifier:six; 28, identifier:string_types; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:dpath_list; 33, list:[dpath_list]; 33, 34; 34, identifier:dpath_list; 35, for_statement; 35, 36; 35, 37; 35, 38; 36, identifier:dpath; 37, identifier:dpath_list; 38, block; 38, 39; 39, for_statement; 39, 40; 39, 44; 39, 50; 40, pattern_list; 40, 41; 40, 42; 40, 43; 41, identifier:root; 42, identifier:dname_list; 43, identifier:fname_list; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:os; 47, identifier:walk; 48, argument_list; 48, 49; 49, identifier:dpath; 50, block; 50, 51; 50, 62; 50, 75; 50, 84; 50, 90; 50, 132; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:subdirs; 54, call; 54, 55; 54, 56; 55, identifier:pathsplit_full; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:relpath; 59, argument_list; 59, 60; 59, 61; 60, identifier:root; 61, identifier:dpath; 62, if_statement; 62, 63; 62, 73; 63, call; 63, 64; 63, 65; 64, identifier:any; 65, argument_list; 65, 66; 66, list_comprehension; 66, 67; 66, 70; 67, comparison_operator:in; 67, 68; 67, 69; 68, identifier:dir_; 69, identifier:greater_exclude_dirs; 70, for_in_clause; 70, 71; 70, 72; 71, identifier:dir_; 72, identifier:subdirs; 73, block; 73, 74; 74, continue_statement; 75, if_statement; 75, 76; 75, 82; 76, comparison_operator:in; 76, 77; 76, 81; 77, call; 77, 78; 77, 79; 78, identifier:basename; 79, argument_list; 79, 80; 80, identifier:root; 81, identifier:exclude_dirs; 82, block; 82, 83; 83, continue_statement; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:_match; 87, attribute; 87, 88; 87, 89; 88, identifier:fnmatch; 89, identifier:fnmatch; 90, for_statement; 90, 91; 90, 92; 90, 93; 91, identifier:name; 92, identifier:fname_list; 93, block; 93, 94; 94, if_statement; 94, 95; 94, 106; 95, call; 95, 96; 95, 97; 96, identifier:any; 97, generator_expression; 97, 98; 97, 103; 98, call; 98, 99; 98, 100; 99, identifier:_match; 100, argument_list; 100, 101; 100, 102; 101, identifier:name; 102, identifier:pat; 103, for_in_clause; 103, 104; 103, 105; 104, identifier:pat; 105, identifier:include_patterns; 106, block; 106, 107; 107, if_statement; 107, 108; 107, 120; 108, not_operator; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:any; 111, generator_expression; 111, 112; 111, 117; 112, call; 112, 113; 112, 114; 113, identifier:_match; 114, argument_list; 114, 115; 114, 116; 115, identifier:name; 116, identifier:pat; 117, for_in_clause; 117, 118; 117, 119; 118, identifier:pat; 119, identifier:exclude_patterns; 120, block; 120, 121; 120, 129; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:fpath; 124, call; 124, 125; 124, 126; 125, identifier:join; 126, argument_list; 126, 127; 126, 128; 127, identifier:root; 128, identifier:name; 129, expression_statement; 129, 130; 130, yield; 130, 131; 131, identifier:fpath; 132, if_statement; 132, 133; 132, 135; 133, not_operator; 133, 134; 134, identifier:recursive; 135, block; 135, 136; 136, break_statement | def matching_fpaths(dpath_list, include_patterns, exclude_dirs=[],
greater_exclude_dirs=[], exclude_patterns=[],
recursive=True):
r
if isinstance(dpath_list, six.string_types):
dpath_list = [dpath_list]
for dpath in dpath_list:
for root, dname_list, fname_list in os.walk(dpath):
subdirs = pathsplit_full(relpath(root, dpath))
if any([dir_ in greater_exclude_dirs for dir_ in subdirs]):
continue
if basename(root) in exclude_dirs:
continue
_match = fnmatch.fnmatch
for name in fname_list:
if any(_match(name, pat) for pat in include_patterns):
if not any(_match(name, pat) for pat in exclude_patterns):
fpath = join(root, name)
yield fpath
if not recursive:
break |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 27; 2, function_name:sed; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 4, identifier:regexpr; 5, identifier:repl; 6, default_parameter; 6, 7; 6, 8; 7, identifier:force; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:recursive; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:dpath_list; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:fpath_list; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:verbose; 20, None; 21, default_parameter; 21, 22; 21, 23; 22, identifier:include_patterns; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:exclude_patterns; 26, list:[]; 27, block; 27, 28; 27, 48; 27, 62; 27, 73; 27, 112; 27, 181; 27, 188; 27, 192; 27, 196; 27, 200; 27, 240; 27, 245; 27, 253; 27, 269; 28, if_statement; 28, 29; 28, 32; 29, comparison_operator:is; 29, 30; 29, 31; 30, identifier:include_patterns; 31, None; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:include_patterns; 36, list:['*.py', '*.pyx', '*.pxi', '*.cxx', '*.cpp', '*.hxx', '*.hpp', '*.c', '*.h', '*.html', '*.tex']; 36, 37; 36, 38; 36, 39; 36, 40; 36, 41; 36, 42; 36, 43; 36, 44; 36, 45; 36, 46; 36, 47; 37, string:'*.py'; 38, string:'*.pyx'; 39, string:'*.pxi'; 40, string:'*.cxx'; 41, string:'*.cpp'; 42, string:'*.hxx'; 43, string:'*.hpp'; 44, string:'*.c'; 45, string:'*.h'; 46, string:'*.html'; 47, string:'*.tex'; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:dpath_list; 51, None; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:dpath_list; 56, list:[os.getcwd()]; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:os; 60, identifier:getcwd; 61, argument_list; 62, if_statement; 62, 63; 62, 66; 63, comparison_operator:is; 63, 64; 63, 65; 64, identifier:verbose; 65, None; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:verbose; 70, attribute; 70, 71; 70, 72; 71, identifier:ut; 72, identifier:NOT_QUIET; 73, if_statement; 73, 74; 73, 77; 73, 106; 74, comparison_operator:is; 74, 75; 74, 76; 75, identifier:fpath_list; 76, None; 77, block; 77, 78; 77, 84; 77, 88; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:greater_exclude_dirs; 81, call; 81, 82; 81, 83; 82, identifier:get_standard_exclude_dnames; 83, argument_list; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:exclude_dirs; 87, list:[]; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:fpath_generator; 91, call; 91, 92; 91, 93; 92, identifier:matching_fpaths; 93, argument_list; 93, 94; 93, 95; 93, 96; 93, 97; 93, 100; 93, 103; 94, identifier:dpath_list; 95, identifier:include_patterns; 96, identifier:exclude_dirs; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:greater_exclude_dirs; 99, identifier:greater_exclude_dirs; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:recursive; 102, identifier:recursive; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:exclude_patterns; 105, identifier:exclude_patterns; 106, else_clause; 106, 107; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:fpath_generator; 111, identifier:fpath_list; 112, if_statement; 112, 113; 112, 114; 113, identifier:verbose; 114, block; 114, 115; 114, 123; 114, 131; 114, 139; 114, 147; 114, 155; 114, 163; 114, 168; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:print; 118, argument_list; 118, 119; 119, binary_operator:%; 119, 120; 119, 121; 120, string:'sed-ing %r'; 121, tuple; 121, 122; 122, identifier:dpath_list; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 126; 125, identifier:print; 126, argument_list; 126, 127; 127, binary_operator:%; 127, 128; 127, 129; 128, string:' * regular expression : %r'; 129, tuple; 129, 130; 130, identifier:regexpr; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 134; 133, identifier:print; 134, argument_list; 134, 135; 135, binary_operator:%; 135, 136; 135, 137; 136, string:' * replacement : %r'; 137, tuple; 137, 138; 138, identifier:repl; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 142; 141, identifier:print; 142, argument_list; 142, 143; 143, binary_operator:%; 143, 144; 143, 145; 144, string:' * include_patterns : %r'; 145, tuple; 145, 146; 146, identifier:include_patterns; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 150; 149, identifier:print; 150, argument_list; 150, 151; 151, binary_operator:%; 151, 152; 151, 153; 152, string:' * recursive: %r'; 153, tuple; 153, 154; 154, identifier:recursive; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 158; 157, identifier:print; 158, argument_list; 158, 159; 159, binary_operator:%; 159, 160; 159, 161; 160, string:' * force: %r'; 161, tuple; 161, 162; 162, identifier:force; 163, import_from_statement; 163, 164; 163, 166; 164, dotted_name; 164, 165; 165, identifier:utool; 166, dotted_name; 166, 167; 167, identifier:util_str; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:print; 171, argument_list; 171, 172; 172, binary_operator:%; 172, 173; 172, 174; 173, string:' * fpath_list: %s'; 174, tuple; 174, 175; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:util_str; 178, identifier:repr3; 179, argument_list; 179, 180; 180, identifier:fpath_list; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:regexpr; 184, call; 184, 185; 184, 186; 185, identifier:extend_regex; 186, argument_list; 186, 187; 187, identifier:regexpr; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:num_changed; 191, integer:0; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:num_files_checked; 195, integer:0; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:fpaths_changed; 199, list:[]; 200, for_statement; 200, 201; 200, 202; 200, 203; 201, identifier:fpath; 202, identifier:fpath_generator; 203, block; 203, 204; 203, 208; 203, 221; 204, expression_statement; 204, 205; 205, augmented_assignment:+=; 205, 206; 205, 207; 206, identifier:num_files_checked; 207, integer:1; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:changed_lines; 211, call; 211, 212; 211, 213; 212, identifier:sedfile; 213, argument_list; 213, 214; 213, 215; 213, 216; 213, 217; 213, 218; 214, identifier:fpath; 215, identifier:regexpr; 216, identifier:repl; 217, identifier:force; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:verbose; 220, identifier:verbose; 221, if_statement; 221, 222; 221, 225; 222, comparison_operator:is; 222, 223; 222, 224; 223, identifier:changed_lines; 224, None; 225, block; 225, 226; 225, 233; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:fpaths_changed; 230, identifier:append; 231, argument_list; 231, 232; 232, identifier:fpath; 233, expression_statement; 233, 234; 234, augmented_assignment:+=; 234, 235; 234, 236; 235, identifier:num_changed; 236, call; 236, 237; 236, 238; 237, identifier:len; 238, argument_list; 238, 239; 239, identifier:changed_lines; 240, import_statement; 240, 241; 241, aliased_import; 241, 242; 241, 244; 242, dotted_name; 242, 243; 243, identifier:utool; 244, identifier:ut; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 248; 247, identifier:print; 248, argument_list; 248, 249; 249, binary_operator:%; 249, 250; 249, 251; 250, string:'num_files_checked = %r'; 251, tuple; 251, 252; 252, identifier:num_files_checked; 253, expression_statement; 253, 254; 254, call; 254, 255; 254, 256; 255, identifier:print; 256, argument_list; 256, 257; 257, binary_operator:%; 257, 258; 257, 259; 258, string:'fpaths_changed = %s'; 259, tuple; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:ut; 263, identifier:repr3; 264, argument_list; 264, 265; 265, call; 265, 266; 265, 267; 266, identifier:sorted; 267, argument_list; 267, 268; 268, identifier:fpaths_changed; 269, expression_statement; 269, 270; 270, call; 270, 271; 270, 272; 271, identifier:print; 272, argument_list; 272, 273; 273, binary_operator:%; 273, 274; 273, 275; 274, string:'total lines changed = %r'; 275, tuple; 275, 276; 276, identifier:num_changed | def sed(regexpr, repl, force=False, recursive=False, dpath_list=None,
fpath_list=None, verbose=None, include_patterns=None,
exclude_patterns=[]):
if include_patterns is None:
include_patterns = ['*.py', '*.pyx', '*.pxi', '*.cxx', '*.cpp', '*.hxx', '*.hpp', '*.c', '*.h', '*.html', '*.tex']
if dpath_list is None:
dpath_list = [os.getcwd()]
if verbose is None:
verbose = ut.NOT_QUIET
if fpath_list is None:
greater_exclude_dirs = get_standard_exclude_dnames()
exclude_dirs = []
fpath_generator = matching_fpaths(
dpath_list, include_patterns, exclude_dirs,
greater_exclude_dirs=greater_exclude_dirs,
recursive=recursive, exclude_patterns=exclude_patterns)
else:
fpath_generator = fpath_list
if verbose:
print('sed-ing %r' % (dpath_list,))
print(' * regular expression : %r' % (regexpr,))
print(' * replacement : %r' % (repl,))
print(' * include_patterns : %r' % (include_patterns,))
print(' * recursive: %r' % (recursive,))
print(' * force: %r' % (force,))
from utool import util_str
print(' * fpath_list: %s' % (util_str.repr3(fpath_list),))
regexpr = extend_regex(regexpr)
num_changed = 0
num_files_checked = 0
fpaths_changed = []
for fpath in fpath_generator:
num_files_checked += 1
changed_lines = sedfile(fpath, regexpr, repl, force, verbose=verbose)
if changed_lines is not None:
fpaths_changed.append(fpath)
num_changed += len(changed_lines)
import utool as ut
print('num_files_checked = %r' % (num_files_checked,))
print('fpaths_changed = %s' % (ut.repr3(sorted(fpaths_changed)),))
print('total lines changed = %r' % (num_changed,)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 38; 2, function_name:grep; 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:regex_list; 5, default_parameter; 5, 6; 5, 7; 6, identifier:recursive; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:dpath_list; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:include_patterns; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:exclude_dirs; 16, list:[]; 17, default_parameter; 17, 18; 17, 19; 18, identifier:greater_exclude_dirs; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:inverse; 22, False; 23, default_parameter; 23, 24; 23, 25; 24, identifier:exclude_patterns; 25, list:[]; 26, default_parameter; 26, 27; 26, 28; 27, identifier:verbose; 28, identifier:VERBOSE; 29, default_parameter; 29, 30; 29, 31; 30, identifier:fpath_list; 31, None; 32, default_parameter; 32, 33; 32, 34; 33, identifier:reflags; 34, integer:0; 35, default_parameter; 35, 36; 35, 37; 36, identifier:cache; 37, None; 38, block; 38, 39; 38, 41; 38, 46; 38, 51; 38, 61; 38, 70; 38, 84; 38, 98; 38, 127; 38, 141; 38, 145; 38, 149; 38, 153; 38, 188; 38, 202; 38, 212; 38, 222; 38, 228; 38, 307; 38, 314; 38, 347; 39, expression_statement; 39, 40; 40, identifier:r; 41, import_from_statement; 41, 42; 41, 44; 42, dotted_name; 42, 43; 43, identifier:utool; 44, dotted_name; 44, 45; 45, identifier:util_regex; 46, import_from_statement; 46, 47; 46, 49; 47, dotted_name; 47, 48; 48, identifier:utool; 49, dotted_name; 49, 50; 50, identifier:util_list; 51, if_statement; 51, 52; 51, 55; 52, comparison_operator:is; 52, 53; 52, 54; 53, identifier:include_patterns; 54, None; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:include_patterns; 59, list:['*']; 59, 60; 60, string:'*'; 61, if_statement; 61, 62; 61, 65; 62, comparison_operator:is; 62, 63; 62, 64; 63, identifier:greater_exclude_dirs; 64, None; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:greater_exclude_dirs; 69, list:[]; 70, if_statement; 70, 71; 70, 78; 71, call; 71, 72; 71, 73; 72, identifier:isinstance; 73, argument_list; 73, 74; 73, 75; 74, identifier:include_patterns; 75, attribute; 75, 76; 75, 77; 76, identifier:six; 77, identifier:string_types; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:include_patterns; 82, list:[include_patterns]; 82, 83; 83, identifier:include_patterns; 84, if_statement; 84, 85; 84, 88; 85, comparison_operator:is; 85, 86; 85, 87; 86, identifier:dpath_list; 87, None; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:dpath_list; 92, list:[os.getcwd()]; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:os; 96, identifier:getcwd; 97, argument_list; 98, if_statement; 98, 99; 98, 100; 99, identifier:verbose; 100, block; 100, 101; 100, 109; 100, 119; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:recursive_stat_str; 104, subscript; 104, 105; 104, 108; 105, list:['flat', 'recursive']; 105, 106; 105, 107; 106, string:'flat'; 107, string:'recursive'; 108, identifier:recursive; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:print; 112, argument_list; 112, 113; 113, binary_operator:%; 113, 114; 113, 115; 114, string:'[util_path] Greping (%s) %r for %r'; 115, tuple; 115, 116; 115, 117; 115, 118; 116, identifier:recursive_stat_str; 117, identifier:dpath_list; 118, identifier:regex_list; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:print; 122, argument_list; 122, 123; 123, binary_operator:%; 123, 124; 123, 125; 124, string:'[util_path] regex_list = %s'; 125, parenthesized_expression; 125, 126; 126, identifier:regex_list; 127, if_statement; 127, 128; 127, 135; 128, call; 128, 129; 128, 130; 129, identifier:isinstance; 130, argument_list; 130, 131; 130, 132; 131, identifier:regex_list; 132, attribute; 132, 133; 132, 134; 133, identifier:six; 134, identifier:string_types; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:regex_list; 139, list:[regex_list]; 139, 140; 140, identifier:regex_list; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:found_fpath_list; 144, list:[]; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:found_lines_list; 148, list:[]; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:found_lxs_list; 152, list:[]; 153, if_statement; 153, 154; 153, 157; 153, 182; 154, comparison_operator:is; 154, 155; 154, 156; 155, identifier:fpath_list; 156, None; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:fpath_generator; 161, call; 161, 162; 161, 163; 162, identifier:matching_fpaths; 163, argument_list; 163, 164; 163, 167; 163, 170; 163, 173; 163, 176; 163, 179; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:dpath_list; 166, identifier:dpath_list; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:include_patterns; 169, identifier:include_patterns; 170, keyword_argument; 170, 171; 170, 172; 171, identifier:exclude_dirs; 172, identifier:exclude_dirs; 173, keyword_argument; 173, 174; 173, 175; 174, identifier:greater_exclude_dirs; 175, identifier:greater_exclude_dirs; 176, keyword_argument; 176, 177; 176, 178; 177, identifier:exclude_patterns; 178, identifier:exclude_patterns; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:recursive; 181, identifier:recursive; 182, else_clause; 182, 183; 183, block; 183, 184; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:fpath_generator; 187, identifier:fpath_list; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:_exprs_flags; 191, list_comprehension; 191, 192; 191, 199; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:util_regex; 195, identifier:extend_regex2; 196, argument_list; 196, 197; 196, 198; 197, identifier:expr; 198, identifier:reflags; 199, for_in_clause; 199, 200; 199, 201; 200, identifier:expr; 201, identifier:regex_list; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:extended_regex_list; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:util_list; 208, identifier:take_column; 209, argument_list; 209, 210; 209, 211; 210, identifier:_exprs_flags; 211, integer:0; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:reflags_list; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:util_list; 218, identifier:take_column; 219, argument_list; 219, 220; 219, 221; 220, identifier:_exprs_flags; 221, integer:1; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:reflags; 225, subscript; 225, 226; 225, 227; 226, identifier:reflags_list; 227, integer:0; 228, for_statement; 228, 229; 228, 230; 228, 231; 229, identifier:fpath; 230, identifier:fpath_generator; 231, block; 231, 232; 231, 246; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 237; 234, pattern_list; 234, 235; 234, 236; 235, identifier:found_lines; 236, identifier:found_lxs; 237, call; 237, 238; 237, 239; 238, identifier:grepfile; 239, argument_list; 239, 240; 239, 241; 239, 242; 239, 243; 240, identifier:fpath; 241, identifier:extended_regex_list; 242, identifier:reflags_list; 243, keyword_argument; 243, 244; 243, 245; 244, identifier:cache; 245, identifier:cache; 246, if_statement; 246, 247; 246, 248; 246, 278; 247, identifier:inverse; 248, block; 248, 249; 249, if_statement; 249, 250; 249, 256; 250, comparison_operator:==; 250, 251; 250, 255; 251, call; 251, 252; 251, 253; 252, identifier:len; 253, argument_list; 253, 254; 254, identifier:found_lines; 255, integer:0; 256, block; 256, 257; 256, 264; 256, 271; 257, expression_statement; 257, 258; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:found_fpath_list; 261, identifier:append; 262, argument_list; 262, 263; 263, identifier:fpath; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:found_lines_list; 268, identifier:append; 269, argument_list; 269, 270; 270, list:[]; 271, expression_statement; 271, 272; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:found_lxs_list; 275, identifier:append; 276, argument_list; 276, 277; 277, list:[]; 278, elif_clause; 278, 279; 278, 285; 279, comparison_operator:>; 279, 280; 279, 284; 280, call; 280, 281; 280, 282; 281, identifier:len; 282, argument_list; 282, 283; 283, identifier:found_lines; 284, integer:0; 285, block; 285, 286; 285, 293; 285, 300; 286, expression_statement; 286, 287; 287, call; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:found_fpath_list; 290, identifier:append; 291, argument_list; 291, 292; 292, identifier:fpath; 293, expression_statement; 293, 294; 294, call; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:found_lines_list; 297, identifier:append; 298, argument_list; 298, 299; 299, identifier:found_lines; 300, expression_statement; 300, 301; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:found_lxs_list; 304, identifier:append; 305, argument_list; 305, 306; 306, identifier:found_lxs; 307, expression_statement; 307, 308; 308, assignment; 308, 309; 308, 310; 309, identifier:grep_result; 310, tuple; 310, 311; 310, 312; 310, 313; 311, identifier:found_fpath_list; 312, identifier:found_lines_list; 313, identifier:found_lxs_list; 314, if_statement; 314, 315; 314, 316; 315, identifier:verbose; 316, block; 316, 317; 316, 322; 316, 327; 316, 337; 317, expression_statement; 317, 318; 318, call; 318, 319; 318, 320; 319, identifier:print; 320, argument_list; 320, 321; 321, string:'=========='; 322, expression_statement; 322, 323; 323, call; 323, 324; 323, 325; 324, identifier:print; 325, argument_list; 325, 326; 326, string:'=========='; 327, expression_statement; 327, 328; 328, call; 328, 329; 328, 330; 329, identifier:print; 330, argument_list; 330, 331; 331, binary_operator:%; 331, 332; 331, 333; 332, string:'[util_path] found matches in %d files'; 333, call; 333, 334; 333, 335; 334, identifier:len; 335, argument_list; 335, 336; 336, identifier:found_fpath_list; 337, expression_statement; 337, 338; 338, call; 338, 339; 338, 340; 339, identifier:print; 340, argument_list; 340, 341; 341, call; 341, 342; 341, 343; 342, identifier:make_grep_resultstr; 343, argument_list; 343, 344; 343, 345; 343, 346; 344, identifier:grep_result; 345, identifier:extended_regex_list; 346, identifier:reflags; 347, return_statement; 347, 348; 348, identifier:grep_result | def grep(regex_list, recursive=True, dpath_list=None, include_patterns=None,
exclude_dirs=[], greater_exclude_dirs=None, inverse=False,
exclude_patterns=[], verbose=VERBOSE, fpath_list=None, reflags=0,
cache=None):
r
from utool import util_regex
from utool import util_list
if include_patterns is None:
include_patterns = ['*']
if greater_exclude_dirs is None:
greater_exclude_dirs = []
if isinstance(include_patterns, six.string_types):
include_patterns = [include_patterns]
if dpath_list is None:
dpath_list = [os.getcwd()]
if verbose:
recursive_stat_str = ['flat', 'recursive'][recursive]
print('[util_path] Greping (%s) %r for %r' % (recursive_stat_str,
dpath_list, regex_list))
print('[util_path] regex_list = %s' % (regex_list))
if isinstance(regex_list, six.string_types):
regex_list = [regex_list]
found_fpath_list = []
found_lines_list = []
found_lxs_list = []
if fpath_list is None:
fpath_generator = matching_fpaths(
dpath_list=dpath_list, include_patterns=include_patterns,
exclude_dirs=exclude_dirs,
greater_exclude_dirs=greater_exclude_dirs,
exclude_patterns=exclude_patterns, recursive=recursive)
else:
fpath_generator = fpath_list
_exprs_flags = [util_regex.extend_regex2(expr, reflags)
for expr in regex_list]
extended_regex_list = util_list.take_column(_exprs_flags, 0)
reflags_list = util_list.take_column(_exprs_flags, 1)
reflags = reflags_list[0]
for fpath in fpath_generator:
found_lines, found_lxs = grepfile(fpath, extended_regex_list,
reflags_list, cache=cache)
if inverse:
if len(found_lines) == 0:
found_fpath_list.append(fpath)
found_lines_list.append([])
found_lxs_list.append([])
elif len(found_lines) > 0:
found_fpath_list.append(fpath)
found_lines_list.append(found_lines)
found_lxs_list.append(found_lxs)
grep_result = (found_fpath_list, found_lines_list, found_lxs_list)
if verbose:
print('==========')
print('==========')
print('[util_path] found matches in %d files' %
len(found_fpath_list))
print(make_grep_resultstr(grep_result, extended_regex_list, reflags))
return grep_result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:find_lib_fpath; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:libname; 5, identifier:root_dir; 6, default_parameter; 6, 7; 6, 8; 7, identifier:recurse_down; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:verbose; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:debug; 14, False; 15, block; 15, 16; 15, 94; 15, 124; 15, 131; 15, 135; 15, 230; 15, 243; 15, 248; 15, 258; 16, function_definition; 16, 17; 16, 18; 16, 20; 17, function_name:get_lib_fname_list; 18, parameters; 18, 19; 19, identifier:libname; 20, block; 20, 21; 20, 92; 21, if_statement; 21, 22; 21, 30; 21, 43; 21, 62; 21, 81; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:sys; 26, identifier:platform; 27, identifier:startswith; 28, argument_list; 28, 29; 29, string:'win32'; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:libnames; 34, list:['lib' + libname + '.dll', libname + '.dll']; 34, 35; 34, 40; 35, binary_operator:+; 35, 36; 35, 39; 36, binary_operator:+; 36, 37; 36, 38; 37, string:'lib'; 38, identifier:libname; 39, string:'.dll'; 40, binary_operator:+; 40, 41; 40, 42; 41, identifier:libname; 42, string:'.dll'; 43, elif_clause; 43, 44; 43, 52; 44, call; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:sys; 48, identifier:platform; 49, identifier:startswith; 50, argument_list; 50, 51; 51, string:'darwin'; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:libnames; 56, list:['lib' + libname + '.dylib']; 56, 57; 57, binary_operator:+; 57, 58; 57, 61; 58, binary_operator:+; 58, 59; 58, 60; 59, string:'lib'; 60, identifier:libname; 61, string:'.dylib'; 62, elif_clause; 62, 63; 62, 71; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:sys; 67, identifier:platform; 68, identifier:startswith; 69, argument_list; 69, 70; 70, string:'linux'; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:libnames; 75, list:['lib' + libname + '.so']; 75, 76; 76, binary_operator:+; 76, 77; 76, 80; 77, binary_operator:+; 77, 78; 77, 79; 78, string:'lib'; 79, identifier:libname; 80, string:'.so'; 81, else_clause; 81, 82; 82, block; 82, 83; 83, raise_statement; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:Exception; 86, argument_list; 86, 87; 87, binary_operator:%; 87, 88; 87, 89; 88, string:'Unknown operating system: %s'; 89, attribute; 89, 90; 89, 91; 90, identifier:sys; 91, identifier:platform; 92, return_statement; 92, 93; 93, identifier:libnames; 94, function_definition; 94, 95; 94, 96; 94, 98; 95, function_name:get_lib_dpath_list; 96, parameters; 96, 97; 97, identifier:root_dir; 98, block; 98, 99; 98, 101; 98, 122; 99, expression_statement; 99, 100; 100, string:'returns possible lib locations'; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:get_lib_dpath_list; 104, list:[root_dir,
join(root_dir, 'lib'),
join(root_dir, 'build'),
join(root_dir, 'build', 'lib')]; 104, 105; 104, 106; 104, 111; 104, 116; 105, identifier:root_dir; 106, call; 106, 107; 106, 108; 107, identifier:join; 108, argument_list; 108, 109; 108, 110; 109, identifier:root_dir; 110, string:'lib'; 111, call; 111, 112; 111, 113; 112, identifier:join; 113, argument_list; 113, 114; 113, 115; 114, identifier:root_dir; 115, string:'build'; 116, call; 116, 117; 116, 118; 117, identifier:join; 118, argument_list; 118, 119; 118, 120; 118, 121; 119, identifier:root_dir; 120, string:'build'; 121, string:'lib'; 122, return_statement; 122, 123; 123, identifier:get_lib_dpath_list; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:lib_fname_list; 127, call; 127, 128; 127, 129; 128, identifier:get_lib_fname_list; 129, argument_list; 129, 130; 130, identifier:libname; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:tried_fpaths; 134, list:[]; 135, while_statement; 135, 136; 135, 139; 136, comparison_operator:is; 136, 137; 136, 138; 137, identifier:root_dir; 138, None; 139, block; 139, 140; 139, 225; 140, for_statement; 140, 141; 140, 142; 140, 143; 141, identifier:lib_fname; 142, identifier:lib_fname_list; 143, block; 143, 144; 143, 202; 143, 209; 144, for_statement; 144, 145; 144, 146; 144, 150; 145, identifier:lib_dpath; 146, call; 146, 147; 146, 148; 147, identifier:get_lib_dpath_list; 148, argument_list; 148, 149; 149, identifier:root_dir; 150, block; 150, 151; 150, 162; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:lib_fpath; 154, call; 154, 155; 154, 156; 155, identifier:normpath; 156, argument_list; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:join; 159, argument_list; 159, 160; 159, 161; 160, identifier:lib_dpath; 161, identifier:lib_fname; 162, if_statement; 162, 163; 162, 167; 162, 193; 163, call; 163, 164; 163, 165; 164, identifier:exists; 165, argument_list; 165, 166; 166, identifier:lib_fpath; 167, block; 167, 168; 167, 181; 167, 191; 168, if_statement; 168, 169; 168, 170; 169, identifier:verbose; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 174; 173, identifier:print; 174, argument_list; 174, 175; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, string:'\n[c] Checked: '; 178, identifier:join; 179, argument_list; 179, 180; 180, identifier:tried_fpaths; 181, if_statement; 181, 182; 181, 183; 182, identifier:debug; 183, block; 183, 184; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:print; 187, argument_list; 187, 188; 188, binary_operator:%; 188, 189; 188, 190; 189, string:'using: %r'; 190, identifier:lib_fpath; 191, return_statement; 191, 192; 192, identifier:lib_fpath; 193, else_clause; 193, 194; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:tried_fpaths; 199, identifier:append; 200, argument_list; 200, 201; 201, identifier:lib_fpath; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:_new_root; 205, call; 205, 206; 205, 207; 206, identifier:dirname; 207, argument_list; 207, 208; 208, identifier:root_dir; 209, if_statement; 209, 210; 209, 213; 209, 219; 210, comparison_operator:==; 210, 211; 210, 212; 211, identifier:_new_root; 212, identifier:root_dir; 213, block; 213, 214; 213, 218; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:root_dir; 217, None; 218, break_statement; 219, else_clause; 219, 220; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:root_dir; 224, identifier:_new_root; 225, if_statement; 225, 226; 225, 228; 226, not_operator; 226, 227; 227, identifier:recurse_down; 228, block; 228, 229; 229, break_statement; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:msg; 233, parenthesized_expression; 233, 234; 234, binary_operator:+; 234, 235; 234, 242; 235, binary_operator:%; 235, 236; 235, 237; 236, string:'\n[C!] load_clib(libname=%r root_dir=%r, recurse_down=%r, verbose=%r)'; 237, tuple; 237, 238; 237, 239; 237, 240; 237, 241; 238, identifier:libname; 239, identifier:root_dir; 240, identifier:recurse_down; 241, identifier:verbose; 242, string:'\n[c!] Cannot FIND dynamic library'; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 246; 245, identifier:print; 246, argument_list; 246, 247; 247, identifier:msg; 248, expression_statement; 248, 249; 249, call; 249, 250; 249, 251; 250, identifier:print; 251, argument_list; 251, 252; 252, call; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, string:'\n[c!] Checked: '; 255, identifier:join; 256, argument_list; 256, 257; 257, identifier:tried_fpaths; 258, raise_statement; 258, 259; 259, call; 259, 260; 259, 261; 260, identifier:ImportError; 261, argument_list; 261, 262; 262, identifier:msg | def find_lib_fpath(libname, root_dir, recurse_down=True, verbose=False, debug=False):
def get_lib_fname_list(libname):
if sys.platform.startswith('win32'):
libnames = ['lib' + libname + '.dll', libname + '.dll']
elif sys.platform.startswith('darwin'):
libnames = ['lib' + libname + '.dylib']
elif sys.platform.startswith('linux'):
libnames = ['lib' + libname + '.so']
else:
raise Exception('Unknown operating system: %s' % sys.platform)
return libnames
def get_lib_dpath_list(root_dir):
'returns possible lib locations'
get_lib_dpath_list = [root_dir,
join(root_dir, 'lib'),
join(root_dir, 'build'),
join(root_dir, 'build', 'lib')]
return get_lib_dpath_list
lib_fname_list = get_lib_fname_list(libname)
tried_fpaths = []
while root_dir is not None:
for lib_fname in lib_fname_list:
for lib_dpath in get_lib_dpath_list(root_dir):
lib_fpath = normpath(join(lib_dpath, lib_fname))
if exists(lib_fpath):
if verbose:
print('\n[c] Checked: '.join(tried_fpaths))
if debug:
print('using: %r' % lib_fpath)
return lib_fpath
else:
tried_fpaths.append(lib_fpath)
_new_root = dirname(root_dir)
if _new_root == root_dir:
root_dir = None
break
else:
root_dir = _new_root
if not recurse_down:
break
msg = ('\n[C!] load_clib(libname=%r root_dir=%r, recurse_down=%r, verbose=%r)' %
(libname, root_dir, recurse_down, verbose) +
'\n[c!] Cannot FIND dynamic library')
print(msg)
print('\n[c!] Checked: '.join(tried_fpaths))
raise ImportError(msg) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:search_candidate_paths; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:candidate_path_list; 5, default_parameter; 5, 6; 5, 7; 6, identifier:candidate_name_list; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:priority_paths; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:required_subpaths; 13, list:[]; 14, default_parameter; 14, 15; 14, 16; 15, identifier:verbose; 16, None; 17, block; 17, 18; 17, 23; 17, 35; 17, 45; 17, 76; 17, 87; 17, 91; 17, 169; 17, 179; 18, import_statement; 18, 19; 19, aliased_import; 19, 20; 19, 22; 20, dotted_name; 20, 21; 21, identifier:utool; 22, identifier:ut; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:verbose; 26, None; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:verbose; 31, conditional_expression:if; 31, 32; 31, 33; 31, 34; 32, integer:0; 33, identifier:QUIET; 34, integer:1; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:>=; 36, 37; 36, 38; 37, identifier:verbose; 38, integer:1; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:print; 43, argument_list; 43, 44; 44, string:'[search_candidate_paths] Searching for candidate paths'; 45, if_statement; 45, 46; 45, 49; 45, 70; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:candidate_name_list; 48, None; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:candidate_path_list_; 53, list_comprehension; 53, 54; 53, 59; 54, call; 54, 55; 54, 56; 55, identifier:join; 56, argument_list; 56, 57; 56, 58; 57, identifier:dpath; 58, identifier:fname; 59, for_in_clause; 59, 60; 59, 63; 60, pattern_list; 60, 61; 60, 62; 61, identifier:dpath; 62, identifier:fname; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:itertools; 66, identifier:product; 67, argument_list; 67, 68; 67, 69; 68, identifier:candidate_path_list; 69, identifier:candidate_name_list; 70, else_clause; 70, 71; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:candidate_path_list_; 75, identifier:candidate_path_list; 76, if_statement; 76, 77; 76, 80; 77, comparison_operator:is; 77, 78; 77, 79; 78, identifier:priority_paths; 79, None; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:candidate_path_list_; 84, binary_operator:+; 84, 85; 84, 86; 85, identifier:priority_paths; 86, identifier:candidate_path_list_; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:return_path; 90, None; 91, for_statement; 91, 92; 91, 93; 91, 94; 92, identifier:path; 93, identifier:candidate_path_list_; 94, block; 94, 95; 95, if_statement; 95, 96; 95, 104; 96, boolean_operator:and; 96, 97; 96, 100; 97, comparison_operator:is; 97, 98; 97, 99; 98, identifier:path; 99, None; 100, call; 100, 101; 100, 102; 101, identifier:exists; 102, argument_list; 102, 103; 103, identifier:path; 104, block; 104, 105; 104, 123; 104, 135; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:>=; 106, 107; 106, 108; 107, identifier:verbose; 108, integer:2; 109, block; 109, 110; 109, 118; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:print; 113, argument_list; 113, 114; 114, binary_operator:%; 114, 115; 114, 116; 115, string:'[search_candidate_paths] Found candidate directory %r'; 116, tuple; 116, 117; 117, identifier:path; 118, expression_statement; 118, 119; 119, call; 119, 120; 119, 121; 120, identifier:print; 121, argument_list; 121, 122; 122, string:'[search_candidate_paths] ... checking for approprate structure'; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:subpath_list; 126, list_comprehension; 126, 127; 126, 132; 127, call; 127, 128; 127, 129; 128, identifier:join; 129, argument_list; 129, 130; 129, 131; 130, identifier:path; 131, identifier:subpath; 132, for_in_clause; 132, 133; 132, 134; 133, identifier:subpath; 134, identifier:required_subpaths; 135, if_statement; 135, 136; 135, 151; 136, call; 136, 137; 136, 138; 137, identifier:all; 138, generator_expression; 138, 139; 138, 148; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:ut; 142, identifier:checkpath; 143, argument_list; 143, 144; 143, 145; 144, identifier:path_; 145, keyword_argument; 145, 146; 145, 147; 146, identifier:verbose; 147, identifier:verbose; 148, for_in_clause; 148, 149; 148, 150; 149, identifier:path_; 150, identifier:subpath_list; 151, block; 151, 152; 151, 156; 151, 166; 151, 168; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:return_path; 155, identifier:path; 156, if_statement; 156, 157; 156, 160; 157, comparison_operator:>=; 157, 158; 157, 159; 158, identifier:verbose; 159, integer:2; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 164; 163, identifier:print; 164, argument_list; 164, 165; 165, string:'[search_candidate_paths] Found acceptable path'; 166, return_statement; 166, 167; 167, identifier:return_path; 168, break_statement; 169, if_statement; 169, 170; 169, 173; 170, comparison_operator:>=; 170, 171; 170, 172; 171, identifier:verbose; 172, integer:1; 173, block; 173, 174; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 177; 176, identifier:print; 177, argument_list; 177, 178; 178, string:'[search_candidate_paths] Failed to find acceptable path'; 179, return_statement; 179, 180; 180, identifier:return_path | def search_candidate_paths(candidate_path_list, candidate_name_list=None,
priority_paths=None, required_subpaths=[],
verbose=None):
import utool as ut
if verbose is None:
verbose = 0 if QUIET else 1
if verbose >= 1:
print('[search_candidate_paths] Searching for candidate paths')
if candidate_name_list is not None:
candidate_path_list_ = [join(dpath, fname) for dpath, fname in
itertools.product(candidate_path_list,
candidate_name_list)]
else:
candidate_path_list_ = candidate_path_list
if priority_paths is not None:
candidate_path_list_ = priority_paths + candidate_path_list_
return_path = None
for path in candidate_path_list_:
if path is not None and exists(path):
if verbose >= 2:
print('[search_candidate_paths] Found candidate directory %r' % (path,))
print('[search_candidate_paths] ... checking for approprate structure')
subpath_list = [join(path, subpath) for subpath in required_subpaths]
if all(ut.checkpath(path_, verbose=verbose) for path_ in subpath_list):
return_path = path
if verbose >= 2:
print('[search_candidate_paths] Found acceptable path')
return return_path
break
if verbose >= 1:
print('[search_candidate_paths] Failed to find acceptable path')
return return_path |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:symlink; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:real_path; 5, identifier:link_path; 6, default_parameter; 6, 7; 6, 8; 7, identifier:overwrite; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:on_error; 11, string:'raise'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:verbose; 14, integer:2; 15, block; 15, 16; 15, 23; 15, 30; 15, 44; 15, 132; 15, 213; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:path; 19, call; 19, 20; 19, 21; 20, identifier:normpath; 21, argument_list; 21, 22; 22, identifier:real_path; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:link; 26, call; 26, 27; 26, 28; 27, identifier:normpath; 28, argument_list; 28, 29; 29, identifier:link_path; 30, if_statement; 30, 31; 30, 32; 31, identifier:verbose; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:print; 36, argument_list; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, string:'[util_path] Creating symlink: path={} link={}'; 40, identifier:format; 41, argument_list; 41, 42; 41, 43; 42, identifier:path; 43, identifier:link; 44, if_statement; 44, 45; 44, 53; 45, call; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:os; 49, identifier:path; 50, identifier:islink; 51, argument_list; 51, 52; 52, identifier:link; 53, block; 53, 54; 53, 62; 53, 71; 53, 104; 53, 114; 54, if_statement; 54, 55; 54, 56; 55, identifier:verbose; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:print; 60, argument_list; 60, 61; 61, string:'[util_path] symlink already exists'; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:os_readlink; 65, call; 65, 66; 65, 67; 66, identifier:getattr; 67, argument_list; 67, 68; 67, 69; 67, 70; 68, identifier:os; 69, string:"readlink"; 70, None; 71, if_statement; 71, 72; 71, 76; 71, 97; 72, call; 72, 73; 72, 74; 73, identifier:callable; 74, argument_list; 74, 75; 75, identifier:os_readlink; 76, block; 76, 77; 77, if_statement; 77, 78; 77, 84; 78, comparison_operator:==; 78, 79; 78, 83; 79, call; 79, 80; 79, 81; 80, identifier:os_readlink; 81, argument_list; 81, 82; 82, identifier:link; 83, identifier:path; 84, block; 84, 85; 84, 95; 85, if_statement; 85, 86; 85, 89; 86, comparison_operator:>; 86, 87; 86, 88; 87, identifier:verbose; 88, integer:1; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:print; 93, argument_list; 93, 94; 94, string:'[path] ... and points to the right place'; 95, return_statement; 95, 96; 96, identifier:link; 97, else_clause; 97, 98; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:print; 102, argument_list; 102, 103; 103, string:'[util_path] Warning, symlinks are not implemented on windows'; 104, if_statement; 104, 105; 104, 108; 105, comparison_operator:>; 105, 106; 105, 107; 106, identifier:verbose; 107, integer:1; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:print; 112, argument_list; 112, 113; 113, string:'[util_path] ... but it points somewhere else'; 114, if_statement; 114, 115; 114, 116; 114, 125; 115, identifier:overwrite; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 120; 119, identifier:delete; 120, argument_list; 120, 121; 120, 122; 121, identifier:link; 122, comparison_operator:>; 122, 123; 122, 124; 123, identifier:verbose; 124, integer:1; 125, elif_clause; 125, 126; 125, 129; 126, comparison_operator:==; 126, 127; 126, 128; 127, identifier:on_error; 128, string:'ignore'; 129, block; 129, 130; 130, return_statement; 130, 131; 131, False; 132, try_statement; 132, 133; 132, 163; 133, block; 133, 134; 133, 143; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:os_symlink; 137, call; 137, 138; 137, 139; 138, identifier:getattr; 139, argument_list; 139, 140; 139, 141; 139, 142; 140, identifier:os; 141, string:"symlink"; 142, None; 143, if_statement; 143, 144; 143, 148; 143, 155; 144, call; 144, 145; 144, 146; 145, identifier:callable; 146, argument_list; 146, 147; 147, identifier:os_symlink; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:os_symlink; 152, argument_list; 152, 153; 152, 154; 153, identifier:path; 154, identifier:link; 155, else_clause; 155, 156; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:win_shortcut; 160, argument_list; 160, 161; 160, 162; 161, identifier:path; 162, identifier:link; 163, except_clause; 163, 164; 163, 168; 164, as_pattern; 164, 165; 164, 166; 165, identifier:Exception; 166, as_pattern_target; 166, 167; 167, identifier:ex; 168, block; 168, 169; 168, 174; 168, 182; 168, 190; 168, 197; 168, 209; 169, import_statement; 169, 170; 170, aliased_import; 170, 171; 170, 173; 171, dotted_name; 171, 172; 172, identifier:utool; 173, identifier:ut; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 177; 176, identifier:checkpath; 177, argument_list; 177, 178; 177, 179; 178, identifier:link; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:verbose; 181, True; 182, expression_statement; 182, 183; 183, call; 183, 184; 183, 185; 184, identifier:checkpath; 185, argument_list; 185, 186; 185, 187; 186, identifier:path; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:verbose; 189, True; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:do_raise; 193, parenthesized_expression; 193, 194; 194, comparison_operator:==; 194, 195; 194, 196; 195, identifier:on_error; 196, string:'raise'; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:ut; 201, identifier:printex; 202, argument_list; 202, 203; 202, 204; 202, 205; 203, identifier:ex; 204, string:'[util_path] error making symlink'; 205, keyword_argument; 205, 206; 205, 207; 206, identifier:iswarning; 207, not_operator; 207, 208; 208, identifier:do_raise; 209, if_statement; 209, 210; 209, 211; 210, identifier:do_raise; 211, block; 211, 212; 212, raise_statement; 213, return_statement; 213, 214; 214, identifier:link | def symlink(real_path, link_path, overwrite=False, on_error='raise',
verbose=2):
path = normpath(real_path)
link = normpath(link_path)
if verbose:
print('[util_path] Creating symlink: path={} link={}'.format(path, link))
if os.path.islink(link):
if verbose:
print('[util_path] symlink already exists')
os_readlink = getattr(os, "readlink", None)
if callable(os_readlink):
if os_readlink(link) == path:
if verbose > 1:
print('[path] ... and points to the right place')
return link
else:
print('[util_path] Warning, symlinks are not implemented on windows')
if verbose > 1:
print('[util_path] ... but it points somewhere else')
if overwrite:
delete(link, verbose > 1)
elif on_error == 'ignore':
return False
try:
os_symlink = getattr(os, "symlink", None)
if callable(os_symlink):
os_symlink(path, link)
else:
win_shortcut(path, link)
except Exception as ex:
import utool as ut
checkpath(link, verbose=True)
checkpath(path, verbose=True)
do_raise = (on_error == 'raise')
ut.printex(ex, '[util_path] error making symlink',
iswarning=not do_raise)
if do_raise:
raise
return link |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:view_directory; 3, parameters; 3, 4; 3, 7; 3, 10; 4, default_parameter; 4, 5; 4, 6; 5, identifier:dname; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:fname; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:verbose; 12, True; 13, block; 13, 14; 13, 20; 13, 26; 13, 44; 13, 54; 13, 67; 13, 82; 13, 89; 13, 101; 13, 124; 13, 130; 13, 140; 14, import_from_statement; 14, 15; 14, 18; 15, dotted_name; 15, 16; 15, 17; 16, identifier:utool; 17, identifier:util_arg; 18, dotted_name; 18, 19; 19, identifier:STRICT; 20, import_from_statement; 20, 21; 20, 24; 21, dotted_name; 21, 22; 21, 23; 22, identifier:utool; 23, identifier:util_path; 24, dotted_name; 24, 25; 25, identifier:checkpath; 26, if_statement; 26, 27; 26, 36; 27, boolean_operator:and; 27, 28; 27, 29; 28, identifier:HAVE_PATHLIB; 29, call; 29, 30; 29, 31; 30, identifier:isinstance; 31, argument_list; 31, 32; 31, 33; 32, identifier:dname; 33, attribute; 33, 34; 33, 35; 34, identifier:pathlib; 35, identifier:Path; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:dname; 40, call; 40, 41; 40, 42; 41, identifier:str; 42, argument_list; 42, 43; 43, identifier:dname; 44, if_statement; 44, 45; 44, 46; 45, identifier:verbose; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:print; 50, argument_list; 50, 51; 51, binary_operator:%; 51, 52; 51, 53; 52, string:'[cplat] view_directory(%r) '; 53, identifier:dname; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:dname; 57, conditional_expression:if; 57, 58; 57, 63; 57, 66; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:os; 61, identifier:getcwd; 62, argument_list; 63, comparison_operator:is; 63, 64; 63, 65; 64, identifier:dname; 65, None; 66, identifier:dname; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:open_prog; 70, subscript; 70, 71; 70, 81; 71, dictionary; 71, 72; 71, 75; 71, 78; 72, pair; 72, 73; 72, 74; 73, string:'win32'; 74, string:'explorer.exe'; 75, pair; 75, 76; 75, 77; 76, string:'linux'; 77, string:'nautilus'; 78, pair; 78, 79; 78, 80; 79, string:'darwin'; 80, string:'open'; 81, identifier:OS_TYPE; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:dname; 85, call; 85, 86; 85, 87; 86, identifier:normpath; 87, argument_list; 87, 88; 88, identifier:dname; 89, if_statement; 89, 90; 89, 91; 90, identifier:STRICT; 91, block; 91, 92; 92, assert_statement; 92, 93; 92, 100; 93, call; 93, 94; 93, 95; 94, identifier:checkpath; 95, argument_list; 95, 96; 95, 97; 96, identifier:dname; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:verbose; 99, identifier:verbose; 100, string:'directory doesnt exit'; 101, if_statement; 101, 102; 101, 109; 101, 118; 102, boolean_operator:and; 102, 103; 102, 106; 103, comparison_operator:is; 103, 104; 103, 105; 104, identifier:fname; 105, None; 106, comparison_operator:==; 106, 107; 106, 108; 107, identifier:OS_TYPE; 108, string:'linux'; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:arg; 113, call; 113, 114; 113, 115; 114, identifier:join; 115, argument_list; 115, 116; 115, 117; 116, identifier:dname; 117, identifier:fname; 118, else_clause; 118, 119; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:arg; 123, identifier:dname; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:args; 127, tuple; 127, 128; 127, 129; 128, identifier:open_prog; 129, identifier:arg; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 133; 132, identifier:print; 133, argument_list; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:subprocess; 137, identifier:list2cmdline; 138, argument_list; 138, 139; 139, identifier:args; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:subprocess; 144, identifier:Popen; 145, argument_list; 145, 146; 146, identifier:args | def view_directory(dname=None, fname=None, verbose=True):
from utool.util_arg import STRICT
from utool.util_path import checkpath
if HAVE_PATHLIB and isinstance(dname, pathlib.Path):
dname = str(dname)
if verbose:
print('[cplat] view_directory(%r) ' % dname)
dname = os.getcwd() if dname is None else dname
open_prog = {
'win32': 'explorer.exe',
'linux': 'nautilus',
'darwin': 'open'
}[OS_TYPE]
dname = normpath(dname)
if STRICT:
assert checkpath(dname, verbose=verbose), 'directory doesnt exit'
if fname is not None and OS_TYPE == 'linux':
arg = join(dname, fname)
else:
arg = dname
args = (open_prog, arg)
print(subprocess.list2cmdline(args))
subprocess.Popen(args) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:__parse_cmd_args; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:args; 5, identifier:sudo; 6, identifier:shell; 7, block; 7, 8; 7, 36; 7, 229; 7, 265; 7, 301; 8, if_statement; 8, 9; 8, 29; 9, boolean_operator:and; 9, 10; 9, 22; 10, boolean_operator:and; 10, 11; 10, 16; 11, call; 11, 12; 11, 13; 12, identifier:isinstance; 13, argument_list; 13, 14; 13, 15; 14, identifier:args; 15, identifier:tuple; 16, comparison_operator:==; 16, 17; 16, 21; 17, call; 17, 18; 17, 19; 18, identifier:len; 19, argument_list; 19, 20; 20, identifier:args; 21, integer:1; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 28; 25, subscript; 25, 26; 25, 27; 26, identifier:args; 27, integer:0; 28, identifier:tuple; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:args; 33, subscript; 33, 34; 33, 35; 34, identifier:args; 35, integer:0; 36, if_statement; 36, 37; 36, 38; 36, 127; 37, identifier:shell; 38, block; 38, 39; 39, if_statement; 39, 40; 39, 47; 39, 49; 39, 74; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 44; 43, identifier:args; 44, attribute; 44, 45; 44, 46; 45, identifier:six; 46, identifier:string_types; 47, block; 47, 48; 48, pass_statement; 49, elif_clause; 49, 50; 49, 64; 50, boolean_operator:and; 50, 51; 50, 58; 51, call; 51, 52; 51, 53; 52, identifier:isinstance; 53, argument_list; 53, 54; 53, 55; 54, identifier:args; 55, tuple; 55, 56; 55, 57; 56, identifier:list; 57, identifier:tuple; 58, comparison_operator:>; 58, 59; 58, 63; 59, call; 59, 60; 59, 61; 60, identifier:len; 61, argument_list; 61, 62; 62, identifier:args; 63, integer:1; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:args; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, string:' '; 71, identifier:join; 72, argument_list; 72, 73; 73, identifier:args; 74, elif_clause; 74, 75; 74, 89; 75, boolean_operator:and; 75, 76; 75, 83; 76, call; 76, 77; 76, 78; 77, identifier:isinstance; 78, argument_list; 78, 79; 78, 80; 79, identifier:args; 80, tuple; 80, 81; 80, 82; 81, identifier:list; 82, identifier:tuple; 83, comparison_operator:==; 83, 84; 83, 88; 84, call; 84, 85; 84, 86; 85, identifier:len; 86, argument_list; 86, 87; 87, identifier:args; 88, integer:1; 89, block; 89, 90; 90, if_statement; 90, 91; 90, 100; 90, 110; 91, call; 91, 92; 91, 93; 92, identifier:isinstance; 93, argument_list; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:args; 96, integer:0; 97, tuple; 97, 98; 97, 99; 98, identifier:tuple; 99, identifier:list; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:args; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, string:' '; 107, identifier:join; 108, argument_list; 108, 109; 109, identifier:args; 110, elif_clause; 110, 111; 110, 120; 111, call; 111, 112; 111, 113; 112, identifier:isinstance; 113, argument_list; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:args; 116, integer:0; 117, attribute; 117, 118; 117, 119; 118, identifier:six; 119, identifier:string_types; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:args; 124, subscript; 124, 125; 124, 126; 125, identifier:args; 126, integer:0; 127, else_clause; 127, 128; 128, block; 128, 129; 129, if_statement; 129, 130; 129, 137; 129, 151; 130, call; 130, 131; 130, 132; 131, identifier:isinstance; 132, argument_list; 132, 133; 132, 134; 133, identifier:args; 134, attribute; 134, 135; 134, 136; 135, identifier:six; 136, identifier:string_types; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:args; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:shlex; 144, identifier:split; 145, argument_list; 145, 146; 145, 147; 146, identifier:args; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:posix; 149, not_operator; 149, 150; 150, identifier:WIN32; 151, elif_clause; 151, 152; 151, 159; 152, call; 152, 153; 152, 154; 153, identifier:isinstance; 154, argument_list; 154, 155; 154, 156; 155, identifier:args; 156, tuple; 156, 157; 156, 158; 157, identifier:list; 158, identifier:tuple; 159, block; 159, 160; 160, if_statement; 160, 161; 160, 167; 160, 175; 161, comparison_operator:>; 161, 162; 161, 166; 162, call; 162, 163; 162, 164; 163, identifier:len; 164, argument_list; 164, 165; 165, identifier:args; 166, integer:1; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:args; 171, call; 171, 172; 171, 173; 172, identifier:tuple; 173, argument_list; 173, 174; 174, identifier:args; 175, elif_clause; 175, 176; 175, 182; 176, comparison_operator:==; 176, 177; 176, 181; 177, call; 177, 178; 177, 179; 178, identifier:len; 179, argument_list; 179, 180; 180, identifier:args; 181, integer:1; 182, block; 182, 183; 183, if_statement; 183, 184; 183, 193; 183, 203; 184, call; 184, 185; 184, 186; 185, identifier:isinstance; 186, argument_list; 186, 187; 186, 190; 187, subscript; 187, 188; 187, 189; 188, identifier:args; 189, integer:0; 190, tuple; 190, 191; 190, 192; 191, identifier:tuple; 192, identifier:list; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:args; 197, call; 197, 198; 197, 199; 198, identifier:tuple; 199, argument_list; 199, 200; 200, subscript; 200, 201; 200, 202; 201, identifier:args; 202, integer:0; 203, elif_clause; 203, 204; 203, 213; 204, call; 204, 205; 204, 206; 205, identifier:isinstance; 206, argument_list; 206, 207; 206, 210; 207, subscript; 207, 208; 207, 209; 208, identifier:args; 209, integer:0; 210, attribute; 210, 211; 210, 212; 211, identifier:six; 212, identifier:string_types; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:args; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:shlex; 220, identifier:split; 221, argument_list; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:args; 224, integer:0; 225, keyword_argument; 225, 226; 225, 227; 226, identifier:posix; 227, not_operator; 227, 228; 228, identifier:WIN32; 229, if_statement; 229, 230; 229, 233; 230, comparison_operator:is; 230, 231; 230, 232; 231, identifier:sudo; 232, True; 233, block; 233, 234; 234, if_statement; 234, 235; 234, 237; 234, 262; 235, not_operator; 235, 236; 236, identifier:WIN32; 237, block; 237, 238; 238, if_statement; 238, 239; 238, 240; 238, 247; 239, identifier:shell; 240, block; 240, 241; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:args; 244, binary_operator:+; 244, 245; 244, 246; 245, string:'sudo '; 246, identifier:args; 247, else_clause; 247, 248; 248, block; 248, 249; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:args; 252, binary_operator:+; 252, 253; 252, 258; 253, call; 253, 254; 253, 255; 254, identifier:tuple; 255, argument_list; 255, 256; 256, list:['sudo']; 256, 257; 257, string:'sudo'; 258, call; 258, 259; 258, 260; 259, identifier:tuple; 260, argument_list; 260, 261; 261, identifier:args; 262, else_clause; 262, 263; 263, block; 263, 264; 264, pass_statement; 265, if_statement; 265, 266; 265, 267; 266, identifier:WIN32; 267, block; 267, 268; 268, if_statement; 268, 269; 268, 285; 269, boolean_operator:and; 269, 270; 269, 276; 270, comparison_operator:==; 270, 271; 270, 275; 271, call; 271, 272; 271, 273; 272, identifier:len; 273, argument_list; 273, 274; 274, identifier:args; 275, integer:1; 276, call; 276, 277; 276, 278; 277, identifier:isinstance; 278, argument_list; 278, 279; 278, 282; 279, subscript; 279, 280; 279, 281; 280, identifier:args; 281, integer:0; 282, attribute; 282, 283; 282, 284; 283, identifier:six; 284, identifier:string_types; 285, block; 285, 286; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:args; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:shlex; 292, identifier:split; 293, argument_list; 293, 294; 293, 297; 294, subscript; 294, 295; 294, 296; 295, identifier:args; 296, integer:0; 297, keyword_argument; 297, 298; 297, 299; 298, identifier:posix; 299, not_operator; 299, 300; 300, identifier:WIN32; 301, return_statement; 301, 302; 302, identifier:args | def __parse_cmd_args(args, sudo, shell):
if isinstance(args, tuple) and len(args) == 1 and isinstance(args[0], tuple):
args = args[0]
if shell:
if isinstance(args, six.string_types):
pass
elif isinstance(args, (list, tuple)) and len(args) > 1:
args = ' '.join(args)
elif isinstance(args, (list, tuple)) and len(args) == 1:
if isinstance(args[0], (tuple, list)):
args = ' '.join(args)
elif isinstance(args[0], six.string_types):
args = args[0]
else:
if isinstance(args, six.string_types):
args = shlex.split(args, posix=not WIN32)
elif isinstance(args, (list, tuple)):
if len(args) > 1:
args = tuple(args)
elif len(args) == 1:
if isinstance(args[0], (tuple, list)):
args = tuple(args[0])
elif isinstance(args[0], six.string_types):
args = shlex.split(args[0], posix=not WIN32)
if sudo is True:
if not WIN32:
if shell:
args = 'sudo ' + args
else:
args = tuple(['sudo']) + tuple(args)
else:
pass
if WIN32:
if len(args) == 1 and isinstance(args[0], six.string_types):
args = shlex.split(args[0], posix=not WIN32)
return args |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:cmd2; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:command; 5, default_parameter; 5, 6; 5, 7; 6, identifier:shell; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:detatch; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:verbose; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:verbout; 16, None; 17, block; 17, 18; 17, 21; 17, 35; 17, 48; 17, 57; 17, 68; 17, 101; 17, 126; 17, 274; 17, 284; 18, import_statement; 18, 19; 19, dotted_name; 19, 20; 20, identifier:shlex; 21, if_statement; 21, 22; 21, 29; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 26; 25, identifier:command; 26, tuple; 26, 27; 26, 28; 27, identifier:list; 28, identifier:tuple; 29, block; 29, 30; 30, raise_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:ValueError; 33, argument_list; 33, 34; 34, string:'command tuple not supported yet'; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:args; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:shlex; 41, identifier:split; 42, argument_list; 42, 43; 42, 44; 43, identifier:command; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:posix; 46, not_operator; 46, 47; 47, identifier:WIN32; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:verbose; 51, True; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:verbose; 56, integer:2; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:verbout; 60, None; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:verbout; 65, comparison_operator:>=; 65, 66; 65, 67; 66, identifier:verbose; 67, integer:1; 68, if_statement; 68, 69; 68, 72; 69, comparison_operator:>=; 69, 70; 69, 71; 70, identifier:verbose; 71, integer:2; 72, block; 72, 73; 72, 78; 72, 83; 72, 88; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:print; 76, argument_list; 76, 77; 77, string:'+=== START CMD2 ==='; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:print; 81, argument_list; 81, 82; 82, string:'Command:'; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:print; 86, argument_list; 86, 87; 87, identifier:command; 88, if_statement; 88, 89; 88, 90; 89, identifier:verbout; 90, block; 90, 91; 90, 96; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:print; 94, argument_list; 94, 95; 95, string:'----'; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:print; 99, argument_list; 99, 100; 100, string:'Stdout:'; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:proc; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:subprocess; 107, identifier:Popen; 108, argument_list; 108, 109; 108, 110; 108, 115; 108, 120; 108, 123; 109, identifier:args; 110, keyword_argument; 110, 111; 110, 112; 111, identifier:stdout; 112, attribute; 112, 113; 112, 114; 113, identifier:subprocess; 114, identifier:PIPE; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:stderr; 117, attribute; 117, 118; 117, 119; 118, identifier:subprocess; 119, identifier:STDOUT; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:shell; 122, identifier:shell; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:universal_newlines; 125, True; 126, if_statement; 126, 127; 126, 128; 126, 136; 127, identifier:detatch; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:info; 132, dictionary; 132, 133; 133, pair; 133, 134; 133, 135; 134, string:'proc'; 135, identifier:proc; 136, else_clause; 136, 137; 137, block; 137, 138; 137, 146; 137, 154; 137, 158; 137, 201; 137, 243; 137, 253; 137, 261; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:write_fn; 141, attribute; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:sys; 144, identifier:stdout; 145, identifier:write; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:flush_fn; 149, attribute; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:sys; 152, identifier:stdout; 153, identifier:flush; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:logged_out; 157, list:[]; 158, for_statement; 158, 159; 158, 160; 158, 164; 159, identifier:line; 160, call; 160, 161; 160, 162; 161, identifier:_run_process; 162, argument_list; 162, 163; 163, identifier:proc; 164, block; 164, 165; 164, 174; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:line_; 168, conditional_expression:if; 168, 169; 168, 170; 168, 173; 169, identifier:line; 170, attribute; 170, 171; 170, 172; 171, identifier:six; 172, identifier:PY2; 173, identifier:line; 174, if_statement; 174, 175; 174, 181; 175, comparison_operator:>; 175, 176; 175, 180; 176, call; 176, 177; 176, 178; 177, identifier:len; 178, argument_list; 178, 179; 179, identifier:line_; 180, integer:0; 181, block; 181, 182; 181, 194; 182, if_statement; 182, 183; 182, 184; 183, identifier:verbout; 184, block; 184, 185; 184, 190; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 188; 187, identifier:write_fn; 188, argument_list; 188, 189; 189, identifier:line_; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 193; 192, identifier:flush_fn; 193, argument_list; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:logged_out; 198, identifier:append; 199, argument_list; 199, 200; 200, identifier:line; 201, try_statement; 201, 202; 201, 217; 202, block; 202, 203; 202, 208; 203, import_from_statement; 203, 204; 203, 206; 204, dotted_name; 204, 205; 205, identifier:utool; 206, dotted_name; 206, 207; 207, identifier:util_str; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:out; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, string:''; 214, identifier:join; 215, argument_list; 215, 216; 216, identifier:logged_out; 217, except_clause; 217, 218; 217, 219; 218, identifier:UnicodeDecodeError; 219, block; 219, 220; 219, 225; 219, 234; 220, import_from_statement; 220, 221; 220, 223; 221, dotted_name; 221, 222; 222, identifier:utool; 223, dotted_name; 223, 224; 224, identifier:util_str; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:logged_out; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:util_str; 231, identifier:ensure_unicode_strlist; 232, argument_list; 232, 233; 233, identifier:logged_out; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:out; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, string:''; 240, identifier:join; 241, argument_list; 241, 242; 242, identifier:logged_out; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 248; 245, tuple_pattern; 245, 246; 245, 247; 246, identifier:out_; 247, identifier:err; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:proc; 251, identifier:communicate; 252, argument_list; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:ret; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:proc; 259, identifier:wait; 260, argument_list; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:info; 264, dictionary; 264, 265; 264, 268; 264, 271; 265, pair; 265, 266; 265, 267; 266, string:'out'; 267, identifier:out; 268, pair; 268, 269; 268, 270; 269, string:'err'; 270, identifier:err; 271, pair; 271, 272; 271, 273; 272, string:'ret'; 273, identifier:ret; 274, if_statement; 274, 275; 274, 278; 275, comparison_operator:>=; 275, 276; 275, 277; 276, identifier:verbose; 277, integer:2; 278, block; 278, 279; 279, expression_statement; 279, 280; 280, call; 280, 281; 280, 282; 281, identifier:print; 282, argument_list; 282, 283; 283, string:'L___ END CMD2 ___'; 284, return_statement; 284, 285; 285, identifier:info | def cmd2(command, shell=False, detatch=False, verbose=False, verbout=None):
import shlex
if isinstance(command, (list, tuple)):
raise ValueError('command tuple not supported yet')
args = shlex.split(command, posix=not WIN32)
if verbose is True:
verbose = 2
if verbout is None:
verbout = verbose >= 1
if verbose >= 2:
print('+=== START CMD2 ===')
print('Command:')
print(command)
if verbout:
print('----')
print('Stdout:')
proc = subprocess.Popen(args, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT, shell=shell,
universal_newlines=True)
if detatch:
info = {'proc': proc}
else:
write_fn = sys.stdout.write
flush_fn = sys.stdout.flush
logged_out = []
for line in _run_process(proc):
line_ = line if six.PY2 else line
if len(line_) > 0:
if verbout:
write_fn(line_)
flush_fn()
logged_out.append(line)
try:
from utool import util_str
out = ''.join(logged_out)
except UnicodeDecodeError:
from utool import util_str
logged_out = util_str.ensure_unicode_strlist(logged_out)
out = ''.join(logged_out)
(out_, err) = proc.communicate()
ret = proc.wait()
info = {
'out': out,
'err': err,
'ret': ret,
}
if verbose >= 2:
print('L___ END CMD2 ___')
return info |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:search_env_paths; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:fname; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key_list; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:verbose; 10, None; 11, block; 11, 12; 11, 14; 11, 19; 11, 52; 11, 61; 11, 103; 12, expression_statement; 12, 13; 13, identifier:r; 14, import_statement; 14, 15; 15, aliased_import; 15, 16; 15, 18; 16, dotted_name; 16, 17; 17, identifier:utool; 18, identifier:ut; 19, if_statement; 19, 20; 19, 23; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:key_list; 22, None; 23, block; 23, 24; 23, 44; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:key_list; 27, list_comprehension; 27, 28; 27, 29; 27, 34; 28, identifier:key; 29, for_in_clause; 29, 30; 29, 31; 30, identifier:key; 31, attribute; 31, 32; 31, 33; 32, identifier:os; 33, identifier:environ; 34, if_clause; 34, 35; 35, comparison_operator:>; 35, 36; 35, 42; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:key; 39, identifier:find; 40, argument_list; 40, 41; 41, string:'PATH'; 42, unary_operator:-; 42, 43; 43, integer:1; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:print; 47, argument_list; 47, 48; 48, binary_operator:%; 48, 49; 48, 50; 49, string:'key_list = %r'; 50, tuple; 50, 51; 51, identifier:key_list; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:found; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:ut; 58, identifier:ddict; 59, argument_list; 59, 60; 60, identifier:list; 61, for_statement; 61, 62; 61, 63; 61, 64; 62, identifier:key; 63, identifier:key_list; 64, block; 64, 65; 64, 80; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:dpath_list; 68, call; 68, 69; 68, 76; 69, attribute; 69, 70; 69, 75; 70, subscript; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:os; 73, identifier:environ; 74, identifier:key; 75, identifier:split; 76, argument_list; 76, 77; 77, attribute; 77, 78; 77, 79; 78, identifier:os; 79, identifier:pathsep; 80, for_statement; 80, 81; 80, 82; 80, 83; 81, identifier:dpath; 82, identifier:dpath_list; 83, block; 83, 84; 83, 94; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:matches; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:ut; 90, identifier:glob; 91, argument_list; 91, 92; 91, 93; 92, identifier:dpath; 93, identifier:fname; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:found; 99, identifier:key; 100, identifier:extend; 101, argument_list; 101, 102; 102, identifier:matches; 103, return_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:dict; 106, argument_list; 106, 107; 107, identifier:found | def search_env_paths(fname, key_list=None, verbose=None):
r
import utool as ut
if key_list is None:
key_list = [key for key in os.environ if key.find('PATH') > -1]
print('key_list = %r' % (key_list,))
found = ut.ddict(list)
for key in key_list:
dpath_list = os.environ[key].split(os.pathsep)
for dpath in dpath_list:
matches = ut.glob(dpath, fname)
found[key].extend(matches)
return dict(found) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:partition_varied_cfg_list; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:cfg_list; 5, default_parameter; 5, 6; 5, 7; 6, identifier:default_cfg; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:recursive; 10, False; 11, block; 11, 12; 11, 14; 11, 19; 11, 49; 11, 60; 11, 78; 11, 185; 12, expression_statement; 12, 13; 13, identifier:r; 14, import_statement; 14, 15; 15, aliased_import; 15, 16; 15, 18; 16, dotted_name; 16, 17; 17, identifier:utool; 18, identifier:ut; 19, if_statement; 19, 20; 19, 23; 19, 34; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:default_cfg; 22, None; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:nonvaried_cfg; 27, call; 27, 28; 27, 29; 28, identifier:reduce; 29, argument_list; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:ut; 32, identifier:dict_intersection; 33, identifier:cfg_list; 34, else_clause; 34, 35; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:nonvaried_cfg; 39, call; 39, 40; 39, 41; 40, identifier:reduce; 41, argument_list; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:ut; 44, identifier:dict_intersection; 45, binary_operator:+; 45, 46; 45, 48; 46, list:[default_cfg]; 46, 47; 47, identifier:default_cfg; 48, identifier:cfg_list; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:nonvaried_keys; 52, call; 52, 53; 52, 54; 53, identifier:list; 54, argument_list; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:nonvaried_cfg; 58, identifier:keys; 59, argument_list; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:varied_cfg_list; 63, list_comprehension; 63, 64; 63, 75; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:ut; 67, identifier:delete_dict_keys; 68, argument_list; 68, 69; 68, 74; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:cfg; 72, identifier:copy; 73, argument_list; 74, identifier:nonvaried_keys; 75, for_in_clause; 75, 76; 75, 77; 76, identifier:cfg; 77, identifier:cfg_list; 78, if_statement; 78, 79; 78, 80; 79, identifier:recursive; 80, block; 80, 81; 80, 98; 80, 116; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:varied_keys; 84, call; 84, 85; 84, 86; 85, identifier:list; 86, argument_list; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:set; 89, argument_list; 89, 90; 90, list_comprehension; 90, 91; 90, 92; 90, 95; 91, identifier:key; 92, for_in_clause; 92, 93; 92, 94; 93, identifier:cfg; 94, identifier:varied_cfg_list; 95, for_in_clause; 95, 96; 95, 97; 96, identifier:key; 97, identifier:cfg; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:varied_vals_list; 101, list_comprehension; 101, 102; 101, 113; 102, list_comprehension; 102, 103; 102, 106; 102, 109; 103, subscript; 103, 104; 103, 105; 104, identifier:cfg; 105, identifier:key; 106, for_in_clause; 106, 107; 106, 108; 107, identifier:cfg; 108, identifier:varied_cfg_list; 109, if_clause; 109, 110; 110, comparison_operator:in; 110, 111; 110, 112; 111, identifier:key; 112, identifier:cfg; 113, for_in_clause; 113, 114; 113, 115; 114, identifier:key; 115, identifier:varied_keys; 116, for_statement; 116, 117; 116, 120; 116, 125; 117, pattern_list; 117, 118; 117, 119; 118, identifier:key; 119, identifier:varied_vals; 120, call; 120, 121; 120, 122; 121, identifier:zip; 122, argument_list; 122, 123; 122, 124; 123, identifier:varied_keys; 124, identifier:varied_vals_list; 125, block; 125, 126; 126, if_statement; 126, 127; 126, 136; 127, comparison_operator:==; 127, 128; 127, 132; 128, call; 128, 129; 128, 130; 129, identifier:len; 130, argument_list; 130, 131; 131, identifier:varied_vals; 132, call; 132, 133; 132, 134; 133, identifier:len; 134, argument_list; 134, 135; 135, identifier:cfg_list; 136, block; 136, 137; 137, if_statement; 137, 138; 137, 150; 138, call; 138, 139; 138, 140; 139, identifier:all; 140, argument_list; 140, 141; 141, list_comprehension; 141, 142; 141, 147; 142, call; 142, 143; 142, 144; 143, identifier:isinstance; 144, argument_list; 144, 145; 144, 146; 145, identifier:val; 146, identifier:dict; 147, for_in_clause; 147, 148; 147, 149; 148, identifier:val; 149, identifier:varied_vals; 150, block; 150, 151; 150, 163; 150, 169; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 156; 153, pattern_list; 153, 154; 153, 155; 154, identifier:nonvaried_subdict; 155, identifier:varied_subdicts; 156, call; 156, 157; 156, 158; 157, identifier:partition_varied_cfg_list; 158, argument_list; 158, 159; 158, 160; 159, identifier:varied_vals; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:recursive; 162, identifier:recursive; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 168; 165, subscript; 165, 166; 165, 167; 166, identifier:nonvaried_cfg; 167, identifier:key; 168, identifier:nonvaried_subdict; 169, for_statement; 169, 170; 169, 173; 169, 178; 170, pattern_list; 170, 171; 170, 172; 171, identifier:cfg; 172, identifier:subdict; 173, call; 173, 174; 173, 175; 174, identifier:zip; 175, argument_list; 175, 176; 175, 177; 176, identifier:varied_cfg_list; 177, identifier:varied_subdicts; 178, block; 178, 179; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 184; 181, subscript; 181, 182; 181, 183; 182, identifier:cfg; 183, identifier:key; 184, identifier:subdict; 185, return_statement; 185, 186; 186, expression_list; 186, 187; 186, 188; 187, identifier:nonvaried_cfg; 188, identifier:varied_cfg_list | def partition_varied_cfg_list(cfg_list, default_cfg=None, recursive=False):
r
import utool as ut
if default_cfg is None:
nonvaried_cfg = reduce(ut.dict_intersection, cfg_list)
else:
nonvaried_cfg = reduce(ut.dict_intersection, [default_cfg] + cfg_list)
nonvaried_keys = list(nonvaried_cfg.keys())
varied_cfg_list = [
ut.delete_dict_keys(cfg.copy(), nonvaried_keys)
for cfg in cfg_list]
if recursive:
varied_keys = list(set([key for cfg in varied_cfg_list for key in cfg]))
varied_vals_list = [[cfg[key] for cfg in varied_cfg_list if key in cfg] for key in varied_keys]
for key, varied_vals in zip(varied_keys, varied_vals_list):
if len(varied_vals) == len(cfg_list):
if all([isinstance(val, dict) for val in varied_vals]):
nonvaried_subdict, varied_subdicts = partition_varied_cfg_list(varied_vals, recursive=recursive)
nonvaried_cfg[key] = nonvaried_subdict
for cfg, subdict in zip(varied_cfg_list, varied_subdicts):
cfg[key] = subdict
return nonvaried_cfg, varied_cfg_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 32; 2, function_name:parse_cfgstr_list2; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 4, identifier:cfgstr_list; 5, default_parameter; 5, 6; 5, 7; 6, identifier:named_defaults_dict; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:cfgtype; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:alias_keys; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:valid_keys; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:expand_nested; 19, True; 20, default_parameter; 20, 21; 20, 22; 21, identifier:strict; 22, True; 23, default_parameter; 23, 24; 23, 25; 24, identifier:special_join_dict; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:is_nestedcfgtype; 28, False; 29, default_parameter; 29, 30; 29, 31; 30, identifier:metadata; 31, None; 32, block; 32, 33; 32, 35; 32, 40; 32, 44; 32, 48; 32, 52; 32, 126; 32, 142; 32, 433; 33, expression_statement; 33, 34; 34, identifier:r; 35, import_statement; 35, 36; 36, aliased_import; 36, 37; 36, 39; 37, dotted_name; 37, 38; 38, identifier:utool; 39, identifier:ut; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:cfg_combos_list; 43, list:[]; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:cfgstr_list_; 47, list:[]; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:dyndef_named_defaults; 51, dictionary; 52, for_statement; 52, 53; 52, 54; 52, 55; 53, identifier:cfgstr; 54, identifier:cfgstr_list; 55, block; 55, 56; 56, if_statement; 56, 57; 56, 66; 56, 117; 57, comparison_operator:>; 57, 58; 57, 64; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:cfgstr; 61, identifier:find; 62, argument_list; 62, 63; 63, string:'=:'; 64, unary_operator:-; 64, 65; 65, integer:1; 66, block; 66, 67; 66, 77; 66, 84; 66, 93; 66, 104; 66, 111; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 73; 69, pattern_list; 69, 70; 69, 71; 69, 72; 70, identifier:cfgname; 71, identifier:cfgopt_strs; 72, identifier:subx; 73, call; 73, 74; 73, 75; 74, identifier:parse_cfgstr_name_options; 75, argument_list; 75, 76; 76, identifier:cfgstr; 77, assert_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:cfgname; 81, identifier:endswith; 82, argument_list; 82, 83; 83, string:'='; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:cfgname; 87, subscript; 87, 88; 87, 89; 88, identifier:cfgname; 89, slice; 89, 90; 89, 91; 90, colon; 91, unary_operator:-; 91, 92; 92, integer:1; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:base_cfg_list; 96, call; 96, 97; 96, 98; 97, identifier:lookup_base_cfg_list; 98, argument_list; 98, 99; 98, 100; 98, 101; 99, identifier:cfgname; 100, identifier:named_defaults_dict; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:metadata; 103, identifier:metadata; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:cfg_options; 107, call; 107, 108; 107, 109; 108, identifier:noexpand_parse_cfgstrs; 109, argument_list; 109, 110; 110, identifier:cfgopt_strs; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:dyndef_named_defaults; 115, identifier:cfgname; 116, identifier:cfg_options; 117, else_clause; 117, 118; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:cfgstr_list_; 123, identifier:append; 124, argument_list; 124, 125; 125, identifier:cfgstr; 126, if_statement; 126, 127; 126, 137; 127, boolean_operator:and; 127, 128; 127, 134; 128, comparison_operator:>; 128, 129; 128, 133; 129, call; 129, 130; 129, 131; 130, identifier:len; 131, argument_list; 131, 132; 132, identifier:dyndef_named_defaults; 133, integer:0; 134, comparison_operator:is; 134, 135; 134, 136; 135, identifier:named_defaults_dict; 136, None; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:named_defaults_dict; 141, identifier:dyndef_named_defaults; 142, for_statement; 142, 143; 142, 144; 142, 145; 143, identifier:cfgstr; 144, identifier:cfgstr_list_; 145, block; 145, 146; 145, 150; 145, 423; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:cfg_combos; 149, list:[]; 150, if_statement; 150, 151; 150, 160; 150, 260; 151, comparison_operator:>; 151, 152; 151, 158; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:cfgstr; 155, identifier:find; 156, argument_list; 156, 157; 157, string:'::'; 158, unary_operator:-; 158, 159; 159, integer:1; 160, block; 160, 161; 160, 170; 160, 201; 160, 221; 160, 241; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:special_cfgstr_list; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:cfgstr; 167, identifier:split; 168, argument_list; 168, 169; 169, string:'::'; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:special_combo_list; 173, call; 173, 174; 173, 175; 174, identifier:parse_cfgstr_list2; 175, argument_list; 175, 176; 175, 177; 175, 180; 175, 183; 175, 186; 175, 189; 175, 192; 175, 195; 175, 198; 176, identifier:special_cfgstr_list; 177, keyword_argument; 177, 178; 177, 179; 178, identifier:named_defaults_dict; 179, identifier:named_defaults_dict; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:cfgtype; 182, identifier:cfgtype; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:alias_keys; 185, identifier:alias_keys; 186, keyword_argument; 186, 187; 186, 188; 187, identifier:valid_keys; 188, identifier:valid_keys; 189, keyword_argument; 189, 190; 189, 191; 190, identifier:strict; 191, identifier:strict; 192, keyword_argument; 192, 193; 192, 194; 193, identifier:expand_nested; 194, identifier:expand_nested; 195, keyword_argument; 195, 196; 195, 197; 196, identifier:is_nestedcfgtype; 197, False; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:metadata; 200, identifier:metadata; 201, if_statement; 201, 202; 201, 205; 202, comparison_operator:is; 202, 203; 202, 204; 203, identifier:special_join_dict; 204, None; 205, block; 205, 206; 206, for_statement; 206, 207; 206, 208; 206, 209; 207, identifier:special_combo; 208, identifier:special_combo_list; 209, block; 209, 210; 210, for_statement; 210, 211; 210, 212; 210, 213; 211, identifier:cfg; 212, identifier:special_combo; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:cfg; 218, identifier:update; 219, argument_list; 219, 220; 220, identifier:special_join_dict; 221, if_statement; 221, 222; 221, 223; 221, 235; 222, identifier:is_nestedcfgtype; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:cfg_combo; 227, call; 227, 228; 227, 229; 228, identifier:tuple; 229, argument_list; 229, 230; 230, list_comprehension; 230, 231; 230, 232; 231, identifier:combo; 232, for_in_clause; 232, 233; 232, 234; 233, identifier:combo; 234, identifier:special_combo_list; 235, else_clause; 235, 236; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:cfg_combo; 240, identifier:special_combo_list; 241, if_statement; 241, 242; 241, 243; 241, 251; 242, identifier:expand_nested; 243, block; 243, 244; 244, expression_statement; 244, 245; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:cfg_combos; 248, identifier:extend; 249, argument_list; 249, 250; 250, identifier:cfg_combo; 251, else_clause; 251, 252; 252, block; 252, 253; 253, expression_statement; 253, 254; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:cfg_combos_list; 257, identifier:append; 258, argument_list; 258, 259; 259, identifier:cfg_combo; 260, else_clause; 260, 261; 261, block; 261, 262; 261, 272; 261, 304; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 268; 264, pattern_list; 264, 265; 264, 266; 264, 267; 265, identifier:cfgname; 266, identifier:cfgopt_strs; 267, identifier:subx; 268, call; 268, 269; 268, 270; 269, identifier:parse_cfgstr_name_options; 270, argument_list; 270, 271; 271, identifier:cfgstr; 272, try_statement; 272, 273; 272, 285; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:base_cfg_list; 277, call; 277, 278; 277, 279; 278, identifier:lookup_base_cfg_list; 279, argument_list; 279, 280; 279, 281; 279, 282; 280, identifier:cfgname; 281, identifier:named_defaults_dict; 282, keyword_argument; 282, 283; 282, 284; 283, identifier:metadata; 284, identifier:metadata; 285, except_clause; 285, 286; 285, 290; 286, as_pattern; 286, 287; 286, 288; 287, identifier:Exception; 288, as_pattern_target; 288, 289; 289, identifier:ex; 290, block; 290, 291; 290, 303; 291, expression_statement; 291, 292; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:ut; 295, identifier:printex; 296, argument_list; 296, 297; 296, 298; 297, identifier:ex; 298, keyword_argument; 298, 299; 298, 300; 299, identifier:keys; 300, list:['cfgstr_list', 'cfgstr_list_']; 300, 301; 300, 302; 301, string:'cfgstr_list'; 302, string:'cfgstr_list_'; 303, raise_statement; 304, for_statement; 304, 305; 304, 306; 304, 307; 305, identifier:base_cfg; 306, identifier:base_cfg_list; 307, block; 307, 308; 307, 316; 307, 324; 307, 332; 307, 340; 307, 348; 307, 359; 307, 367; 307, 375; 307, 396; 307, 404; 308, expression_statement; 308, 309; 309, call; 309, 310; 309, 311; 310, identifier:print; 311, argument_list; 311, 312; 312, binary_operator:%; 312, 313; 312, 314; 313, string:'cfgname = %r'; 314, tuple; 314, 315; 315, identifier:cfgname; 316, expression_statement; 316, 317; 317, call; 317, 318; 317, 319; 318, identifier:print; 319, argument_list; 319, 320; 320, binary_operator:%; 320, 321; 320, 322; 321, string:'cfgopt_strs = %r'; 322, tuple; 322, 323; 323, identifier:cfgopt_strs; 324, expression_statement; 324, 325; 325, call; 325, 326; 325, 327; 326, identifier:print; 327, argument_list; 327, 328; 328, binary_operator:%; 328, 329; 328, 330; 329, string:'base_cfg = %r'; 330, tuple; 330, 331; 331, identifier:base_cfg; 332, expression_statement; 332, 333; 333, call; 333, 334; 333, 335; 334, identifier:print; 335, argument_list; 335, 336; 336, binary_operator:%; 336, 337; 336, 338; 337, string:'alias_keys = %r'; 338, tuple; 338, 339; 339, identifier:alias_keys; 340, expression_statement; 340, 341; 341, call; 341, 342; 341, 343; 342, identifier:print; 343, argument_list; 343, 344; 344, binary_operator:%; 344, 345; 344, 346; 345, string:'cfgtype = %r'; 346, tuple; 346, 347; 347, identifier:cfgtype; 348, expression_statement; 348, 349; 349, call; 349, 350; 349, 351; 350, identifier:print; 351, argument_list; 351, 352; 352, binary_operator:%; 352, 353; 352, 354; 353, string:'offset = %r'; 354, tuple; 354, 355; 355, call; 355, 356; 355, 357; 356, identifier:len; 357, argument_list; 357, 358; 358, identifier:cfg_combos; 359, expression_statement; 359, 360; 360, call; 360, 361; 360, 362; 361, identifier:print; 362, argument_list; 362, 363; 363, binary_operator:%; 363, 364; 363, 365; 364, string:'valid_keys = %r'; 365, tuple; 365, 366; 366, identifier:valid_keys; 367, expression_statement; 367, 368; 368, call; 368, 369; 368, 370; 369, identifier:print; 370, argument_list; 370, 371; 371, binary_operator:%; 371, 372; 371, 373; 372, string:'strict = %r'; 373, tuple; 373, 374; 374, identifier:strict; 375, expression_statement; 375, 376; 376, assignment; 376, 377; 376, 378; 377, identifier:cfg_combo; 378, call; 378, 379; 378, 380; 379, identifier:customize_base_cfg; 380, argument_list; 380, 381; 380, 382; 380, 383; 380, 384; 380, 385; 380, 386; 380, 387; 380, 390; 381, identifier:cfgname; 382, identifier:cfgopt_strs; 383, identifier:base_cfg; 384, identifier:cfgtype; 385, identifier:alias_keys; 386, identifier:valid_keys; 387, keyword_argument; 387, 388; 387, 389; 388, identifier:strict; 389, identifier:strict; 390, keyword_argument; 390, 391; 390, 392; 391, identifier:offset; 392, call; 392, 393; 392, 394; 393, identifier:len; 394, argument_list; 394, 395; 395, identifier:cfg_combos; 396, if_statement; 396, 397; 396, 398; 397, identifier:is_nestedcfgtype; 398, block; 398, 399; 399, expression_statement; 399, 400; 400, assignment; 400, 401; 400, 402; 401, identifier:cfg_combo; 402, list:[cfg_combo]; 402, 403; 403, identifier:cfg_combo; 404, if_statement; 404, 405; 404, 406; 404, 414; 405, identifier:expand_nested; 406, block; 406, 407; 407, expression_statement; 407, 408; 408, call; 408, 409; 408, 412; 409, attribute; 409, 410; 409, 411; 410, identifier:cfg_combos; 411, identifier:extend; 412, argument_list; 412, 413; 413, identifier:cfg_combo; 414, else_clause; 414, 415; 415, block; 415, 416; 416, expression_statement; 416, 417; 417, call; 417, 418; 417, 421; 418, attribute; 418, 419; 418, 420; 419, identifier:cfg_combos_list; 420, identifier:append; 421, argument_list; 421, 422; 422, identifier:cfg_combo; 423, if_statement; 423, 424; 423, 425; 424, identifier:expand_nested; 425, block; 425, 426; 426, expression_statement; 426, 427; 427, call; 427, 428; 427, 431; 428, attribute; 428, 429; 428, 430; 429, identifier:cfg_combos_list; 430, identifier:append; 431, argument_list; 431, 432; 432, identifier:cfg_combos; 433, return_statement; 433, 434; 434, identifier:cfg_combos_list | def parse_cfgstr_list2(cfgstr_list, named_defaults_dict=None, cfgtype=None,
alias_keys=None, valid_keys=None, expand_nested=True,
strict=True, special_join_dict=None, is_nestedcfgtype=False,
metadata=None):
r
import utool as ut
cfg_combos_list = []
cfgstr_list_ = []
dyndef_named_defaults = {}
for cfgstr in cfgstr_list:
if cfgstr.find('=:') > -1:
cfgname, cfgopt_strs, subx = parse_cfgstr_name_options(cfgstr)
assert cfgname.endswith('=')
cfgname = cfgname[:-1]
base_cfg_list = lookup_base_cfg_list(cfgname,
named_defaults_dict,
metadata=metadata)
cfg_options = noexpand_parse_cfgstrs(cfgopt_strs)
dyndef_named_defaults[cfgname] = cfg_options
else:
cfgstr_list_.append(cfgstr)
if len(dyndef_named_defaults) > 0 and named_defaults_dict is None:
named_defaults_dict = dyndef_named_defaults
for cfgstr in cfgstr_list_:
cfg_combos = []
if cfgstr.find('::') > -1:
special_cfgstr_list = cfgstr.split('::')
special_combo_list = parse_cfgstr_list2(
special_cfgstr_list,
named_defaults_dict=named_defaults_dict, cfgtype=cfgtype,
alias_keys=alias_keys, valid_keys=valid_keys,
strict=strict, expand_nested=expand_nested,
is_nestedcfgtype=False, metadata=metadata)
if special_join_dict is not None:
for special_combo in special_combo_list:
for cfg in special_combo:
cfg.update(special_join_dict)
if is_nestedcfgtype:
cfg_combo = tuple([combo for combo in special_combo_list])
else:
cfg_combo = special_combo_list
if expand_nested:
cfg_combos.extend(cfg_combo)
else:
cfg_combos_list.append(cfg_combo)
else:
cfgname, cfgopt_strs, subx = parse_cfgstr_name_options(cfgstr)
try:
base_cfg_list = lookup_base_cfg_list(cfgname,
named_defaults_dict,
metadata=metadata)
except Exception as ex:
ut.printex(ex, keys=['cfgstr_list', 'cfgstr_list_'])
raise
for base_cfg in base_cfg_list:
print('cfgname = %r' % (cfgname,))
print('cfgopt_strs = %r' % (cfgopt_strs,))
print('base_cfg = %r' % (base_cfg,))
print('alias_keys = %r' % (alias_keys,))
print('cfgtype = %r' % (cfgtype,))
print('offset = %r' % (len(cfg_combos),))
print('valid_keys = %r' % (valid_keys,))
print('strict = %r' % (strict,))
cfg_combo = customize_base_cfg(
cfgname, cfgopt_strs, base_cfg, cfgtype, alias_keys,
valid_keys, strict=strict, offset=len(cfg_combos))
if is_nestedcfgtype:
cfg_combo = [cfg_combo]
if expand_nested:
cfg_combos.extend(cfg_combo)
else:
cfg_combos_list.append(cfg_combo)
if expand_nested:
cfg_combos_list.append(cfg_combos)
return cfg_combos_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:gridsearch_timer; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:func_list; 5, identifier:args_list; 6, default_parameter; 6, 7; 6, 8; 7, identifier:niters; 8, None; 9, dictionary_splat_pattern; 9, 10; 10, identifier:searchkw; 11, block; 11, 12; 11, 17; 11, 26; 11, 38; 11, 58; 11, 77; 11, 95; 11, 105; 11, 115; 11, 119; 11, 131; 11, 291; 11, 297; 11, 311; 11, 326; 11, 376; 11, 386; 12, import_statement; 12, 13; 13, aliased_import; 13, 14; 13, 16; 14, dotted_name; 14, 15; 15, identifier:utool; 16, identifier:ut; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:timings; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:ut; 23, identifier:ddict; 24, argument_list; 24, 25; 25, identifier:list; 26, if_statement; 26, 27; 26, 30; 27, comparison_operator:is; 27, 28; 27, 29; 28, identifier:niters; 29, None; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:niters; 34, call; 34, 35; 34, 36; 35, identifier:len; 36, argument_list; 36, 37; 37, identifier:args_list; 38, if_statement; 38, 39; 38, 45; 38, 50; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:ut; 42, identifier:is_funclike; 43, argument_list; 43, 44; 44, identifier:args_list; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:get_args; 49, identifier:args_list; 50, else_clause; 50, 51; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:get_args; 55, attribute; 55, 56; 55, 57; 56, identifier:args_list; 57, identifier:__getitem__; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:func_labels; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:searchkw; 64, identifier:get; 65, argument_list; 65, 66; 65, 67; 66, string:'func_labels'; 67, list_comprehension; 67, 68; 67, 74; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:ut; 71, identifier:get_funcname; 72, argument_list; 72, 73; 73, identifier:func; 74, for_in_clause; 74, 75; 74, 76; 75, identifier:func; 76, identifier:func_list; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:use_cache; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:searchkw; 83, identifier:get; 84, argument_list; 84, 85; 84, 86; 85, string:'use_cache'; 86, not_operator; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:ut; 90, identifier:get_argflag; 91, argument_list; 91, 92; 92, tuple; 92, 93; 92, 94; 93, string:'--nocache'; 94, string:'--nocache-time'; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:assert_eq; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:searchkw; 101, identifier:get; 102, argument_list; 102, 103; 102, 104; 103, string:'assert_eq'; 104, True; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:count_list; 108, call; 108, 109; 108, 110; 109, identifier:list; 110, argument_list; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:range; 113, argument_list; 113, 114; 114, identifier:niters; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:xlabel_list; 118, list:[]; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:cache; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:ut; 125, identifier:ShelfCacher; 126, argument_list; 126, 127; 126, 128; 127, string:'timeings.shelf'; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:enabled; 130, identifier:use_cache; 131, for_statement; 131, 132; 131, 133; 131, 142; 132, identifier:count; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:ut; 136, identifier:ProgressIter; 137, argument_list; 137, 138; 137, 139; 138, identifier:count_list; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:lbl; 141, string:'Testing Timeings'; 142, block; 142, 143; 142, 150; 142, 157; 142, 173; 142, 180; 142, 184; 142, 272; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:args_; 146, call; 146, 147; 146, 148; 147, identifier:get_args; 148, argument_list; 148, 149; 149, identifier:count; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:xlabel_list; 154, identifier:append; 155, argument_list; 155, 156; 156, identifier:args_; 157, if_statement; 157, 158; 157, 159; 158, True; 159, block; 159, 160; 160, if_statement; 160, 161; 160, 167; 161, not_operator; 161, 162; 162, call; 162, 163; 162, 164; 163, identifier:isinstance; 164, argument_list; 164, 165; 164, 166; 165, identifier:args_; 166, identifier:tuple; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:args_; 171, tuple; 171, 172; 172, identifier:args_; 173, assert_statement; 173, 174; 173, 179; 174, call; 174, 175; 174, 176; 175, identifier:isinstance; 176, argument_list; 176, 177; 176, 178; 177, identifier:args_; 178, identifier:tuple; 179, string:'args_ should be a tuple so it can be unpacked'; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:ret_list; 183, list:[]; 184, for_statement; 184, 185; 184, 186; 184, 187; 185, identifier:func_; 186, identifier:func_list; 187, block; 187, 188; 187, 263; 188, try_statement; 188, 189; 188, 214; 189, block; 189, 190; 189, 194; 189, 205; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:kwargs_; 193, dictionary; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:func_cachekey; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:ut; 200, identifier:get_func_result_cachekey; 201, argument_list; 201, 202; 201, 203; 201, 204; 202, identifier:func_; 203, identifier:args_; 204, identifier:kwargs_; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:ellapsed; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:cache; 211, identifier:load; 212, argument_list; 212, 213; 213, identifier:func_cachekey; 214, except_clause; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:ut; 217, identifier:CacheMissException; 218, block; 218, 219; 218, 249; 218, 255; 219, with_statement; 219, 220; 219, 233; 220, with_clause; 220, 221; 221, with_item; 221, 222; 222, as_pattern; 222, 223; 222, 231; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:ut; 226, identifier:Timer; 227, argument_list; 227, 228; 228, keyword_argument; 228, 229; 228, 230; 229, identifier:verbose; 230, False; 231, as_pattern_target; 231, 232; 232, identifier:t; 233, block; 233, 234; 233, 242; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:ret; 237, call; 237, 238; 237, 239; 238, identifier:func_; 239, argument_list; 239, 240; 240, list_splat; 240, 241; 241, identifier:args_; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:ret_list; 246, identifier:append; 247, argument_list; 247, 248; 248, identifier:ret; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:ellapsed; 252, attribute; 252, 253; 252, 254; 253, identifier:t; 254, identifier:ellapsed; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:cache; 259, identifier:save; 260, argument_list; 260, 261; 260, 262; 261, identifier:func_cachekey; 262, identifier:ellapsed; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 270; 265, attribute; 265, 266; 265, 269; 266, subscript; 266, 267; 266, 268; 267, identifier:timings; 268, identifier:func_; 269, identifier:append; 270, argument_list; 270, 271; 271, identifier:ellapsed; 272, if_statement; 272, 273; 272, 274; 273, identifier:assert_eq; 274, block; 274, 275; 275, expression_statement; 275, 276; 276, call; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:ut; 279, identifier:assert_all_eq; 280, argument_list; 280, 281; 281, call; 281, 282; 281, 283; 282, identifier:list; 283, argument_list; 283, 284; 284, call; 284, 285; 284, 286; 285, identifier:map; 286, argument_list; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:ut; 289, identifier:cachestr_repr; 290, identifier:ret_list; 291, expression_statement; 291, 292; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:cache; 295, identifier:close; 296, argument_list; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:count_to_xtick; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:searchkw; 303, identifier:get; 304, argument_list; 304, 305; 304, 306; 305, string:'count_to_xtick'; 306, lambda; 306, 307; 306, 310; 307, lambda_parameters; 307, 308; 307, 309; 308, identifier:x; 309, identifier:y; 310, identifier:x; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:xtick_list; 314, list_comprehension; 314, 315; 314, 323; 315, call; 315, 316; 315, 317; 316, identifier:count_to_xtick; 317, argument_list; 317, 318; 317, 319; 318, identifier:count; 319, call; 319, 320; 319, 321; 320, identifier:get_args; 321, argument_list; 321, 322; 322, identifier:count; 323, for_in_clause; 323, 324; 323, 325; 324, identifier:count; 325, identifier:count_list; 326, function_definition; 326, 327; 326, 328; 326, 329; 327, function_name:plot_timings; 328, parameters; 329, block; 329, 330; 329, 335; 329, 345; 329, 349; 329, 353; 329, 357; 330, import_statement; 330, 331; 331, aliased_import; 331, 332; 331, 334; 332, dotted_name; 332, 333; 333, identifier:plottool; 334, identifier:pt; 335, expression_statement; 335, 336; 336, assignment; 336, 337; 336, 338; 337, identifier:ydata_list; 338, call; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, identifier:ut; 341, identifier:dict_take; 342, argument_list; 342, 343; 342, 344; 343, identifier:timings; 344, identifier:func_list; 345, expression_statement; 345, 346; 346, assignment; 346, 347; 346, 348; 347, identifier:xdata; 348, identifier:xtick_list; 349, expression_statement; 349, 350; 350, assignment; 350, 351; 350, 352; 351, identifier:ylabel; 352, string:'seconds'; 353, expression_statement; 353, 354; 354, assignment; 354, 355; 354, 356; 355, identifier:xlabel; 356, string:'input size'; 357, expression_statement; 357, 358; 358, call; 358, 359; 358, 362; 359, attribute; 359, 360; 359, 361; 360, identifier:pt; 361, identifier:multi_plot; 362, argument_list; 362, 363; 362, 364; 362, 365; 362, 368; 362, 371; 362, 374; 363, identifier:xdata; 364, identifier:ydata_list; 365, keyword_argument; 365, 366; 365, 367; 366, identifier:label_list; 367, identifier:func_labels; 368, keyword_argument; 368, 369; 368, 370; 369, identifier:ylabel; 370, identifier:ylabel; 371, keyword_argument; 371, 372; 371, 373; 372, identifier:xlabel; 373, identifier:xlabel; 374, dictionary_splat; 374, 375; 375, identifier:searchkw; 376, expression_statement; 376, 377; 377, assignment; 377, 378; 377, 379; 378, identifier:time_result; 379, dictionary; 379, 380; 379, 383; 380, pair; 380, 381; 380, 382; 381, string:'plot_timings'; 382, identifier:plot_timings; 383, pair; 383, 384; 383, 385; 384, string:'timings'; 385, identifier:timings; 386, return_statement; 386, 387; 387, identifier:time_result | def gridsearch_timer(func_list, args_list, niters=None, **searchkw):
import utool as ut
timings = ut.ddict(list)
if niters is None:
niters = len(args_list)
if ut.is_funclike(args_list):
get_args = args_list
else:
get_args = args_list.__getitem__
func_labels = searchkw.get('func_labels', [ut.get_funcname(func) for func in func_list])
use_cache = searchkw.get('use_cache', not ut.get_argflag(('--nocache', '--nocache-time')))
assert_eq = searchkw.get('assert_eq', True)
count_list = list(range(niters))
xlabel_list = []
cache = ut.ShelfCacher('timeings.shelf', enabled=use_cache)
for count in ut.ProgressIter(count_list, lbl='Testing Timeings'):
args_ = get_args(count)
xlabel_list.append(args_)
if True:
if not isinstance(args_, tuple):
args_ = (args_,)
assert isinstance(args_, tuple), 'args_ should be a tuple so it can be unpacked'
ret_list = []
for func_ in func_list:
try:
kwargs_ = {}
func_cachekey = ut.get_func_result_cachekey(func_, args_, kwargs_)
ellapsed = cache.load(func_cachekey)
except ut.CacheMissException:
with ut.Timer(verbose=False) as t:
ret = func_(*args_)
ret_list.append(ret)
ellapsed = t.ellapsed
cache.save(func_cachekey, ellapsed)
timings[func_].append(ellapsed)
if assert_eq:
ut.assert_all_eq(list(map(ut.cachestr_repr, ret_list)))
cache.close()
count_to_xtick = searchkw.get('count_to_xtick', lambda x, y: x)
xtick_list = [count_to_xtick(count, get_args(count)) for count in count_list]
def plot_timings():
import plottool as pt
ydata_list = ut.dict_take(timings, func_list)
xdata = xtick_list
ylabel = 'seconds'
xlabel = 'input size'
pt.multi_plot(
xdata, ydata_list, label_list=func_labels,
ylabel=ylabel, xlabel=xlabel,
**searchkw
)
time_result = {
'plot_timings': plot_timings,
'timings': timings,
}
return time_result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:to_string_monkey; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:df; 5, default_parameter; 5, 6; 5, 7; 6, identifier:highlight_cols; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:latex; 10, False; 11, block; 11, 12; 12, try_statement; 12, 13; 12, 413; 13, block; 13, 14; 13, 19; 13, 24; 13, 29; 13, 32; 13, 59; 13, 92; 13, 98; 13, 111; 13, 126; 13, 151; 13, 248; 13, 265; 13, 288; 13, 305; 13, 373; 13, 379; 13, 389; 13, 411; 14, import_statement; 14, 15; 15, aliased_import; 15, 16; 15, 18; 16, dotted_name; 16, 17; 17, identifier:pandas; 18, identifier:pd; 19, import_statement; 19, 20; 20, aliased_import; 20, 21; 20, 23; 21, dotted_name; 21, 22; 22, identifier:utool; 23, identifier:ut; 24, import_statement; 24, 25; 25, aliased_import; 25, 26; 25, 28; 26, dotted_name; 26, 27; 27, identifier:numpy; 28, identifier:np; 29, import_statement; 29, 30; 30, dotted_name; 30, 31; 31, identifier:six; 32, if_statement; 32, 33; 32, 44; 33, boolean_operator:and; 33, 34; 33, 41; 34, call; 34, 35; 34, 36; 35, identifier:isinstance; 36, argument_list; 36, 37; 36, 38; 37, identifier:highlight_cols; 38, attribute; 38, 39; 38, 40; 39, identifier:six; 40, identifier:string_types; 41, comparison_operator:==; 41, 42; 41, 43; 42, identifier:highlight_cols; 43, string:'all'; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:highlight_cols; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:np; 51, identifier:arange; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, attribute; 56, 57; 56, 58; 57, identifier:df; 58, identifier:columns; 59, try_statement; 59, 60; 59, 74; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:self; 64, call; 64, 65; 64, 72; 65, attribute; 65, 66; 65, 71; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:pd; 69, identifier:formats; 70, identifier:format; 71, identifier:DataFrameFormatter; 72, argument_list; 72, 73; 73, identifier:df; 74, except_clause; 74, 75; 74, 76; 75, identifier:AttributeError; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:self; 80, call; 80, 81; 80, 90; 81, attribute; 81, 82; 81, 89; 82, attribute; 82, 83; 82, 88; 83, attribute; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:pd; 86, identifier:io; 87, identifier:formats; 88, identifier:format; 89, identifier:DataFrameFormatter; 90, argument_list; 90, 91; 91, identifier:df; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:highlight_cols; 97, identifier:highlight_cols; 98, function_definition; 98, 99; 98, 100; 98, 102; 99, function_name:monkey; 100, parameters; 100, 101; 101, identifier:self; 102, block; 102, 103; 103, return_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:monkey_to_str_columns; 106, argument_list; 106, 107; 106, 108; 107, identifier:self; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:latex; 110, identifier:latex; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:ut; 115, identifier:inject_func_as_method; 116, argument_list; 116, 117; 116, 118; 116, 119; 116, 120; 116, 123; 117, identifier:self; 118, identifier:monkey; 119, string:'_to_str_columns'; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:override; 122, True; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:force; 125, True; 126, function_definition; 126, 127; 126, 128; 126, 130; 127, function_name:strip_ansi; 128, parameters; 128, 129; 129, identifier:text; 130, block; 130, 131; 130, 134; 130, 143; 131, import_statement; 131, 132; 132, dotted_name; 132, 133; 133, identifier:re; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:ansi_escape; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:re; 140, identifier:compile; 141, argument_list; 141, 142; 142, string:r'\x1b[^m]*m'; 143, return_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:ansi_escape; 147, identifier:sub; 148, argument_list; 148, 149; 148, 150; 149, string:''; 150, identifier:text; 151, function_definition; 151, 152; 151, 153; 151, 160; 152, function_name:justify_ansi; 153, parameters; 153, 154; 153, 155; 153, 156; 153, 157; 154, identifier:self; 155, identifier:texts; 156, identifier:max_len; 157, default_parameter; 157, 158; 157, 159; 158, identifier:mode; 159, string:'right'; 160, block; 160, 161; 161, if_statement; 161, 162; 161, 165; 161, 191; 161, 221; 162, comparison_operator:==; 162, 163; 162, 164; 163, identifier:mode; 164, string:'left'; 165, block; 165, 166; 166, return_statement; 166, 167; 167, list_comprehension; 167, 168; 167, 188; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:x; 171, identifier:ljust; 172, argument_list; 172, 173; 173, binary_operator:+; 173, 174; 173, 175; 174, identifier:max_len; 175, parenthesized_expression; 175, 176; 176, binary_operator:-; 176, 177; 176, 181; 177, call; 177, 178; 177, 179; 178, identifier:len; 179, argument_list; 179, 180; 180, identifier:x; 181, call; 181, 182; 181, 183; 182, identifier:len; 183, argument_list; 183, 184; 184, call; 184, 185; 184, 186; 185, identifier:strip_ansi; 186, argument_list; 186, 187; 187, identifier:x; 188, for_in_clause; 188, 189; 188, 190; 189, identifier:x; 190, identifier:texts; 191, elif_clause; 191, 192; 191, 195; 192, comparison_operator:==; 192, 193; 192, 194; 193, identifier:mode; 194, string:'center'; 195, block; 195, 196; 196, return_statement; 196, 197; 197, list_comprehension; 197, 198; 197, 218; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:x; 201, identifier:center; 202, argument_list; 202, 203; 203, binary_operator:+; 203, 204; 203, 205; 204, identifier:max_len; 205, parenthesized_expression; 205, 206; 206, binary_operator:-; 206, 207; 206, 211; 207, call; 207, 208; 207, 209; 208, identifier:len; 209, argument_list; 209, 210; 210, identifier:x; 211, call; 211, 212; 211, 213; 212, identifier:len; 213, argument_list; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:strip_ansi; 216, argument_list; 216, 217; 217, identifier:x; 218, for_in_clause; 218, 219; 218, 220; 219, identifier:x; 220, identifier:texts; 221, else_clause; 221, 222; 222, block; 222, 223; 223, return_statement; 223, 224; 224, list_comprehension; 224, 225; 224, 245; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:x; 228, identifier:rjust; 229, argument_list; 229, 230; 230, binary_operator:+; 230, 231; 230, 232; 231, identifier:max_len; 232, parenthesized_expression; 232, 233; 233, binary_operator:-; 233, 234; 233, 238; 234, call; 234, 235; 234, 236; 235, identifier:len; 236, argument_list; 236, 237; 237, identifier:x; 238, call; 238, 239; 238, 240; 239, identifier:len; 240, argument_list; 240, 241; 241, call; 241, 242; 241, 243; 242, identifier:strip_ansi; 243, argument_list; 243, 244; 244, identifier:x; 245, for_in_clause; 245, 246; 245, 247; 246, identifier:x; 247, identifier:texts; 248, expression_statement; 248, 249; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:ut; 252, identifier:inject_func_as_method; 253, argument_list; 253, 254; 253, 257; 253, 258; 253, 259; 253, 262; 254, attribute; 254, 255; 254, 256; 255, identifier:self; 256, identifier:adj; 257, identifier:justify_ansi; 258, string:'justify'; 259, keyword_argument; 259, 260; 259, 261; 260, identifier:override; 261, True; 262, keyword_argument; 262, 263; 262, 264; 263, identifier:force; 264, True; 265, function_definition; 265, 266; 265, 267; 265, 270; 266, function_name:strlen_ansii; 267, parameters; 267, 268; 267, 269; 268, identifier:self; 269, identifier:text; 270, block; 270, 271; 271, return_statement; 271, 272; 272, call; 272, 273; 272, 278; 273, attribute; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:pd; 276, identifier:compat; 277, identifier:strlen; 278, argument_list; 278, 279; 278, 283; 279, call; 279, 280; 279, 281; 280, identifier:strip_ansi; 281, argument_list; 281, 282; 282, identifier:text; 283, keyword_argument; 283, 284; 283, 285; 284, identifier:encoding; 285, attribute; 285, 286; 285, 287; 286, identifier:self; 287, identifier:encoding; 288, expression_statement; 288, 289; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:ut; 292, identifier:inject_func_as_method; 293, argument_list; 293, 294; 293, 297; 293, 298; 293, 299; 293, 302; 294, attribute; 294, 295; 294, 296; 295, identifier:self; 296, identifier:adj; 297, identifier:strlen_ansii; 298, string:'len'; 299, keyword_argument; 299, 300; 299, 301; 300, identifier:override; 301, True; 302, keyword_argument; 302, 303; 302, 304; 303, identifier:force; 304, True; 305, if_statement; 305, 306; 305, 307; 306, False; 307, block; 307, 308; 307, 320; 307, 332; 307, 339; 307, 343; 307, 347; 307, 360; 307, 365; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 311; 310, identifier:strlen; 311, call; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:ut; 314, identifier:partial; 315, argument_list; 315, 316; 315, 317; 316, identifier:strlen_ansii; 317, attribute; 317, 318; 317, 319; 318, identifier:self; 319, identifier:adj; 320, expression_statement; 320, 321; 321, assignment; 321, 322; 321, 323; 322, identifier:justfunc; 323, call; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:ut; 326, identifier:partial; 327, argument_list; 327, 328; 327, 329; 328, identifier:justify_ansi; 329, attribute; 329, 330; 329, 331; 330, identifier:self; 331, identifier:adj; 332, expression_statement; 332, 333; 333, assignment; 333, 334; 333, 335; 334, identifier:strcols; 335, call; 335, 336; 335, 337; 336, identifier:monkey_to_str_columns; 337, argument_list; 337, 338; 338, identifier:self; 339, expression_statement; 339, 340; 340, assignment; 340, 341; 340, 342; 341, identifier:space; 342, integer:1; 343, expression_statement; 343, 344; 344, assignment; 344, 345; 344, 346; 345, identifier:lists; 346, identifier:strcols; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 350; 349, identifier:str_; 350, call; 350, 351; 350, 356; 351, attribute; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:self; 354, identifier:adj; 355, identifier:adjoin; 356, argument_list; 356, 357; 356, 358; 357, identifier:space; 358, list_splat; 358, 359; 359, identifier:lists; 360, expression_statement; 360, 361; 361, call; 361, 362; 361, 363; 362, identifier:print; 363, argument_list; 363, 364; 364, identifier:str_; 365, expression_statement; 365, 366; 366, call; 366, 367; 366, 368; 367, identifier:print; 368, argument_list; 368, 369; 369, call; 369, 370; 369, 371; 370, identifier:strip_ansi; 371, argument_list; 371, 372; 372, identifier:str_; 373, expression_statement; 373, 374; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:self; 377, identifier:to_string; 378, argument_list; 379, expression_statement; 379, 380; 380, assignment; 380, 381; 380, 382; 381, identifier:result; 382, call; 382, 383; 382, 388; 383, attribute; 383, 384; 383, 387; 384, attribute; 384, 385; 384, 386; 385, identifier:self; 386, identifier:buf; 387, identifier:getvalue; 388, argument_list; 389, expression_statement; 389, 390; 390, assignment; 390, 391; 390, 392; 391, identifier:result; 392, call; 392, 393; 392, 396; 393, attribute; 393, 394; 393, 395; 394, string:'\n'; 395, identifier:join; 396, argument_list; 396, 397; 397, list_comprehension; 397, 398; 397, 403; 398, call; 398, 399; 398, 402; 399, attribute; 399, 400; 399, 401; 400, identifier:x; 401, identifier:rstrip; 402, argument_list; 403, for_in_clause; 403, 404; 403, 405; 404, identifier:x; 405, call; 405, 406; 405, 409; 406, attribute; 406, 407; 406, 408; 407, identifier:result; 408, identifier:split; 409, argument_list; 409, 410; 410, string:'\n'; 411, return_statement; 411, 412; 412, identifier:result; 413, except_clause; 413, 414; 413, 418; 414, as_pattern; 414, 415; 414, 416; 415, identifier:Exception; 416, as_pattern_target; 416, 417; 417, identifier:ex; 418, block; 418, 419; 418, 440; 419, expression_statement; 419, 420; 420, call; 420, 421; 420, 424; 421, attribute; 421, 422; 421, 423; 422, identifier:ut; 423, identifier:printex; 424, argument_list; 424, 425; 424, 434; 424, 437; 425, call; 425, 426; 425, 429; 426, attribute; 426, 427; 426, 428; 427, string:'pandas monkey-patch is broken: {}'; 428, identifier:format; 429, argument_list; 429, 430; 430, call; 430, 431; 430, 432; 431, identifier:str; 432, argument_list; 432, 433; 433, identifier:ex; 434, keyword_argument; 434, 435; 434, 436; 435, identifier:tb; 436, True; 437, keyword_argument; 437, 438; 437, 439; 438, identifier:iswarning; 439, True; 440, return_statement; 440, 441; 441, call; 441, 442; 441, 443; 442, identifier:str; 443, argument_list; 443, 444; 444, identifier:df | def to_string_monkey(df, highlight_cols=None, latex=False):
try:
import pandas as pd
import utool as ut
import numpy as np
import six
if isinstance(highlight_cols, six.string_types) and highlight_cols == 'all':
highlight_cols = np.arange(len(df.columns))
try:
self = pd.formats.format.DataFrameFormatter(df)
except AttributeError:
self = pd.io.formats.format.DataFrameFormatter(df)
self.highlight_cols = highlight_cols
def monkey(self):
return monkey_to_str_columns(self, latex=latex)
ut.inject_func_as_method(self, monkey, '_to_str_columns', override=True, force=True)
def strip_ansi(text):
import re
ansi_escape = re.compile(r'\x1b[^m]*m')
return ansi_escape.sub('', text)
def justify_ansi(self, texts, max_len, mode='right'):
if mode == 'left':
return [x.ljust(max_len + (len(x) - len(strip_ansi(x)))) for x in texts]
elif mode == 'center':
return [x.center(max_len + (len(x) - len(strip_ansi(x)))) for x in texts]
else:
return [x.rjust(max_len + (len(x) - len(strip_ansi(x)))) for x in texts]
ut.inject_func_as_method(self.adj, justify_ansi, 'justify', override=True, force=True)
def strlen_ansii(self, text):
return pd.compat.strlen(strip_ansi(text), encoding=self.encoding)
ut.inject_func_as_method(self.adj, strlen_ansii, 'len', override=True, force=True)
if False:
strlen = ut.partial(strlen_ansii, self.adj)
justfunc = ut.partial(justify_ansi, self.adj)
strcols = monkey_to_str_columns(self)
space = 1
lists = strcols
str_ = self.adj.adjoin(space, *lists)
print(str_)
print(strip_ansi(str_))
self.to_string()
result = self.buf.getvalue()
result = '\n'.join([x.rstrip() for x in result.split('\n')])
return result
except Exception as ex:
ut.printex('pandas monkey-patch is broken: {}'.format(str(ex)),
tb=True, iswarning=True)
return str(df) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:translate; 3, parameters; 3, 4; 4, identifier:value; 5, block; 5, 6; 5, 15; 5, 24; 5, 36; 5, 63; 5, 120; 5, 212; 6, if_statement; 6, 7; 6, 12; 7, call; 7, 8; 7, 9; 8, identifier:isinstance; 9, argument_list; 9, 10; 9, 11; 10, identifier:value; 11, identifier:BaseValidator; 12, block; 12, 13; 13, return_statement; 13, 14; 14, identifier:value; 15, if_statement; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:value; 18, None; 19, block; 19, 20; 20, return_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:Anything; 23, argument_list; 24, if_statement; 24, 25; 24, 30; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 29; 28, identifier:value; 29, identifier:type; 30, block; 30, 31; 31, return_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:IsA; 34, argument_list; 34, 35; 35, identifier:value; 36, if_statement; 36, 37; 36, 45; 37, comparison_operator:in; 37, 38; 37, 42; 38, call; 38, 39; 38, 40; 39, identifier:type; 40, argument_list; 40, 41; 41, identifier:value; 42, attribute; 42, 43; 42, 44; 43, identifier:compat; 44, identifier:func_types; 45, block; 45, 46; 45, 52; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:real_value; 49, call; 49, 50; 49, 51; 50, identifier:value; 51, argument_list; 52, return_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:IsA; 55, argument_list; 55, 56; 55, 60; 56, call; 56, 57; 56, 58; 57, identifier:type; 58, argument_list; 58, 59; 59, identifier:real_value; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:default; 62, identifier:real_value; 63, if_statement; 63, 64; 63, 69; 64, call; 64, 65; 64, 66; 65, identifier:isinstance; 66, argument_list; 66, 67; 66, 68; 67, identifier:value; 68, identifier:list; 69, block; 69, 70; 70, if_statement; 70, 71; 70, 74; 70, 80; 70, 98; 71, comparison_operator:==; 71, 72; 71, 73; 72, identifier:value; 73, list:[]; 74, block; 74, 75; 75, return_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:IsA; 78, argument_list; 78, 79; 79, identifier:list; 80, elif_clause; 80, 81; 80, 87; 81, comparison_operator:==; 81, 82; 81, 86; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, identifier:value; 86, integer:1; 87, block; 87, 88; 88, return_statement; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:ListOf; 91, argument_list; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:translate; 94, argument_list; 94, 95; 95, subscript; 95, 96; 95, 97; 96, identifier:value; 97, integer:0; 98, else_clause; 98, 99; 99, block; 99, 100; 100, raise_statement; 100, 101; 101, call; 101, 102; 101, 103; 102, identifier:StructureSpecificationError; 103, argument_list; 103, 104; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, concatenated_string; 106, 107; 106, 108; 107, string:'Expected a list containing exactly 1 item; '; 108, string:'got {cnt}: {spec}'; 109, identifier:format; 110, argument_list; 110, 111; 110, 117; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:cnt; 113, call; 113, 114; 113, 115; 114, identifier:len; 115, argument_list; 115, 116; 116, identifier:value; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:spec; 119, identifier:value; 120, if_statement; 120, 121; 120, 126; 121, call; 121, 122; 121, 123; 122, identifier:isinstance; 123, argument_list; 123, 124; 123, 125; 124, identifier:value; 125, identifier:dict; 126, block; 126, 127; 126, 136; 126, 140; 126, 207; 127, if_statement; 127, 128; 127, 130; 128, not_operator; 128, 129; 129, identifier:value; 130, block; 130, 131; 131, return_statement; 131, 132; 132, call; 132, 133; 132, 134; 133, identifier:IsA; 134, argument_list; 134, 135; 135, identifier:dict; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:items; 139, list:[]; 140, for_statement; 140, 141; 140, 144; 140, 149; 141, pattern_list; 141, 142; 141, 143; 142, identifier:k; 143, identifier:v; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:value; 147, identifier:items; 148, argument_list; 149, block; 149, 150; 149, 191; 149, 198; 150, if_statement; 150, 151; 150, 156; 150, 161; 151, call; 151, 152; 151, 153; 152, identifier:isinstance; 153, argument_list; 153, 154; 153, 155; 154, identifier:k; 155, identifier:BaseValidator; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:k_validator; 160, identifier:k; 161, else_clause; 161, 162; 162, block; 162, 163; 162, 170; 162, 179; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:k_validator; 166, call; 166, 167; 166, 168; 167, identifier:translate; 168, argument_list; 168, 169; 169, identifier:k; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:default; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:k_validator; 176, identifier:get_default_for; 177, argument_list; 177, 178; 178, None; 179, if_statement; 179, 180; 179, 183; 180, comparison_operator:is; 180, 181; 180, 182; 181, identifier:default; 182, None; 183, block; 183, 184; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:k_validator; 187, call; 187, 188; 187, 189; 188, identifier:Equals; 189, argument_list; 189, 190; 190, identifier:default; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:v_validator; 194, call; 194, 195; 194, 196; 195, identifier:translate; 196, argument_list; 196, 197; 197, identifier:v; 198, expression_statement; 198, 199; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:items; 202, identifier:append; 203, argument_list; 203, 204; 204, tuple; 204, 205; 204, 206; 205, identifier:k_validator; 206, identifier:v_validator; 207, return_statement; 207, 208; 208, call; 208, 209; 208, 210; 209, identifier:DictOf; 210, argument_list; 210, 211; 211, identifier:items; 212, return_statement; 212, 213; 213, call; 213, 214; 213, 215; 214, identifier:IsA; 215, argument_list; 215, 216; 215, 220; 216, call; 216, 217; 216, 218; 217, identifier:type; 218, argument_list; 218, 219; 219, identifier:value; 220, keyword_argument; 220, 221; 220, 222; 221, identifier:default; 222, identifier:value | def translate(value):
if isinstance(value, BaseValidator):
return value
if value is None:
return Anything()
if isinstance(value, type):
return IsA(value)
if type(value) in compat.func_types:
real_value = value()
return IsA(type(real_value), default=real_value)
if isinstance(value, list):
if value == []:
return IsA(list)
elif len(value) == 1:
return ListOf(translate(value[0]))
else:
raise StructureSpecificationError(
'Expected a list containing exactly 1 item; '
'got {cnt}: {spec}'.format(cnt=len(value), spec=value))
if isinstance(value, dict):
if not value:
return IsA(dict)
items = []
for k, v in value.items():
if isinstance(k, BaseValidator):
k_validator = k
else:
k_validator = translate(k)
default = k_validator.get_default_for(None)
if default is not None:
k_validator = Equals(default)
v_validator = translate(v)
items.append((k_validator, v_validator))
return DictOf(items)
return IsA(type(value), default=value) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:parse_keys; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:string; 5, default_parameter; 5, 6; 5, 7; 6, identifier:with_spaces; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:with_tabs; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:with_newlines; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:modifiers; 16, None; 17, block; 17, 18; 17, 20; 17, 24; 17, 32; 17, 36; 17, 321; 17, 341; 18, expression_statement; 18, 19; 19, string:"Return the parsed keys"; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:keys; 23, list:[]; 24, if_statement; 24, 25; 24, 27; 25, not_operator; 25, 26; 26, identifier:modifiers; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:modifiers; 31, list:[]; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:index; 35, integer:0; 36, while_statement; 36, 37; 36, 43; 37, comparison_operator:<; 37, 38; 37, 39; 38, identifier:index; 39, call; 39, 40; 39, 41; 40, identifier:len; 41, argument_list; 41, 42; 42, identifier:string; 43, block; 43, 44; 43, 50; 43, 54; 43, 292; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:c; 47, subscript; 47, 48; 47, 49; 48, identifier:string; 49, identifier:index; 50, expression_statement; 50, 51; 51, augmented_assignment:+=; 51, 52; 51, 53; 52, identifier:index; 53, integer:1; 54, if_statement; 54, 55; 54, 62; 54, 99; 54, 149; 54, 202; 54, 212; 54, 222; 55, comparison_operator:in; 55, 56; 55, 57; 56, identifier:c; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:MODIFIERS; 60, identifier:keys; 61, argument_list; 62, block; 62, 63; 62, 69; 62, 76; 62, 89; 62, 98; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:modifier; 66, subscript; 66, 67; 66, 68; 67, identifier:MODIFIERS; 68, identifier:c; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:modifiers; 73, identifier:append; 74, argument_list; 74, 75; 75, identifier:modifier; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:keys; 80, identifier:append; 81, argument_list; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:VirtualKeyAction; 84, argument_list; 84, 85; 84, 86; 85, identifier:modifier; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:up; 88, False; 89, if_statement; 89, 90; 89, 91; 90, identifier:DEBUG; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 95; 94, identifier:print; 95, argument_list; 95, 96; 95, 97; 96, string:"MODS+"; 97, identifier:modifiers; 98, continue_statement; 99, elif_clause; 99, 100; 99, 103; 100, comparison_operator:==; 100, 101; 100, 102; 101, identifier:c; 102, string:"("; 103, block; 103, 104; 103, 114; 103, 125; 103, 143; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:end_pos; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:string; 110, identifier:find; 111, argument_list; 111, 112; 111, 113; 112, string:")"; 113, identifier:index; 114, if_statement; 114, 115; 114, 119; 115, comparison_operator:==; 115, 116; 115, 117; 116, identifier:end_pos; 117, unary_operator:-; 117, 118; 118, integer:1; 119, block; 119, 120; 120, raise_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:KeySequenceError; 123, argument_list; 123, 124; 124, string:'`)` not found'; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:keys; 129, identifier:extend; 130, argument_list; 130, 131; 131, call; 131, 132; 131, 133; 132, identifier:parse_keys; 133, argument_list; 133, 134; 133, 140; 134, subscript; 134, 135; 134, 136; 135, identifier:string; 136, slice; 136, 137; 136, 138; 136, 139; 137, identifier:index; 138, colon; 139, identifier:end_pos; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:modifiers; 142, identifier:modifiers; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:index; 146, binary_operator:+; 146, 147; 146, 148; 147, identifier:end_pos; 148, integer:1; 149, elif_clause; 149, 150; 149, 153; 150, comparison_operator:==; 150, 151; 150, 152; 151, identifier:c; 152, string:"{"; 153, block; 153, 154; 153, 166; 153, 177; 153, 186; 153, 192; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:end_pos; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:string; 160, identifier:find; 161, argument_list; 161, 162; 161, 163; 162, string:"}"; 163, binary_operator:+; 163, 164; 163, 165; 164, identifier:index; 165, integer:1; 166, if_statement; 166, 167; 166, 171; 167, comparison_operator:==; 167, 168; 167, 169; 168, identifier:end_pos; 169, unary_operator:-; 169, 170; 170, integer:1; 171, block; 171, 172; 172, raise_statement; 172, 173; 173, call; 173, 174; 173, 175; 174, identifier:KeySequenceError; 175, argument_list; 175, 176; 176, string:'`}` not found'; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:code; 180, subscript; 180, 181; 180, 182; 181, identifier:string; 182, slice; 182, 183; 182, 184; 182, 185; 183, identifier:index; 184, colon; 185, identifier:end_pos; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:index; 189, binary_operator:+; 189, 190; 189, 191; 190, identifier:end_pos; 191, integer:1; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:keys; 196, identifier:extend; 197, argument_list; 197, 198; 198, call; 198, 199; 198, 200; 199, identifier:handle_code; 200, argument_list; 200, 201; 201, identifier:code; 202, elif_clause; 202, 203; 202, 206; 203, comparison_operator:==; 203, 204; 203, 205; 204, identifier:c; 205, string:')'; 206, block; 206, 207; 207, raise_statement; 207, 208; 208, call; 208, 209; 208, 210; 209, identifier:KeySequenceError; 210, argument_list; 210, 211; 211, string:'`)` should be preceeded by `(`'; 212, elif_clause; 212, 213; 212, 216; 213, comparison_operator:==; 213, 214; 213, 215; 214, identifier:c; 215, string:'}'; 216, block; 216, 217; 217, raise_statement; 217, 218; 218, call; 218, 219; 218, 220; 219, identifier:KeySequenceError; 220, argument_list; 220, 221; 221, string:'`}` should be preceeded by `{`'; 222, else_clause; 222, 223; 223, block; 223, 224; 223, 248; 224, if_statement; 224, 225; 224, 246; 225, parenthesized_expression; 225, 226; 226, boolean_operator:or; 226, 227; 226, 240; 227, boolean_operator:or; 227, 228; 227, 234; 228, boolean_operator:and; 228, 229; 228, 232; 229, comparison_operator:==; 229, 230; 229, 231; 230, identifier:c; 231, string:' '; 232, not_operator; 232, 233; 233, identifier:with_spaces; 234, boolean_operator:and; 234, 235; 234, 238; 235, comparison_operator:==; 235, 236; 235, 237; 236, identifier:c; 237, string:'\t'; 238, not_operator; 238, 239; 239, identifier:with_tabs; 240, boolean_operator:and; 240, 241; 240, 244; 241, comparison_operator:==; 241, 242; 241, 243; 242, identifier:c; 243, string:'\n'; 244, not_operator; 244, 245; 245, identifier:with_newlines; 246, block; 246, 247; 247, continue_statement; 248, if_statement; 248, 249; 248, 254; 248, 267; 248, 280; 249, comparison_operator:in; 249, 250; 249, 251; 250, identifier:c; 251, tuple; 251, 252; 251, 253; 252, string:'~'; 253, string:'\n'; 254, block; 254, 255; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:keys; 259, identifier:append; 260, argument_list; 260, 261; 261, call; 261, 262; 261, 263; 262, identifier:VirtualKeyAction; 263, argument_list; 263, 264; 264, subscript; 264, 265; 264, 266; 265, identifier:CODES; 266, string:"ENTER"; 267, elif_clause; 267, 268; 267, 269; 268, identifier:modifiers; 269, block; 269, 270; 270, expression_statement; 270, 271; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:keys; 274, identifier:append; 275, argument_list; 275, 276; 276, call; 276, 277; 276, 278; 277, identifier:EscapedKeyAction; 278, argument_list; 278, 279; 279, identifier:c; 280, else_clause; 280, 281; 281, block; 281, 282; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:keys; 286, identifier:append; 287, argument_list; 287, 288; 288, call; 288, 289; 288, 290; 289, identifier:KeyAction; 290, argument_list; 290, 291; 291, identifier:c; 292, while_statement; 292, 293; 292, 294; 293, identifier:modifiers; 294, block; 294, 295; 294, 304; 295, if_statement; 295, 296; 295, 297; 296, identifier:DEBUG; 297, block; 297, 298; 298, expression_statement; 298, 299; 299, call; 299, 300; 299, 301; 300, identifier:print; 301, argument_list; 301, 302; 301, 303; 302, string:"MODS-"; 303, identifier:modifiers; 304, expression_statement; 304, 305; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:keys; 308, identifier:append; 309, argument_list; 309, 310; 310, call; 310, 311; 310, 312; 311, identifier:VirtualKeyAction; 312, argument_list; 312, 313; 312, 318; 313, call; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:modifiers; 316, identifier:pop; 317, argument_list; 318, keyword_argument; 318, 319; 318, 320; 319, identifier:down; 320, False; 321, while_statement; 321, 322; 321, 323; 322, identifier:modifiers; 323, block; 323, 324; 324, expression_statement; 324, 325; 325, call; 325, 326; 325, 329; 326, attribute; 326, 327; 326, 328; 327, identifier:keys; 328, identifier:append; 329, argument_list; 329, 330; 330, call; 330, 331; 330, 332; 331, identifier:VirtualKeyAction; 332, argument_list; 332, 333; 332, 338; 333, call; 333, 334; 333, 337; 334, attribute; 334, 335; 334, 336; 335, identifier:modifiers; 336, identifier:pop; 337, argument_list; 338, keyword_argument; 338, 339; 338, 340; 339, identifier:down; 340, False; 341, return_statement; 341, 342; 342, identifier:keys | def parse_keys(string,
with_spaces = False,
with_tabs = False,
with_newlines = False,
modifiers = None):
"Return the parsed keys"
keys = []
if not modifiers:
modifiers = []
index = 0
while index < len(string):
c = string[index]
index += 1
if c in MODIFIERS.keys():
modifier = MODIFIERS[c]
modifiers.append(modifier)
keys.append(VirtualKeyAction(modifier, up = False))
if DEBUG:
print("MODS+", modifiers)
continue
elif c == "(":
end_pos = string.find(")", index)
if end_pos == -1:
raise KeySequenceError('`)` not found')
keys.extend(
parse_keys(string[index:end_pos], modifiers = modifiers))
index = end_pos + 1
elif c == "{":
end_pos = string.find("}", index + 1)
if end_pos == -1:
raise KeySequenceError('`}` not found')
code = string[index:end_pos]
index = end_pos + 1
keys.extend(handle_code(code))
elif c == ')':
raise KeySequenceError('`)` should be preceeded by `(`')
elif c == '}':
raise KeySequenceError('`}` should be preceeded by `{`')
else:
if (c == ' ' and not with_spaces or
c == '\t' and not with_tabs or
c == '\n' and not with_newlines):
continue
if c in ('~', '\n'):
keys.append(VirtualKeyAction(CODES["ENTER"]))
elif modifiers:
keys.append(EscapedKeyAction(c))
else:
keys.append(KeyAction(c))
while modifiers:
if DEBUG:
print("MODS-", modifiers)
keys.append(VirtualKeyAction(modifiers.pop(), down = False))
while modifiers:
keys.append(VirtualKeyAction(modifiers.pop(), down = False))
return keys |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 28; 2, function_name:get_argflag; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 4, identifier:argstr_; 5, default_parameter; 5, 6; 5, 7; 6, identifier:default; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:help_; 10, string:''; 11, default_parameter; 11, 12; 11, 13; 12, identifier:return_specified; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:need_prefix; 16, True; 17, default_parameter; 17, 18; 17, 19; 18, identifier:return_was_specified; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:argv; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:debug; 25, None; 26, dictionary_splat_pattern; 26, 27; 27, identifier:kwargs; 28, block; 28, 29; 28, 40; 28, 47; 28, 56; 28, 64; 28, 68; 28, 72; 28, 81; 28, 84; 28, 85; 28, 197; 28, 336; 28, 345; 29, if_statement; 29, 30; 29, 33; 30, comparison_operator:is; 30, 31; 30, 32; 31, identifier:argv; 32, None; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:argv; 37, attribute; 37, 38; 37, 39; 38, identifier:sys; 39, identifier:argv; 40, assert_statement; 40, 41; 40, 46; 41, call; 41, 42; 41, 43; 42, identifier:isinstance; 43, argument_list; 43, 44; 43, 45; 44, identifier:default; 45, identifier:bool; 46, string:'default must be boolean'; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:argstr_list; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:meta_util_iter; 53, identifier:ensure_iterable; 54, argument_list; 54, 55; 55, identifier:argstr_; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:_register_arg; 59, argument_list; 59, 60; 59, 61; 59, 62; 59, 63; 60, identifier:argstr_list; 61, identifier:bool; 62, identifier:default; 63, identifier:help_; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:parsed_val; 67, identifier:default; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:was_specified; 71, False; 72, if_statement; 72, 73; 72, 76; 73, comparison_operator:is; 73, 74; 73, 75; 74, identifier:debug; 75, None; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:debug; 80, identifier:DEBUG; 81, import_statement; 81, 82; 82, dotted_name; 82, 83; 83, identifier:os; 84, comment; 85, for_statement; 85, 86; 85, 89; 85, 96; 86, pattern_list; 86, 87; 86, 88; 87, identifier:key; 88, identifier:val; 89, call; 89, 90; 89, 95; 90, attribute; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:os; 93, identifier:environ; 94, identifier:items; 95, argument_list; 96, block; 96, 97; 96, 105; 96, 109; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:key; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:key; 103, identifier:upper; 104, argument_list; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:sentinal; 108, string:'UTOOL_'; 109, if_statement; 109, 110; 109, 116; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:key; 113, identifier:startswith; 114, argument_list; 114, 115; 115, identifier:sentinal; 116, block; 116, 117; 116, 140; 116, 167; 116, 172; 116, 181; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:flag; 120, binary_operator:+; 120, 121; 120, 122; 121, string:'--'; 122, call; 122, 123; 122, 137; 123, attribute; 123, 124; 123, 136; 124, call; 124, 125; 124, 135; 125, attribute; 125, 126; 125, 134; 126, subscript; 126, 127; 126, 128; 127, identifier:key; 128, slice; 128, 129; 128, 133; 129, call; 129, 130; 129, 131; 130, identifier:len; 131, argument_list; 131, 132; 132, identifier:sentinal; 133, colon; 134, identifier:lower; 135, argument_list; 136, identifier:replace; 137, argument_list; 137, 138; 137, 139; 138, string:'_'; 139, string:'-'; 140, if_statement; 140, 141; 140, 150; 140, 152; 140, 164; 141, comparison_operator:in; 141, 142; 141, 147; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:val; 145, identifier:upper; 146, argument_list; 147, list:['TRUE', 'ON']; 147, 148; 147, 149; 148, string:'TRUE'; 149, string:'ON'; 150, block; 150, 151; 151, pass_statement; 152, elif_clause; 152, 153; 152, 162; 153, comparison_operator:in; 153, 154; 153, 159; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:val; 157, identifier:upper; 158, argument_list; 159, list:['FALSE', 'OFF']; 159, 160; 159, 161; 160, string:'FALSE'; 161, string:'OFF'; 162, block; 162, 163; 163, continue_statement; 164, else_clause; 164, 165; 165, block; 165, 166; 166, continue_statement; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:new_argv; 170, list:[flag]; 170, 171; 171, identifier:flag; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:argv; 175, binary_operator:+; 175, 176; 175, 180; 176, subscript; 176, 177; 176, 178; 177, identifier:argv; 178, slice; 178, 179; 179, colon; 180, identifier:new_argv; 181, if_statement; 181, 182; 181, 183; 182, identifier:debug; 183, block; 183, 184; 183, 189; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:print; 187, argument_list; 187, 188; 188, string:'ENV SPECIFIED COMMAND LINE'; 189, expression_statement; 189, 190; 190, call; 190, 191; 190, 192; 191, identifier:print; 192, argument_list; 192, 193; 193, binary_operator:%; 193, 194; 193, 195; 194, string:'argv.extend(new_argv=%r)'; 195, tuple; 195, 196; 196, identifier:new_argv; 197, for_statement; 197, 198; 197, 199; 197, 200; 198, identifier:argstr; 199, identifier:argstr_list; 200, block; 200, 201; 200, 238; 200, 266; 200, 276; 201, if_statement; 201, 202; 201, 229; 202, not_operator; 202, 203; 203, parenthesized_expression; 203, 204; 204, boolean_operator:or; 204, 205; 204, 213; 205, comparison_operator:==; 205, 206; 205, 212; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:argstr; 209, identifier:find; 210, argument_list; 210, 211; 211, string:'--'; 212, integer:0; 213, parenthesized_expression; 213, 214; 214, boolean_operator:and; 214, 215; 214, 223; 215, comparison_operator:==; 215, 216; 215, 222; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:argstr; 219, identifier:find; 220, argument_list; 220, 221; 221, string:'-'; 222, integer:0; 223, comparison_operator:==; 223, 224; 223, 228; 224, call; 224, 225; 224, 226; 225, identifier:len; 226, argument_list; 226, 227; 227, identifier:argstr; 228, integer:2; 229, block; 229, 230; 230, raise_statement; 230, 231; 231, call; 231, 232; 231, 233; 232, identifier:AssertionError; 233, argument_list; 233, 234; 234, binary_operator:%; 234, 235; 234, 236; 235, string:'Invalid argstr: %r'; 236, tuple; 236, 237; 237, identifier:argstr; 238, if_statement; 238, 239; 238, 241; 239, not_operator; 239, 240; 240, identifier:need_prefix; 241, block; 241, 242; 241, 252; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:noprefix; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:argstr; 248, identifier:replace; 249, argument_list; 249, 250; 249, 251; 250, string:'--'; 251, string:''; 252, if_statement; 252, 253; 252, 256; 253, comparison_operator:in; 253, 254; 253, 255; 254, identifier:noprefix; 255, identifier:argv; 256, block; 256, 257; 256, 261; 256, 265; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:parsed_val; 260, True; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:was_specified; 264, True; 265, break_statement; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:noarg; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:argstr; 272, identifier:replace; 273, argument_list; 273, 274; 273, 275; 274, string:'--'; 275, string:'--no'; 276, if_statement; 276, 277; 276, 280; 276, 290; 276, 304; 276, 320; 277, comparison_operator:in; 277, 278; 277, 279; 278, identifier:argstr; 279, identifier:argv; 280, block; 280, 281; 280, 285; 280, 289; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:parsed_val; 284, True; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:was_specified; 288, True; 289, break_statement; 290, elif_clause; 290, 291; 290, 294; 291, comparison_operator:in; 291, 292; 291, 293; 292, identifier:noarg; 293, identifier:argv; 294, block; 294, 295; 294, 299; 294, 303; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:parsed_val; 298, False; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:was_specified; 302, True; 303, break_statement; 304, elif_clause; 304, 305; 304, 310; 305, comparison_operator:in; 305, 306; 305, 309; 306, binary_operator:+; 306, 307; 306, 308; 307, identifier:argstr; 308, string:'=True'; 309, identifier:argv; 310, block; 310, 311; 310, 315; 310, 319; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:parsed_val; 314, True; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 318; 317, identifier:was_specified; 318, True; 319, break_statement; 320, elif_clause; 320, 321; 320, 326; 321, comparison_operator:in; 321, 322; 321, 325; 322, binary_operator:+; 322, 323; 322, 324; 323, identifier:argstr; 324, string:'=False'; 325, identifier:argv; 326, block; 326, 327; 326, 331; 326, 335; 327, expression_statement; 327, 328; 328, assignment; 328, 329; 328, 330; 329, identifier:parsed_val; 330, False; 331, expression_statement; 331, 332; 332, assignment; 332, 333; 332, 334; 333, identifier:was_specified; 334, True; 335, break_statement; 336, if_statement; 336, 337; 336, 340; 337, comparison_operator:is; 337, 338; 337, 339; 338, identifier:return_specified; 339, None; 340, block; 340, 341; 341, expression_statement; 341, 342; 342, assignment; 342, 343; 342, 344; 343, identifier:return_specified; 344, identifier:return_was_specified; 345, if_statement; 345, 346; 345, 347; 345, 352; 346, identifier:return_specified; 347, block; 347, 348; 348, return_statement; 348, 349; 349, expression_list; 349, 350; 349, 351; 350, identifier:parsed_val; 351, identifier:was_specified; 352, else_clause; 352, 353; 353, block; 353, 354; 354, return_statement; 354, 355; 355, identifier:parsed_val | def get_argflag(argstr_, default=False, help_='', return_specified=None,
need_prefix=True, return_was_specified=False, argv=None,
debug=None,
**kwargs):
if argv is None:
argv = sys.argv
assert isinstance(default, bool), 'default must be boolean'
argstr_list = meta_util_iter.ensure_iterable(argstr_)
_register_arg(argstr_list, bool, default, help_)
parsed_val = default
was_specified = False
if debug is None:
debug = DEBUG
import os
#
for key, val in os.environ.items():
key = key.upper()
sentinal = 'UTOOL_'
if key.startswith(sentinal):
flag = '--' + key[len(sentinal):].lower().replace('_', '-')
if val.upper() in ['TRUE', 'ON']:
pass
elif val.upper() in ['FALSE', 'OFF']:
continue
else:
continue
new_argv = [flag]
argv = argv[:] + new_argv
if debug:
print('ENV SPECIFIED COMMAND LINE')
print('argv.extend(new_argv=%r)' % (new_argv,))
for argstr in argstr_list:
if not (argstr.find('--') == 0 or (argstr.find('-') == 0 and len(argstr) == 2)):
raise AssertionError('Invalid argstr: %r' % (argstr,))
if not need_prefix:
noprefix = argstr.replace('--', '')
if noprefix in argv:
parsed_val = True
was_specified = True
break
noarg = argstr.replace('--', '--no')
if argstr in argv:
parsed_val = True
was_specified = True
break
elif noarg in argv:
parsed_val = False
was_specified = True
break
elif argstr + '=True' in argv:
parsed_val = True
was_specified = True
break
elif argstr + '=False' in argv:
parsed_val = False
was_specified = True
break
if return_specified is None:
return_specified = return_was_specified
if return_specified:
return parsed_val, was_specified
else:
return parsed_val |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_arg_dict; 3, parameters; 3, 4; 3, 7; 3, 11; 4, default_parameter; 4, 5; 4, 6; 5, identifier:argv; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:prefix_list; 9, list:['--']; 9, 10; 10, string:'--'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:type_hints; 13, dictionary; 14, block; 14, 15; 14, 17; 14, 28; 14, 32; 14, 51; 14, 96; 14, 167; 14, 265; 15, expression_statement; 15, 16; 16, identifier:r; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:argv; 20, None; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:argv; 25, attribute; 25, 26; 25, 27; 26, identifier:sys; 27, identifier:argv; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:arg_dict; 31, dictionary; 32, function_definition; 32, 33; 32, 34; 32, 36; 33, function_name:startswith_prefix; 34, parameters; 34, 35; 35, identifier:arg; 36, block; 36, 37; 37, return_statement; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:any; 40, argument_list; 40, 41; 41, list_comprehension; 41, 42; 41, 48; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:arg; 45, identifier:startswith; 46, argument_list; 46, 47; 47, identifier:prefix; 48, for_in_clause; 48, 49; 48, 50; 49, identifier:prefix; 50, identifier:prefix_list; 51, function_definition; 51, 52; 51, 53; 51, 56; 52, function_name:argx_has_value; 53, parameters; 53, 54; 53, 55; 54, identifier:argv; 55, identifier:argx; 56, block; 56, 57; 56, 72; 56, 94; 57, if_statement; 57, 58; 57, 69; 58, comparison_operator:>; 58, 59; 58, 67; 59, call; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:argv; 63, identifier:argx; 64, identifier:find; 65, argument_list; 65, 66; 66, string:'='; 67, unary_operator:-; 67, 68; 68, integer:1; 69, block; 69, 70; 70, return_statement; 70, 71; 71, True; 72, if_statement; 72, 73; 72, 91; 73, boolean_operator:and; 73, 74; 73, 82; 74, comparison_operator:<; 74, 75; 74, 78; 75, binary_operator:+; 75, 76; 75, 77; 76, identifier:argx; 77, integer:1; 78, call; 78, 79; 78, 80; 79, identifier:len; 80, argument_list; 80, 81; 81, identifier:argv; 82, not_operator; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:startswith_prefix; 85, argument_list; 85, 86; 86, subscript; 86, 87; 86, 88; 87, identifier:argv; 88, binary_operator:+; 88, 89; 88, 90; 89, identifier:argx; 90, integer:1; 91, block; 91, 92; 92, return_statement; 92, 93; 93, True; 94, return_statement; 94, 95; 95, False; 96, function_definition; 96, 97; 96, 98; 96, 102; 97, function_name:get_arg_value; 98, parameters; 98, 99; 98, 100; 98, 101; 99, identifier:argv; 100, identifier:argx; 101, identifier:argname; 102, block; 102, 103; 103, if_statement; 103, 104; 103, 115; 103, 134; 104, comparison_operator:>; 104, 105; 104, 113; 105, call; 105, 106; 105, 111; 106, attribute; 106, 107; 106, 110; 107, subscript; 107, 108; 107, 109; 108, identifier:argv; 109, identifier:argx; 110, identifier:find; 111, argument_list; 111, 112; 112, string:'='; 113, unary_operator:-; 113, 114; 114, integer:1; 115, block; 115, 116; 116, return_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, string:'='; 120, identifier:join; 121, argument_list; 121, 122; 122, subscript; 122, 123; 122, 131; 123, call; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:argv; 127, identifier:argx; 128, identifier:split; 129, argument_list; 129, 130; 130, string:'='; 131, slice; 131, 132; 131, 133; 132, integer:1; 133, colon; 134, else_clause; 134, 135; 135, block; 135, 136; 135, 146; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:type_; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:type_hints; 142, identifier:get; 143, argument_list; 143, 144; 143, 145; 144, identifier:argname; 145, None; 146, if_statement; 146, 147; 146, 150; 146, 157; 147, comparison_operator:is; 147, 148; 147, 149; 148, identifier:type_; 149, None; 150, block; 150, 151; 151, return_statement; 151, 152; 152, subscript; 152, 153; 152, 154; 153, identifier:argv; 154, binary_operator:+; 154, 155; 154, 156; 155, identifier:argx; 156, integer:1; 157, else_clause; 157, 158; 158, block; 158, 159; 159, return_statement; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:parse_arglist_hack; 162, argument_list; 162, 163; 162, 164; 163, identifier:argx; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:argv; 166, identifier:argv; 167, for_statement; 167, 168; 167, 169; 167, 176; 168, identifier:argx; 169, call; 169, 170; 169, 171; 170, identifier:range; 171, argument_list; 171, 172; 172, call; 172, 173; 172, 174; 173, identifier:len; 174, argument_list; 174, 175; 175, identifier:argv; 176, block; 176, 177; 176, 183; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:arg; 180, subscript; 180, 181; 180, 182; 181, identifier:argv; 182, identifier:argx; 183, for_statement; 183, 184; 183, 185; 183, 186; 184, identifier:prefix; 185, identifier:prefix_list; 186, block; 186, 187; 187, if_statement; 187, 188; 187, 194; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:arg; 191, identifier:startswith; 192, argument_list; 192, 193; 193, identifier:prefix; 194, block; 194, 195; 194, 206; 194, 264; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:argname; 198, subscript; 198, 199; 198, 200; 199, identifier:arg; 200, slice; 200, 201; 200, 205; 201, call; 201, 202; 201, 203; 202, identifier:len; 203, argument_list; 203, 204; 204, identifier:prefix; 205, colon; 206, if_statement; 206, 207; 206, 212; 206, 256; 207, call; 207, 208; 207, 209; 208, identifier:argx_has_value; 209, argument_list; 209, 210; 209, 211; 210, identifier:argv; 211, identifier:argx; 212, block; 212, 213; 212, 241; 212, 250; 213, if_statement; 213, 214; 213, 223; 214, comparison_operator:>; 214, 215; 214, 221; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:arg; 218, identifier:find; 219, argument_list; 219, 220; 220, string:'='; 221, unary_operator:-; 221, 222; 222, integer:1; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:argname; 227, subscript; 227, 228; 227, 229; 228, identifier:arg; 229, slice; 229, 230; 229, 234; 229, 235; 230, call; 230, 231; 230, 232; 231, identifier:len; 232, argument_list; 232, 233; 233, identifier:prefix; 234, colon; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:arg; 238, identifier:find; 239, argument_list; 239, 240; 240, string:'='; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:argvalue; 244, call; 244, 245; 244, 246; 245, identifier:get_arg_value; 246, argument_list; 246, 247; 246, 248; 246, 249; 247, identifier:argv; 248, identifier:argx; 249, identifier:argname; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 255; 252, subscript; 252, 253; 252, 254; 253, identifier:arg_dict; 254, identifier:argname; 255, identifier:argvalue; 256, else_clause; 256, 257; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 263; 260, subscript; 260, 261; 260, 262; 261, identifier:arg_dict; 262, identifier:argname; 263, True; 264, break_statement; 265, return_statement; 265, 266; 266, identifier:arg_dict | def get_arg_dict(argv=None, prefix_list=['--'], type_hints={}):
r
if argv is None:
argv = sys.argv
arg_dict = {}
def startswith_prefix(arg):
return any([arg.startswith(prefix) for prefix in prefix_list])
def argx_has_value(argv, argx):
if argv[argx].find('=') > -1:
return True
if argx + 1 < len(argv) and not startswith_prefix(argv[argx + 1]):
return True
return False
def get_arg_value(argv, argx, argname):
if argv[argx].find('=') > -1:
return '='.join(argv[argx].split('=')[1:])
else:
type_ = type_hints.get(argname, None)
if type_ is None:
return argv[argx + 1]
else:
return parse_arglist_hack(argx, argv=argv)
for argx in range(len(argv)):
arg = argv[argx]
for prefix in prefix_list:
if arg.startswith(prefix):
argname = arg[len(prefix):]
if argx_has_value(argv, argx):
if arg.find('=') > -1:
argname = arg[len(prefix):arg.find('=')]
argvalue = get_arg_value(argv, argx, argname)
arg_dict[argname] = argvalue
else:
arg_dict[argname] = True
break
return arg_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:__argv_flag_dec; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:func; 5, default_parameter; 5, 6; 5, 7; 6, identifier:default; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:quiet; 10, identifier:QUIET; 11, default_parameter; 11, 12; 11, 13; 12, identifier:indent; 13, False; 14, block; 14, 15; 14, 20; 14, 29; 14, 47; 14, 63; 14, 261; 14, 274; 15, import_from_statement; 15, 16; 15, 18; 16, dotted_name; 16, 17; 17, identifier:utool; 18, dotted_name; 18, 19; 19, identifier:util_decor; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:flagname; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:meta_util_six; 26, identifier:get_funcname; 27, argument_list; 27, 28; 28, identifier:func; 29, if_statement; 29, 30; 29, 38; 30, comparison_operator:==; 30, 31; 30, 37; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:flagname; 34, identifier:find; 35, argument_list; 35, 36; 36, string:'no'; 37, integer:0; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:flagname; 42, subscript; 42, 43; 42, 44; 43, identifier:flagname; 44, slice; 44, 45; 44, 46; 45, integer:2; 46, colon; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:flags; 50, tuple; 50, 51; 50, 60; 51, binary_operator:+; 51, 52; 51, 53; 52, string:'--'; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:flagname; 56, identifier:replace; 57, argument_list; 57, 58; 57, 59; 58, string:'_'; 59, string:'-'; 60, binary_operator:+; 60, 61; 60, 62; 61, string:'--'; 62, identifier:flagname; 63, decorated_definition; 63, 64; 63, 73; 64, decorator; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:util_decor; 68, identifier:ignores_exc_tb; 69, argument_list; 69, 70; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:outer_wrapper; 72, False; 73, function_definition; 73, 74; 73, 75; 73, 80; 74, function_name:GaurdWrapper; 75, parameters; 75, 76; 75, 78; 76, list_splat_pattern; 76, 77; 77, identifier:args; 78, dictionary_splat_pattern; 78, 79; 79, identifier:kwargs; 80, block; 80, 81; 80, 86; 80, 96; 80, 106; 80, 132; 80, 146; 81, import_from_statement; 81, 82; 81, 84; 82, dotted_name; 82, 83; 83, identifier:utool; 84, dotted_name; 84, 85; 85, identifier:util_print; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:default_; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:kwargs; 92, identifier:pop; 93, argument_list; 93, 94; 93, 95; 94, string:'default'; 95, identifier:default; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:alias_flags; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:kwargs; 102, identifier:pop; 103, argument_list; 103, 104; 103, 105; 104, string:'alias_flags'; 105, list:[]; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:is_flagged; 109, parenthesized_expression; 109, 110; 110, boolean_operator:or; 110, 111; 110, 121; 111, boolean_operator:or; 111, 112; 111, 117; 112, call; 112, 113; 112, 114; 113, identifier:get_argflag; 114, argument_list; 114, 115; 114, 116; 115, identifier:flags; 116, identifier:default_; 117, call; 117, 118; 117, 119; 118, identifier:get_argflag; 119, argument_list; 119, 120; 120, string:'--print-all'; 121, call; 121, 122; 121, 123; 122, identifier:any; 123, argument_list; 123, 124; 124, list_comprehension; 124, 125; 124, 129; 125, call; 125, 126; 125, 127; 126, identifier:get_argflag; 127, argument_list; 127, 128; 128, identifier:_; 129, for_in_clause; 129, 130; 129, 131; 130, identifier:_; 131, identifier:alias_flags; 132, if_statement; 132, 133; 132, 136; 133, comparison_operator:in; 133, 134; 133, 135; 134, identifier:flagname; 135, identifier:kwargs; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:is_flagged; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:kwargs; 143, identifier:pop; 144, argument_list; 144, 145; 145, identifier:flagname; 146, if_statement; 146, 147; 146, 148; 146, 233; 147, identifier:is_flagged; 148, block; 148, 149; 148, 167; 148, 176; 148, 182; 148, 199; 148, 222; 148, 231; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:func_label; 152, call; 152, 153; 152, 164; 153, attribute; 153, 154; 153, 163; 154, call; 154, 155; 154, 160; 155, attribute; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:flags; 158, integer:0; 159, identifier:replace; 160, argument_list; 160, 161; 160, 162; 161, string:'--'; 162, string:''; 163, identifier:replace; 164, argument_list; 164, 165; 164, 166; 165, string:'print-'; 166, string:''; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 170; 169, identifier:print; 170, argument_list; 170, 171; 171, binary_operator:+; 171, 172; 171, 175; 172, binary_operator:+; 172, 173; 172, 174; 173, string:'\n+ --- '; 174, identifier:func_label; 175, string:' ___'; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:use_indent; 179, comparison_operator:is; 179, 180; 179, 181; 180, identifier:indent; 181, False; 182, if_statement; 182, 183; 182, 186; 182, 193; 183, comparison_operator:is; 183, 184; 183, 185; 184, identifier:indent; 185, True; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:indent_; 190, binary_operator:%; 190, 191; 190, 192; 191, string:'[%s]'; 192, identifier:func_label; 193, else_clause; 193, 194; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:indent_; 198, identifier:indent; 199, with_statement; 199, 200; 199, 211; 200, with_clause; 200, 201; 201, with_item; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:util_print; 205, identifier:Indenter; 206, argument_list; 206, 207; 206, 208; 207, identifier:indent_; 208, keyword_argument; 208, 209; 208, 210; 209, identifier:enabled; 210, identifier:use_indent; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:ret; 215, call; 215, 216; 215, 217; 216, identifier:func; 217, argument_list; 217, 218; 217, 220; 218, list_splat; 218, 219; 219, identifier:args; 220, dictionary_splat; 220, 221; 221, identifier:kwargs; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 225; 224, identifier:print; 225, argument_list; 225, 226; 226, binary_operator:+; 226, 227; 226, 230; 227, binary_operator:+; 227, 228; 227, 229; 228, string:'L ___ '; 229, identifier:func_label; 230, string:'___\n'; 231, return_statement; 231, 232; 232, identifier:ret; 233, else_clause; 233, 234; 234, block; 234, 235; 234, 246; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:PRINT_DISABLED_FLAGDEC; 238, not_operator; 238, 239; 239, call; 239, 240; 239, 241; 240, identifier:get_argflag; 241, argument_list; 241, 242; 241, 243; 242, string:'--noinform'; 243, keyword_argument; 243, 244; 243, 245; 244, identifier:help_; 245, string:'does not print disabled flag decorators'; 246, if_statement; 246, 247; 246, 251; 247, boolean_operator:and; 247, 248; 247, 250; 248, not_operator; 248, 249; 249, identifier:quiet; 250, identifier:PRINT_DISABLED_FLAGDEC; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 255; 254, identifier:print; 255, argument_list; 255, 256; 256, binary_operator:%; 256, 257; 256, 258; 257, string:'~~~ %s ~~~'; 258, subscript; 258, 259; 258, 260; 259, identifier:flags; 260, integer:0; 261, expression_statement; 261, 262; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:meta_util_six; 265, identifier:set_funcname; 266, argument_list; 266, 267; 266, 268; 267, identifier:GaurdWrapper; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:meta_util_six; 271, identifier:get_funcname; 272, argument_list; 272, 273; 273, identifier:func; 274, return_statement; 274, 275; 275, identifier:GaurdWrapper | def __argv_flag_dec(func, default=False, quiet=QUIET, indent=False):
from utool import util_decor
flagname = meta_util_six.get_funcname(func)
if flagname.find('no') == 0:
flagname = flagname[2:]
flags = (
'--' + flagname.replace('_', '-'),
'--' + flagname,
)
@util_decor.ignores_exc_tb(outer_wrapper=False)
def GaurdWrapper(*args, **kwargs):
from utool import util_print
default_ = kwargs.pop('default', default)
alias_flags = kwargs.pop('alias_flags', [])
is_flagged = (get_argflag(flags, default_) or
get_argflag('--print-all') or
any([get_argflag(_) for _ in alias_flags]))
if flagname in kwargs:
is_flagged = kwargs.pop(flagname)
if is_flagged:
func_label = flags[0].replace('--', '').replace('print-', '')
print('\n+ --- ' + func_label + ' ___')
use_indent = indent is not False
if indent is True:
indent_ = '[%s]' % func_label
else:
indent_ = indent
with util_print.Indenter(indent_, enabled=use_indent):
ret = func(*args, **kwargs)
print('L ___ ' + func_label + '___\n')
return ret
else:
PRINT_DISABLED_FLAGDEC = not get_argflag(
'--noinform', help_='does not print disabled flag decorators')
if not quiet and PRINT_DISABLED_FLAGDEC:
print('~~~ %s ~~~' % flags[0])
meta_util_six.set_funcname(GaurdWrapper, meta_util_six.get_funcname(func))
return GaurdWrapper |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:include_file; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:path; 6, default_parameter; 6, 7; 6, 8; 7, identifier:include_dirs; 8, list:[]; 9, block; 9, 10; 10, if_statement; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:include_includes; 14, block; 14, 15; 14, 27; 14, 36; 14, 47; 14, 178; 14, 184; 15, if_statement; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:debug; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:print; 23, argument_list; 23, 24; 24, binary_operator:%; 24, 25; 24, 26; 25, string:"------------------ Including a file: %s"; 26, identifier:path; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:inc_dirs; 30, conditional_expression:if; 30, 31; 30, 32; 30, 33; 31, identifier:include_dirs; 32, identifier:include_dirs; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:include_dirs; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:parser; 39, call; 39, 40; 39, 41; 40, identifier:LEMSFileParser; 41, argument_list; 41, 42; 41, 43; 41, 44; 42, identifier:self; 43, identifier:inc_dirs; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:include_includes; 47, if_statement; 47, 48; 47, 57; 47, 105; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:os; 51, identifier:access; 52, argument_list; 52, 53; 52, 54; 53, identifier:path; 54, attribute; 54, 55; 54, 56; 55, identifier:os; 56, identifier:F_OK; 57, block; 57, 58; 58, if_statement; 58, 59; 58, 65; 58, 90; 59, not_operator; 59, 60; 60, comparison_operator:in; 60, 61; 60, 62; 61, identifier:path; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:included_files; 65, block; 65, 66; 65, 80; 65, 89; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:parser; 70, identifier:parse; 71, argument_list; 71, 72; 72, call; 72, 73; 72, 79; 73, attribute; 73, 74; 73, 78; 74, call; 74, 75; 74, 76; 75, identifier:open; 76, argument_list; 76, 77; 77, identifier:path; 78, identifier:read; 79, argument_list; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:included_files; 86, identifier:append; 87, argument_list; 87, 88; 88, identifier:path; 89, return_statement; 90, else_clause; 90, 91; 91, block; 91, 92; 91, 104; 92, if_statement; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:debug; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:print; 100, argument_list; 100, 101; 101, binary_operator:%; 101, 102; 101, 103; 102, string:"Already included: %s"; 103, identifier:path; 104, return_statement; 105, else_clause; 105, 106; 106, block; 106, 107; 107, for_statement; 107, 108; 107, 109; 107, 110; 108, identifier:inc_dir; 109, identifier:inc_dirs; 110, block; 110, 111; 110, 120; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:new_path; 114, parenthesized_expression; 114, 115; 115, binary_operator:+; 115, 116; 115, 119; 116, binary_operator:+; 116, 117; 116, 118; 117, identifier:inc_dir; 118, string:'/'; 119, identifier:path; 120, if_statement; 120, 121; 120, 130; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:os; 124, identifier:access; 125, argument_list; 125, 126; 125, 127; 126, identifier:new_path; 127, attribute; 127, 128; 127, 129; 128, identifier:os; 129, identifier:F_OK; 130, block; 130, 131; 131, if_statement; 131, 132; 131, 138; 131, 163; 132, not_operator; 132, 133; 133, comparison_operator:in; 133, 134; 133, 135; 134, identifier:new_path; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:included_files; 138, block; 138, 139; 138, 153; 138, 162; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:parser; 143, identifier:parse; 144, argument_list; 144, 145; 145, call; 145, 146; 145, 152; 146, attribute; 146, 147; 146, 151; 147, call; 147, 148; 147, 149; 148, identifier:open; 149, argument_list; 149, 150; 150, identifier:new_path; 151, identifier:read; 152, argument_list; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 160; 155, attribute; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:included_files; 159, identifier:append; 160, argument_list; 160, 161; 161, identifier:new_path; 162, return_statement; 163, else_clause; 163, 164; 164, block; 164, 165; 164, 177; 165, if_statement; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:debug; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:print; 173, argument_list; 173, 174; 174, binary_operator:%; 174, 175; 174, 176; 175, string:"Already included: %s"; 176, identifier:path; 177, return_statement; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:msg; 181, binary_operator:+; 181, 182; 181, 183; 182, string:'Unable to open '; 183, identifier:path; 184, if_statement; 184, 185; 184, 188; 184, 194; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:fail_on_missing_includes; 188, block; 188, 189; 189, raise_statement; 189, 190; 190, call; 190, 191; 190, 192; 191, identifier:Exception; 192, argument_list; 192, 193; 193, identifier:msg; 194, elif_clause; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:self; 197, identifier:debug; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 202; 201, identifier:print; 202, argument_list; 202, 203; 203, identifier:msg | def include_file(self, path, include_dirs = []):
if self.include_includes:
if self.debug: print("------------------ Including a file: %s"%path)
inc_dirs = include_dirs if include_dirs else self.include_dirs
parser = LEMSFileParser(self, inc_dirs, self.include_includes)
if os.access(path, os.F_OK):
if not path in self.included_files:
parser.parse(open(path).read())
self.included_files.append(path)
return
else:
if self.debug: print("Already included: %s"%path)
return
else:
for inc_dir in inc_dirs:
new_path = (inc_dir + '/' + path)
if os.access(new_path, os.F_OK):
if not new_path in self.included_files:
parser.parse(open(new_path).read())
self.included_files.append(new_path)
return
else:
if self.debug: print("Already included: %s"%path)
return
msg = 'Unable to open ' + path
if self.fail_on_missing_includes:
raise Exception(msg)
elif self.debug:
print(msg) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:resolve_simulation; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:fc; 6, identifier:ct; 7, block; 7, 8; 7, 73; 7, 193; 7, 257; 7, 337; 8, for_statement; 8, 9; 8, 10; 8, 15; 9, identifier:run; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:ct; 13, identifier:simulation; 14, identifier:runs; 15, block; 15, 16; 15, 64; 16, try_statement; 16, 17; 16, 54; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:run2; 21, call; 21, 22; 21, 23; 22, identifier:Run; 23, argument_list; 23, 24; 23, 33; 23, 36; 23, 45; 24, attribute; 24, 25; 24, 32; 25, subscript; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:fc; 28, identifier:component_references; 29, attribute; 29, 30; 29, 31; 30, identifier:run; 31, identifier:component; 32, identifier:referenced_component; 33, attribute; 33, 34; 33, 35; 34, identifier:run; 35, identifier:variable; 36, attribute; 36, 37; 36, 44; 37, subscript; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:fc; 40, identifier:parameters; 41, attribute; 41, 42; 41, 43; 42, identifier:run; 43, identifier:increment; 44, identifier:numeric_value; 45, attribute; 45, 46; 45, 53; 46, subscript; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:fc; 49, identifier:parameters; 50, attribute; 50, 51; 50, 52; 51, identifier:run; 52, identifier:total; 53, identifier:numeric_value; 54, except_clause; 54, 55; 55, block; 55, 56; 56, raise_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:ModelError; 59, argument_list; 59, 60; 59, 61; 60, string:"Unable to resolve simulation run parameters in component '{0}'"; 61, attribute; 61, 62; 61, 63; 62, identifier:fc; 63, identifier:id; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 71; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:fc; 69, identifier:simulation; 70, identifier:add; 71, argument_list; 71, 72; 72, identifier:run2; 73, for_statement; 73, 74; 73, 75; 73, 80; 74, identifier:record; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:ct; 78, identifier:simulation; 79, identifier:records; 80, block; 80, 81; 80, 184; 81, try_statement; 81, 82; 81, 149; 81, 174; 82, ERROR; 82, 83; 82, 147; 82, 148; 83, ERROR; 83, 84; 83, 85; 83, 86; 83, 95; 83, 109; 84, identifier:record2; 85, identifier:Record; 86, attribute; 86, 87; 86, 94; 87, subscript; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:fc; 90, identifier:paths; 91, attribute; 91, 92; 91, 93; 92, identifier:record; 93, identifier:quantity; 94, identifier:value; 95, conditional_expression:if; 95, 96; 95, 105; 95, 108; 96, attribute; 96, 97; 96, 104; 97, subscript; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:fc; 100, identifier:parameters; 101, attribute; 101, 102; 101, 103; 102, identifier:record; 103, identifier:scale; 104, identifier:numeric_value; 105, attribute; 105, 106; 105, 107; 106, identifier:record; 107, identifier:scale; 108, integer:1; 109, conditional_expression:if; 109, 110; 109, 119; 109, 122; 109, 140; 110, attribute; 110, 111; 110, 118; 111, subscript; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:fc; 114, identifier:texts; 115, attribute; 115, 116; 115, 117; 116, identifier:record; 117, identifier:color; 118, identifier:value; 119, attribute; 119, 120; 119, 121; 120, identifier:record; 121, identifier:color; 122, ERROR; 122, 123; 122, 139; 123, call; 123, 124; 123, 137; 124, attribute; 124, 125; 124, 136; 125, attribute; 125, 126; 125, 133; 125, 135; 126, call; 126, 127; 126, 128; 127, identifier:ModelError; 128, argument_list; 128, 129; 128, 130; 129, string:"Unable to resolve simulation record parameters in component '{0}'"; 130, attribute; 130, 131; 130, 132; 131, identifier:fc; 132, identifier:id; 133, ERROR; 133, 134; 134, identifier:fc; 135, identifier:simulation; 136, identifier:add; 137, argument_list; 137, 138; 138, identifier:record2; 139, identifier:for; 140, comparison_operator:in; 140, 141; 140, 142; 141, identifier:event_record; 142, attribute; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:ct; 145, identifier:simulation; 146, identifier:event_records; 147, block:; 148, identifier:try; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:event_record2; 153, call; 153, 154; 153, 155; 154, identifier:EventRecord; 155, argument_list; 155, 156; 155, 165; 156, attribute; 156, 157; 156, 164; 157, subscript; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:fc; 160, identifier:paths; 161, attribute; 161, 162; 161, 163; 162, identifier:event_record; 163, identifier:quantity; 164, identifier:value; 165, attribute; 165, 166; 165, 173; 166, subscript; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:fc; 169, identifier:texts; 170, attribute; 170, 171; 170, 172; 171, identifier:event_record; 172, identifier:eventPort; 173, identifier:value; 174, except_clause; 174, 175; 175, block; 175, 176; 176, raise_statement; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:ModelError; 179, argument_list; 179, 180; 179, 181; 180, string:"Unable to resolve simulation event_record parameters in component '{0}'"; 181, attribute; 181, 182; 181, 183; 182, identifier:fc; 183, identifier:id; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 191; 186, attribute; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:fc; 189, identifier:simulation; 190, identifier:add; 191, argument_list; 191, 192; 192, identifier:event_record2; 193, for_statement; 193, 194; 193, 195; 193, 200; 194, identifier:dd; 195, attribute; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:ct; 198, identifier:simulation; 199, identifier:data_displays; 200, block; 200, 201; 200, 248; 201, try_statement; 201, 202; 201, 238; 202, block; 202, 203; 202, 219; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:dd2; 206, call; 206, 207; 206, 208; 207, identifier:DataDisplay; 208, argument_list; 208, 209; 208, 218; 209, attribute; 209, 210; 209, 217; 210, subscript; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:fc; 213, identifier:texts; 214, attribute; 214, 215; 214, 216; 215, identifier:dd; 216, identifier:title; 217, identifier:value; 218, string:''; 219, if_statement; 219, 220; 219, 225; 220, comparison_operator:in; 220, 221; 220, 222; 221, string:'timeScale'; 222, attribute; 222, 223; 222, 224; 223, identifier:fc; 224, identifier:parameters; 225, block; 225, 226; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:dd2; 230, identifier:timeScale; 231, attribute; 231, 232; 231, 237; 232, subscript; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:fc; 235, identifier:parameters; 236, string:'timeScale'; 237, identifier:numeric_value; 238, except_clause; 238, 239; 239, block; 239, 240; 240, raise_statement; 240, 241; 241, call; 241, 242; 241, 243; 242, identifier:ModelError; 243, argument_list; 243, 244; 243, 245; 244, string:"Unable to resolve simulation display parameters in component '{0}'"; 245, attribute; 245, 246; 245, 247; 246, identifier:fc; 247, identifier:id; 248, expression_statement; 248, 249; 249, call; 249, 250; 249, 255; 250, attribute; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:fc; 253, identifier:simulation; 254, identifier:add; 255, argument_list; 255, 256; 256, identifier:dd2; 257, for_statement; 257, 258; 257, 259; 257, 264; 258, identifier:dw; 259, attribute; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:ct; 262, identifier:simulation; 263, identifier:data_writers; 264, block; 264, 265; 264, 328; 265, try_statement; 265, 266; 265, 318; 266, block; 266, 267; 266, 271; 266, 302; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:path; 270, string:'.'; 271, if_statement; 271, 272; 271, 289; 272, boolean_operator:and; 272, 273; 272, 280; 273, subscript; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:fc; 276, identifier:texts; 277, attribute; 277, 278; 277, 279; 278, identifier:dw; 279, identifier:path; 280, attribute; 280, 281; 280, 288; 281, subscript; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:fc; 284, identifier:texts; 285, attribute; 285, 286; 285, 287; 286, identifier:dw; 287, identifier:path; 288, identifier:value; 289, block; 289, 290; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:path; 293, attribute; 293, 294; 293, 301; 294, subscript; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:fc; 297, identifier:texts; 298, attribute; 298, 299; 298, 300; 299, identifier:dw; 300, identifier:path; 301, identifier:value; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 305; 304, identifier:dw2; 305, call; 305, 306; 305, 307; 306, identifier:DataWriter; 307, argument_list; 307, 308; 307, 309; 308, identifier:path; 309, attribute; 309, 310; 309, 317; 310, subscript; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:fc; 313, identifier:texts; 314, attribute; 314, 315; 314, 316; 315, identifier:dw; 316, identifier:file_name; 317, identifier:value; 318, except_clause; 318, 319; 319, block; 319, 320; 320, raise_statement; 320, 321; 321, call; 321, 322; 321, 323; 322, identifier:ModelError; 323, argument_list; 323, 324; 323, 325; 324, string:"Unable to resolve simulation writer parameters in component '{0}'"; 325, attribute; 325, 326; 325, 327; 326, identifier:fc; 327, identifier:id; 328, expression_statement; 328, 329; 329, call; 329, 330; 329, 335; 330, attribute; 330, 331; 330, 334; 331, attribute; 331, 332; 331, 333; 332, identifier:fc; 333, identifier:simulation; 334, identifier:add; 335, argument_list; 335, 336; 336, identifier:dw2; 337, for_statement; 337, 338; 337, 339; 337, 344; 338, identifier:ew; 339, attribute; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, identifier:ct; 342, identifier:simulation; 343, identifier:event_writers; 344, block; 344, 345; 344, 417; 345, try_statement; 345, 346; 345, 407; 346, block; 346, 347; 346, 351; 346, 382; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 350; 349, identifier:path; 350, string:'.'; 351, if_statement; 351, 352; 351, 369; 352, boolean_operator:and; 352, 353; 352, 360; 353, subscript; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:fc; 356, identifier:texts; 357, attribute; 357, 358; 357, 359; 358, identifier:ew; 359, identifier:path; 360, attribute; 360, 361; 360, 368; 361, subscript; 361, 362; 361, 365; 362, attribute; 362, 363; 362, 364; 363, identifier:fc; 364, identifier:texts; 365, attribute; 365, 366; 365, 367; 366, identifier:ew; 367, identifier:path; 368, identifier:value; 369, block; 369, 370; 370, expression_statement; 370, 371; 371, assignment; 371, 372; 371, 373; 372, identifier:path; 373, attribute; 373, 374; 373, 381; 374, subscript; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:fc; 377, identifier:texts; 378, attribute; 378, 379; 378, 380; 379, identifier:ew; 380, identifier:path; 381, identifier:value; 382, expression_statement; 382, 383; 383, assignment; 383, 384; 383, 385; 384, identifier:ew2; 385, call; 385, 386; 385, 387; 386, identifier:EventWriter; 387, argument_list; 387, 388; 387, 389; 387, 398; 388, identifier:path; 389, attribute; 389, 390; 389, 397; 390, subscript; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, identifier:fc; 393, identifier:texts; 394, attribute; 394, 395; 394, 396; 395, identifier:ew; 396, identifier:file_name; 397, identifier:value; 398, attribute; 398, 399; 398, 406; 399, subscript; 399, 400; 399, 403; 400, attribute; 400, 401; 400, 402; 401, identifier:fc; 402, identifier:texts; 403, attribute; 403, 404; 403, 405; 404, identifier:ew; 405, identifier:format; 406, identifier:value; 407, except_clause; 407, 408; 408, block; 408, 409; 409, raise_statement; 409, 410; 410, call; 410, 411; 410, 412; 411, identifier:ModelError; 412, argument_list; 412, 413; 412, 414; 413, string:"Unable to resolve simulation writer parameters in component '{0}'"; 414, attribute; 414, 415; 414, 416; 415, identifier:fc; 416, identifier:id; 417, expression_statement; 417, 418; 418, call; 418, 419; 418, 424; 419, attribute; 419, 420; 419, 423; 420, attribute; 420, 421; 420, 422; 421, identifier:fc; 422, identifier:simulation; 423, identifier:add; 424, argument_list; 424, 425; 425, identifier:ew2 | def resolve_simulation(self, fc, ct):
for run in ct.simulation.runs:
try:
run2 = Run(fc.component_references[run.component].referenced_component,
run.variable,
fc.parameters[run.increment].numeric_value,
fc.parameters[run.total].numeric_value)
except:
raise ModelError("Unable to resolve simulation run parameters in component '{0}'",
fc.id)
fc.simulation.add(run2)
for record in ct.simulation.records:
try:
record2 = Record(fc.paths[record.quantity].value,
fc.parameters[record.scale].numeric_value if record.scale else 1,
fc.texts[record.color].value if record.color else '
except:
raise ModelError("Unable to resolve simulation record parameters in component '{0}'",
fc.id)
fc.simulation.add(record2)
for event_record in ct.simulation.event_records:
try:
event_record2 = EventRecord(fc.paths[event_record.quantity].value,
fc.texts[event_record.eventPort].value)
except:
raise ModelError("Unable to resolve simulation event_record parameters in component '{0}'",
fc.id)
fc.simulation.add(event_record2)
for dd in ct.simulation.data_displays:
try:
dd2 = DataDisplay(fc.texts[dd.title].value,
'')
if 'timeScale' in fc.parameters:
dd2.timeScale = fc.parameters['timeScale'].numeric_value
except:
raise ModelError("Unable to resolve simulation display parameters in component '{0}'",
fc.id)
fc.simulation.add(dd2)
for dw in ct.simulation.data_writers:
try:
path = '.'
if fc.texts[dw.path] and fc.texts[dw.path].value:
path = fc.texts[dw.path].value
dw2 = DataWriter(path,
fc.texts[dw.file_name].value)
except:
raise ModelError("Unable to resolve simulation writer parameters in component '{0}'",
fc.id)
fc.simulation.add(dw2)
for ew in ct.simulation.event_writers:
try:
path = '.'
if fc.texts[ew.path] and fc.texts[ew.path].value:
path = fc.texts[ew.path].value
ew2 = EventWriter(path,
fc.texts[ew.file_name].value,
fc.texts[ew.format].value)
except:
raise ModelError("Unable to resolve simulation writer parameters in component '{0}'",
fc.id)
fc.simulation.add(ew2) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:order_derived_parameters; 3, parameters; 3, 4; 4, identifier:component; 5, block; 5, 6; 5, 18; 5, 22; 5, 26; 5, 41; 5, 45; 5, 49; 5, 124; 5, 142; 6, if_statement; 6, 7; 6, 15; 7, comparison_operator:==; 7, 8; 7, 14; 8, call; 8, 9; 8, 10; 9, identifier:len; 10, argument_list; 10, 11; 11, attribute; 11, 12; 11, 13; 12, identifier:component; 13, identifier:derived_parameters; 14, integer:0; 15, block; 15, 16; 16, return_statement; 16, 17; 17, list:[]; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:ordering; 21, list:[]; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:dps; 25, list:[]; 26, for_statement; 26, 27; 26, 28; 26, 31; 27, identifier:dp; 28, attribute; 28, 29; 28, 30; 29, identifier:component; 30, identifier:derived_parameters; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:dps; 36, identifier:append; 37, argument_list; 37, 38; 38, attribute; 38, 39; 38, 40; 39, identifier:dp; 40, identifier:name; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:maxcount; 44, integer:5; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:count; 48, identifier:maxcount; 49, while_statement; 49, 50; 49, 57; 50, boolean_operator:and; 50, 51; 50, 54; 51, comparison_operator:>; 51, 52; 51, 53; 52, identifier:count; 53, integer:0; 54, comparison_operator:!=; 54, 55; 54, 56; 55, identifier:dps; 56, list:[]; 57, block; 57, 58; 57, 64; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:count; 61, binary_operator:-; 61, 62; 61, 63; 62, identifier:count; 63, integer:1; 64, for_statement; 64, 65; 64, 66; 64, 67; 65, identifier:dp1; 66, identifier:dps; 67, block; 67, 68; 67, 78; 67, 82; 67, 99; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:value; 71, attribute; 71, 72; 71, 77; 72, subscript; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:component; 75, identifier:derived_parameters; 76, identifier:dp1; 77, identifier:value; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:found; 81, False; 82, for_statement; 82, 83; 82, 84; 82, 85; 83, identifier:dp2; 84, identifier:dps; 85, block; 85, 86; 86, if_statement; 86, 87; 86, 94; 87, boolean_operator:and; 87, 88; 87, 91; 88, comparison_operator:!=; 88, 89; 88, 90; 89, identifier:dp1; 90, identifier:dp2; 91, comparison_operator:in; 91, 92; 91, 93; 92, identifier:dp2; 93, identifier:value; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:found; 98, True; 99, if_statement; 99, 100; 99, 102; 100, not_operator; 100, 101; 101, identifier:found; 102, block; 102, 103; 102, 110; 102, 119; 102, 123; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:ordering; 107, identifier:append; 108, argument_list; 108, 109; 109, identifier:dp1; 110, delete_statement; 110, 111; 111, subscript; 111, 112; 111, 113; 112, identifier:dps; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:dps; 116, identifier:index; 117, argument_list; 117, 118; 118, identifier:dp1; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:count; 122, identifier:maxcount; 123, break_statement; 124, if_statement; 124, 125; 124, 128; 125, comparison_operator:==; 125, 126; 125, 127; 126, identifier:count; 127, integer:0; 128, block; 128, 129; 129, raise_statement; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:SimBuildError; 132, argument_list; 132, 133; 133, call; 133, 134; 133, 140; 134, attribute; 134, 135; 134, 139; 135, parenthesized_expression; 135, 136; 136, concatenated_string; 136, 137; 136, 138; 137, string:"Unable to find ordering for derived "; 138, string:"parameter in component '{0}'"; 139, identifier:format; 140, argument_list; 140, 141; 141, identifier:component; 142, return_statement; 142, 143; 143, identifier:ordering | def order_derived_parameters(component):
if len(component.derived_parameters) == 0:
return []
ordering = []
dps = []
for dp in component.derived_parameters:
dps.append(dp.name)
maxcount = 5
count = maxcount
while count > 0 and dps != []:
count = count - 1
for dp1 in dps:
value = component.derived_parameters[dp1].value
found = False
for dp2 in dps:
if dp1 != dp2 and dp2 in value:
found = True
if not found:
ordering.append(dp1)
del dps[dps.index(dp1)]
count = maxcount
break
if count == 0:
raise SimBuildError(("Unable to find ordering for derived "
"parameter in component '{0}'").format(component))
return ordering |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:order_derived_variables; 3, parameters; 3, 4; 4, identifier:regime; 5, block; 5, 6; 5, 10; 5, 14; 5, 18; 5, 22; 5, 55; 5, 91; 5, 95; 5, 238; 5, 258; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:ordering; 9, list:[]; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:dvs; 13, list:[]; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:dvsnoexp; 17, list:[]; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:maxcount; 21, integer:5; 22, for_statement; 22, 23; 22, 24; 22, 27; 23, identifier:dv; 24, attribute; 24, 25; 24, 26; 25, identifier:regime; 26, identifier:derived_variables; 27, block; 27, 28; 28, if_statement; 28, 29; 28, 34; 28, 44; 29, comparison_operator:==; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:dv; 32, identifier:expression_tree; 33, None; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:dvsnoexp; 39, identifier:append; 40, argument_list; 40, 41; 41, attribute; 41, 42; 41, 43; 42, identifier:dv; 43, identifier:name; 44, else_clause; 44, 45; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:dvs; 50, identifier:append; 51, argument_list; 51, 52; 52, attribute; 52, 53; 52, 54; 53, identifier:dv; 54, identifier:name; 55, for_statement; 55, 56; 55, 57; 55, 60; 56, identifier:dv; 57, attribute; 57, 58; 57, 59; 58, identifier:regime; 59, identifier:conditional_derived_variables; 60, block; 60, 61; 61, if_statement; 61, 62; 61, 70; 61, 80; 62, comparison_operator:==; 62, 63; 62, 69; 63, call; 63, 64; 63, 65; 64, identifier:len; 65, argument_list; 65, 66; 66, attribute; 66, 67; 66, 68; 67, identifier:dv; 68, identifier:cases; 69, integer:0; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:dvsnoexp; 75, identifier:append; 76, argument_list; 76, 77; 77, attribute; 77, 78; 77, 79; 78, identifier:dv; 79, identifier:name; 80, else_clause; 80, 81; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:dvs; 86, identifier:append; 87, argument_list; 87, 88; 88, attribute; 88, 89; 88, 90; 89, identifier:dv; 90, identifier:name; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:count; 94, identifier:maxcount; 95, while_statement; 95, 96; 95, 103; 96, boolean_operator:and; 96, 97; 96, 100; 97, comparison_operator:>; 97, 98; 97, 99; 98, identifier:count; 99, integer:0; 100, comparison_operator:!=; 100, 101; 100, 102; 101, identifier:dvs; 102, list:[]; 103, block; 103, 104; 103, 110; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:count; 107, binary_operator:-; 107, 108; 107, 109; 108, identifier:count; 109, integer:1; 110, for_statement; 110, 111; 110, 112; 110, 113; 111, identifier:dv1; 112, identifier:dvs; 113, block; 113, 114; 113, 139; 113, 143; 113, 213; 114, if_statement; 114, 115; 114, 120; 114, 129; 115, comparison_operator:in; 115, 116; 115, 117; 116, identifier:dv1; 117, attribute; 117, 118; 117, 119; 118, identifier:regime; 119, identifier:derived_variables; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:dv; 124, subscript; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:regime; 127, identifier:derived_variables; 128, identifier:dv1; 129, else_clause; 129, 130; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:dv; 134, subscript; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:regime; 137, identifier:conditional_derived_variables; 138, identifier:dv1; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:found; 142, False; 143, if_statement; 143, 144; 143, 149; 143, 175; 144, call; 144, 145; 144, 146; 145, identifier:isinstance; 146, argument_list; 146, 147; 146, 148; 147, identifier:dv; 148, identifier:DerivedVariable; 149, block; 149, 150; 149, 156; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:exp_tree; 153, attribute; 153, 154; 153, 155; 154, identifier:dv; 155, identifier:expression_tree; 156, for_statement; 156, 157; 156, 158; 156, 159; 157, identifier:dv2; 158, identifier:dvs; 159, block; 159, 160; 160, if_statement; 160, 161; 160, 170; 161, boolean_operator:and; 161, 162; 161, 165; 162, comparison_operator:!=; 162, 163; 162, 164; 163, identifier:dv1; 164, identifier:dv2; 165, call; 165, 166; 165, 167; 166, identifier:is_var_in_exp_tree; 167, argument_list; 167, 168; 167, 169; 168, identifier:dv2; 169, identifier:exp_tree; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:found; 174, True; 175, else_clause; 175, 176; 176, block; 176, 177; 177, for_statement; 177, 178; 177, 179; 177, 182; 178, identifier:case; 179, attribute; 179, 180; 179, 181; 180, identifier:dv; 181, identifier:cases; 182, block; 182, 183; 183, for_statement; 183, 184; 183, 185; 183, 186; 184, identifier:dv2; 185, identifier:dvs; 186, block; 186, 187; 187, if_statement; 187, 188; 187, 208; 188, boolean_operator:and; 188, 189; 188, 192; 189, comparison_operator:!=; 189, 190; 189, 191; 190, identifier:dv1; 191, identifier:dv2; 192, parenthesized_expression; 192, 193; 193, boolean_operator:or; 193, 194; 193, 201; 194, call; 194, 195; 194, 196; 195, identifier:is_var_in_exp_tree; 196, argument_list; 196, 197; 196, 198; 197, identifier:dv2; 198, attribute; 198, 199; 198, 200; 199, identifier:case; 200, identifier:condition_expression_tree; 201, call; 201, 202; 201, 203; 202, identifier:is_var_in_exp_tree; 203, argument_list; 203, 204; 203, 205; 204, identifier:dv2; 205, attribute; 205, 206; 205, 207; 206, identifier:case; 207, identifier:value_expression_tree; 208, block; 208, 209; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:found; 212, True; 213, if_statement; 213, 214; 213, 216; 214, not_operator; 214, 215; 215, identifier:found; 216, block; 216, 217; 216, 224; 216, 233; 216, 237; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:ordering; 221, identifier:append; 222, argument_list; 222, 223; 223, identifier:dv1; 224, delete_statement; 224, 225; 225, subscript; 225, 226; 225, 227; 226, identifier:dvs; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:dvs; 230, identifier:index; 231, argument_list; 231, 232; 232, identifier:dv1; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:count; 236, identifier:maxcount; 237, break_statement; 238, if_statement; 238, 239; 238, 242; 239, comparison_operator:==; 239, 240; 239, 241; 240, identifier:count; 241, integer:0; 242, block; 242, 243; 243, raise_statement; 243, 244; 244, call; 244, 245; 244, 246; 245, identifier:SimBuildError; 246, argument_list; 246, 247; 247, call; 247, 248; 247, 254; 248, attribute; 248, 249; 248, 253; 249, parenthesized_expression; 249, 250; 250, concatenated_string; 250, 251; 250, 252; 251, string:"Unable to find ordering for derived "; 252, string:"variables in regime '{0}'"; 253, identifier:format; 254, argument_list; 254, 255; 255, attribute; 255, 256; 255, 257; 256, identifier:regime; 257, identifier:name; 258, return_statement; 258, 259; 259, binary_operator:+; 259, 260; 259, 261; 260, identifier:dvsnoexp; 261, identifier:ordering | def order_derived_variables(regime):
ordering = []
dvs = []
dvsnoexp = []
maxcount = 5
for dv in regime.derived_variables:
if dv.expression_tree == None:
dvsnoexp.append(dv.name)
else:
dvs.append(dv.name)
for dv in regime.conditional_derived_variables:
if len(dv.cases) == 0:
dvsnoexp.append(dv.name)
else:
dvs.append(dv.name)
count = maxcount
while count > 0 and dvs != []:
count = count - 1
for dv1 in dvs:
if dv1 in regime.derived_variables:
dv = regime.derived_variables[dv1]
else:
dv = regime.conditional_derived_variables[dv1]
found = False
if isinstance(dv, DerivedVariable):
exp_tree = dv.expression_tree
for dv2 in dvs:
if dv1 != dv2 and is_var_in_exp_tree(dv2, exp_tree):
found = True
else:
for case in dv.cases:
for dv2 in dvs:
if dv1 != dv2 and (is_var_in_exp_tree(dv2, case.condition_expression_tree) or
is_var_in_exp_tree(dv2, case.value_expression_tree)):
found = True
if not found:
ordering.append(dv1)
del dvs[dvs.index(dv1)]
count = maxcount
break
if count == 0:
raise SimBuildError(("Unable to find ordering for derived "
"variables in regime '{0}'").format(regime.name))
return dvsnoexp + ordering |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:build_event_connections; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:component; 6, identifier:runnable; 7, identifier:structure; 8, block; 8, 9; 8, 30; 9, if_statement; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:debug; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:print; 17, argument_list; 17, 18; 18, binary_operator:%; 18, 19; 18, 20; 19, string:"\n++++++++ Calling build_event_connections of %s with runnable %s, parent %s"; 20, tuple; 20, 21; 20, 24; 20, 27; 21, attribute; 21, 22; 21, 23; 22, identifier:component; 23, identifier:id; 24, attribute; 24, 25; 24, 26; 25, identifier:runnable; 26, identifier:id; 27, attribute; 27, 28; 27, 29; 28, identifier:runnable; 29, identifier:parent; 30, for_statement; 30, 31; 30, 32; 30, 35; 31, identifier:ec; 32, attribute; 32, 33; 32, 34; 33, identifier:structure; 34, identifier:event_connections; 35, block; 35, 36; 35, 50; 35, 63; 35, 76; 35, 170; 35, 176; 35, 182; 35, 222; 35, 260; 35, 284; 36, if_statement; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:debug; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:print; 44, argument_list; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:ec; 48, identifier:toxml; 49, argument_list; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:source; 53, call; 53, 54; 53, 59; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:runnable; 57, identifier:parent; 58, identifier:resolve_path; 59, argument_list; 59, 60; 60, attribute; 60, 61; 60, 62; 61, identifier:ec; 62, identifier:from_; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:target; 66, call; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:runnable; 70, identifier:parent; 71, identifier:resolve_path; 72, argument_list; 72, 73; 73, attribute; 73, 74; 73, 75; 74, identifier:ec; 75, identifier:to; 76, if_statement; 76, 77; 76, 80; 76, 146; 77, attribute; 77, 78; 77, 79; 78, identifier:ec; 79, identifier:receiver; 80, block; 80, 81; 80, 93; 80, 101; 80, 117; 80, 132; 80, 142; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:receiver_template; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:build_runnable; 88, argument_list; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:ec; 91, identifier:receiver; 92, identifier:target; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:receiver; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:receiver_template; 99, identifier:copy; 100, argument_list; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:receiver; 105, identifier:id; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, string:"{0}__{1}__"; 109, identifier:format; 110, argument_list; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:component; 113, identifier:id; 114, attribute; 114, 115; 114, 116; 115, identifier:receiver_template; 116, identifier:id; 117, if_statement; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:ec; 120, identifier:receiver_container; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:target; 126, identifier:add_attachment; 127, argument_list; 127, 128; 127, 129; 128, identifier:receiver; 129, attribute; 129, 130; 129, 131; 130, identifier:ec; 131, identifier:receiver_container; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:target; 136, identifier:add_child; 137, argument_list; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:receiver_template; 140, identifier:id; 141, identifier:receiver; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:target; 145, identifier:receiver; 146, else_clause; 146, 147; 147, block; 147, 148; 147, 159; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:source; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:runnable; 154, identifier:resolve_path; 155, argument_list; 155, 156; 156, attribute; 156, 157; 156, 158; 157, identifier:ec; 158, identifier:from_; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:target; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:runnable; 165, identifier:resolve_path; 166, argument_list; 166, 167; 167, attribute; 167, 168; 167, 169; 168, identifier:ec; 169, identifier:to; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:source_port; 173, attribute; 173, 174; 173, 175; 174, identifier:ec; 175, identifier:source_port; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:target_port; 179, attribute; 179, 180; 179, 181; 180, identifier:ec; 181, identifier:target_port; 182, if_statement; 182, 183; 182, 185; 183, not_operator; 183, 184; 184, identifier:source_port; 185, block; 185, 186; 186, if_statement; 186, 187; 186, 195; 186, 204; 187, comparison_operator:==; 187, 188; 187, 194; 188, call; 188, 189; 188, 190; 189, identifier:len; 190, argument_list; 190, 191; 191, attribute; 191, 192; 191, 193; 192, identifier:source; 193, identifier:event_out_ports; 194, integer:1; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:source_port; 199, subscript; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:source; 202, identifier:event_out_ports; 203, integer:0; 204, else_clause; 204, 205; 205, block; 205, 206; 206, raise_statement; 206, 207; 207, call; 207, 208; 207, 209; 208, identifier:SimBuildError; 209, argument_list; 209, 210; 210, call; 210, 211; 210, 218; 211, attribute; 211, 212; 211, 217; 212, parenthesized_expression; 212, 213; 213, concatenated_string; 213, 214; 213, 215; 213, 216; 214, string:"No source event port "; 215, string:"uniquely identifiable"; 216, string:" in '{0}'"; 217, identifier:format; 218, argument_list; 218, 219; 219, attribute; 219, 220; 219, 221; 220, identifier:source; 221, identifier:id; 222, if_statement; 222, 223; 222, 225; 223, not_operator; 223, 224; 224, identifier:target_port; 225, block; 225, 226; 226, if_statement; 226, 227; 226, 235; 226, 244; 227, comparison_operator:==; 227, 228; 227, 234; 228, call; 228, 229; 228, 230; 229, identifier:len; 230, argument_list; 230, 231; 231, attribute; 231, 232; 231, 233; 232, identifier:target; 233, identifier:event_in_ports; 234, integer:1; 235, block; 235, 236; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:target_port; 239, subscript; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:target; 242, identifier:event_in_ports; 243, integer:0; 244, else_clause; 244, 245; 245, block; 245, 246; 246, raise_statement; 246, 247; 247, call; 247, 248; 247, 249; 248, identifier:SimBuildError; 249, argument_list; 249, 250; 250, call; 250, 251; 250, 258; 251, attribute; 251, 252; 251, 257; 252, parenthesized_expression; 252, 253; 253, concatenated_string; 253, 254; 253, 255; 253, 256; 254, string:"No destination event port "; 255, string:"uniquely identifiable "; 256, string:"in '{0}'"; 257, identifier:format; 258, argument_list; 258, 259; 259, identifier:target; 260, if_statement; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:self; 263, identifier:debug; 264, block; 264, 265; 265, expression_statement; 265, 266; 266, call; 266, 267; 266, 268; 267, identifier:print; 268, argument_list; 268, 269; 269, binary_operator:%; 269, 270; 269, 271; 270, string:"register_event_out_callback\n Source: %s, %s (port: %s) \n -> %s, %s (port: %s)"; 271, tuple; 271, 272; 271, 273; 271, 277; 271, 278; 271, 279; 271, 283; 272, identifier:source; 273, call; 273, 274; 273, 275; 274, identifier:id; 275, argument_list; 275, 276; 276, identifier:source; 277, identifier:source_port; 278, identifier:target; 279, call; 279, 280; 279, 281; 280, identifier:id; 281, argument_list; 281, 282; 282, identifier:target; 283, identifier:target_port; 284, expression_statement; 284, 285; 285, call; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:source; 288, identifier:register_event_out_callback; 289, argument_list; 289, 290; 289, 291; 289, 292; 290, line_continuation:\; 291, identifier:source_port; 292, lambda; 292, 293; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:target; 296, identifier:inc_event_in; 297, argument_list; 297, 298; 298, identifier:target_port | def build_event_connections(self, component, runnable, structure):
if self.debug: print("\n++++++++ Calling build_event_connections of %s with runnable %s, parent %s"%(component.id, runnable.id, runnable.parent))
for ec in structure.event_connections:
if self.debug: print(ec.toxml())
source = runnable.parent.resolve_path(ec.from_)
target = runnable.parent.resolve_path(ec.to)
if ec.receiver:
receiver_template = self.build_runnable(ec.receiver,
target)
receiver = receiver_template.copy()
receiver.id = "{0}__{1}__".format(component.id,
receiver_template.id)
if ec.receiver_container:
target.add_attachment(receiver, ec.receiver_container)
target.add_child(receiver_template.id, receiver)
target = receiver
else:
source = runnable.resolve_path(ec.from_)
target = runnable.resolve_path(ec.to)
source_port = ec.source_port
target_port = ec.target_port
if not source_port:
if len(source.event_out_ports) == 1:
source_port = source.event_out_ports[0]
else:
raise SimBuildError(("No source event port "
"uniquely identifiable"
" in '{0}'").format(source.id))
if not target_port:
if len(target.event_in_ports) == 1:
target_port = target.event_in_ports[0]
else:
raise SimBuildError(("No destination event port "
"uniquely identifiable "
"in '{0}'").format(target))
if self.debug: print("register_event_out_callback\n Source: %s, %s (port: %s) \n -> %s, %s (port: %s)"%(source, id(source), source_port, target, id(target), target_port))
source.register_event_out_callback(\
source_port, lambda: target.inc_event_in(target_port)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:build_foreach; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:component; 6, identifier:runnable; 7, identifier:foreach; 8, default_parameter; 8, 9; 8, 10; 9, identifier:name_mappings; 10, dictionary; 11, block; 11, 12; 11, 34; 11, 45; 12, if_statement; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:debug; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:print; 20, argument_list; 20, 21; 21, binary_operator:%; 21, 22; 21, 23; 22, string:"\n++++++++ Calling build_foreach of %s with runnable %s, parent %s, name_mappings: %s"; 23, tuple; 23, 24; 23, 27; 23, 30; 23, 33; 24, attribute; 24, 25; 24, 26; 25, identifier:component; 26, identifier:id; 27, attribute; 27, 28; 27, 29; 28, identifier:runnable; 29, identifier:id; 30, attribute; 30, 31; 30, 32; 31, identifier:runnable; 32, identifier:parent; 33, identifier:name_mappings; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:target_array; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:runnable; 40, identifier:resolve_path; 41, argument_list; 41, 42; 42, attribute; 42, 43; 42, 44; 43, identifier:foreach; 44, identifier:instances; 45, for_statement; 45, 46; 45, 47; 45, 48; 46, identifier:target_runnable; 47, identifier:target_array; 48, block; 48, 49; 48, 67; 48, 75; 48, 114; 49, if_statement; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:debug; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 57; 56, identifier:print; 57, argument_list; 57, 58; 58, binary_operator:%; 58, 59; 58, 60; 59, string:"Applying contents of for_each to %s, as %s"; 60, tuple; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:target_runnable; 63, identifier:id; 64, attribute; 64, 65; 64, 66; 65, identifier:foreach; 66, identifier:as_; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 74; 69, subscript; 69, 70; 69, 71; 70, identifier:name_mappings; 71, attribute; 71, 72; 71, 73; 72, identifier:foreach; 73, identifier:as_; 74, identifier:target_runnable; 75, for_statement; 75, 76; 75, 77; 75, 80; 76, identifier:fe2; 77, attribute; 77, 78; 77, 79; 78, identifier:foreach; 79, identifier:for_eachs; 80, block; 80, 81; 80, 92; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:target_array2; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:runnable; 87, identifier:resolve_path; 88, argument_list; 88, 89; 89, attribute; 89, 90; 89, 91; 90, identifier:fe2; 91, identifier:instances; 92, for_statement; 92, 93; 92, 94; 92, 95; 93, identifier:target_runnable2; 94, identifier:target_array2; 95, block; 95, 96; 95, 104; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 103; 98, subscript; 98, 99; 98, 100; 99, identifier:name_mappings; 100, attribute; 100, 101; 100, 102; 101, identifier:fe2; 102, identifier:as_; 103, identifier:target_runnable2; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:build_foreach; 109, argument_list; 109, 110; 109, 111; 109, 112; 109, 113; 110, identifier:component; 111, identifier:runnable; 112, identifier:fe2; 113, identifier:name_mappings; 114, for_statement; 114, 115; 114, 116; 114, 119; 115, identifier:ec; 116, attribute; 116, 117; 116, 118; 117, identifier:foreach; 118, identifier:event_connections; 119, block; 119, 120; 119, 128; 119, 136; 119, 142; 119, 148; 119, 188; 119, 226; 119, 250; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:source; 123, subscript; 123, 124; 123, 125; 124, identifier:name_mappings; 125, attribute; 125, 126; 125, 127; 126, identifier:ec; 127, identifier:from_; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:target; 131, subscript; 131, 132; 131, 133; 132, identifier:name_mappings; 133, attribute; 133, 134; 133, 135; 134, identifier:ec; 135, identifier:to; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:source_port; 139, attribute; 139, 140; 139, 141; 140, identifier:ec; 141, identifier:source_port; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:target_port; 145, attribute; 145, 146; 145, 147; 146, identifier:ec; 147, identifier:target_port; 148, if_statement; 148, 149; 148, 151; 149, not_operator; 149, 150; 150, identifier:source_port; 151, block; 151, 152; 152, if_statement; 152, 153; 152, 161; 152, 170; 153, comparison_operator:==; 153, 154; 153, 160; 154, call; 154, 155; 154, 156; 155, identifier:len; 156, argument_list; 156, 157; 157, attribute; 157, 158; 157, 159; 158, identifier:source; 159, identifier:event_out_ports; 160, integer:1; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:source_port; 165, subscript; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:source; 168, identifier:event_out_ports; 169, integer:0; 170, else_clause; 170, 171; 171, block; 171, 172; 172, raise_statement; 172, 173; 173, call; 173, 174; 173, 175; 174, identifier:SimBuildError; 175, argument_list; 175, 176; 176, call; 176, 177; 176, 184; 177, attribute; 177, 178; 177, 183; 178, parenthesized_expression; 178, 179; 179, concatenated_string; 179, 180; 179, 181; 179, 182; 180, string:"No source event port "; 181, string:"uniquely identifiable"; 182, string:" in '{0}'"; 183, identifier:format; 184, argument_list; 184, 185; 185, attribute; 185, 186; 185, 187; 186, identifier:source; 187, identifier:id; 188, if_statement; 188, 189; 188, 191; 189, not_operator; 189, 190; 190, identifier:target_port; 191, block; 191, 192; 192, if_statement; 192, 193; 192, 201; 192, 210; 193, comparison_operator:==; 193, 194; 193, 200; 194, call; 194, 195; 194, 196; 195, identifier:len; 196, argument_list; 196, 197; 197, attribute; 197, 198; 197, 199; 198, identifier:target; 199, identifier:event_in_ports; 200, integer:1; 201, block; 201, 202; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:target_port; 205, subscript; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:target; 208, identifier:event_in_ports; 209, integer:0; 210, else_clause; 210, 211; 211, block; 211, 212; 212, raise_statement; 212, 213; 213, call; 213, 214; 213, 215; 214, identifier:SimBuildError; 215, argument_list; 215, 216; 216, call; 216, 217; 216, 224; 217, attribute; 217, 218; 217, 223; 218, parenthesized_expression; 218, 219; 219, concatenated_string; 219, 220; 219, 221; 219, 222; 220, string:"No destination event port "; 221, string:"uniquely identifiable "; 222, string:"in '{0}'"; 223, identifier:format; 224, argument_list; 224, 225; 225, identifier:target; 226, if_statement; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:self; 229, identifier:debug; 230, block; 230, 231; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:print; 234, argument_list; 234, 235; 235, binary_operator:%; 235, 236; 235, 237; 236, string:"register_event_out_callback\n Source: %s, %s (port: %s) \n -> %s, %s (port: %s)"; 237, tuple; 237, 238; 237, 239; 237, 243; 237, 244; 237, 245; 237, 249; 238, identifier:source; 239, call; 239, 240; 239, 241; 240, identifier:id; 241, argument_list; 241, 242; 242, identifier:source; 243, identifier:source_port; 244, identifier:target; 245, call; 245, 246; 245, 247; 246, identifier:id; 247, argument_list; 247, 248; 248, identifier:target; 249, identifier:target_port; 250, expression_statement; 250, 251; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:source; 254, identifier:register_event_out_callback; 255, argument_list; 255, 256; 255, 257; 255, 258; 256, line_continuation:\; 257, identifier:source_port; 258, lambda; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:target; 262, identifier:inc_event_in; 263, argument_list; 263, 264; 264, identifier:target_port | def build_foreach(self, component, runnable, foreach, name_mappings = {}):
if self.debug: print("\n++++++++ Calling build_foreach of %s with runnable %s, parent %s, name_mappings: %s"%(component.id, runnable.id, runnable.parent, name_mappings))
target_array = runnable.resolve_path(foreach.instances)
for target_runnable in target_array:
if self.debug: print("Applying contents of for_each to %s, as %s"%(target_runnable.id, foreach.as_))
name_mappings[foreach.as_] = target_runnable
for fe2 in foreach.for_eachs:
target_array2 = runnable.resolve_path(fe2.instances)
for target_runnable2 in target_array2:
name_mappings[fe2.as_] = target_runnable2
self.build_foreach(component, runnable, fe2, name_mappings)
for ec in foreach.event_connections:
source = name_mappings[ec.from_]
target = name_mappings[ec.to]
source_port = ec.source_port
target_port = ec.target_port
if not source_port:
if len(source.event_out_ports) == 1:
source_port = source.event_out_ports[0]
else:
raise SimBuildError(("No source event port "
"uniquely identifiable"
" in '{0}'").format(source.id))
if not target_port:
if len(target.event_in_ports) == 1:
target_port = target.event_in_ports[0]
else:
raise SimBuildError(("No destination event port "
"uniquely identifiable "
"in '{0}'").format(target))
if self.debug: print("register_event_out_callback\n Source: %s, %s (port: %s) \n -> %s, %s (port: %s)"%(source, id(source), source_port, target, id(target), target_port))
source.register_event_out_callback(\
source_port, lambda: target.inc_event_in(target_port)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:check_static_member_vars; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:class_; 5, default_parameter; 5, 6; 5, 7; 6, identifier:fpath; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:only_init; 10, True; 11, block; 11, 12; 11, 17; 11, 89; 11, 98; 11, 101; 11, 110; 11, 132; 11, 175; 11, 179; 11, 216; 11, 220; 11, 224; 11, 289; 11, 298; 11, 300; 12, import_statement; 12, 13; 13, aliased_import; 13, 14; 13, 16; 14, dotted_name; 14, 15; 15, identifier:utool; 16, identifier:ut; 17, if_statement; 17, 18; 17, 25; 17, 40; 18, call; 18, 19; 18, 20; 19, identifier:isinstance; 20, argument_list; 20, 21; 20, 22; 21, identifier:class_; 22, attribute; 22, 23; 22, 24; 23, identifier:six; 24, identifier:string_types; 25, block; 25, 26; 25, 30; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:classname; 29, identifier:class_; 30, if_statement; 30, 31; 30, 34; 31, comparison_operator:is; 31, 32; 31, 33; 32, identifier:fpath; 33, None; 34, block; 34, 35; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:Exception; 38, argument_list; 38, 39; 39, string:'must specify fpath'; 40, else_clause; 40, 41; 41, block; 41, 42; 41, 60; 41, 66; 42, if_statement; 42, 43; 42, 49; 43, not_operator; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:isinstance; 46, argument_list; 46, 47; 46, 48; 47, identifier:class_; 48, identifier:type; 49, block; 49, 50; 49, 54; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:class_instance; 53, identifier:class_; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:class_; 57, attribute; 57, 58; 57, 59; 58, identifier:class_instance; 59, identifier:__class__; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:classname; 63, attribute; 63, 64; 63, 65; 64, identifier:class_; 65, identifier:__name__; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:is; 67, 68; 67, 69; 68, identifier:fpath; 69, None; 70, block; 70, 71; 70, 80; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:module; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:ut; 77, identifier:get_module_from_class; 78, argument_list; 78, 79; 79, identifier:class_; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:fpath; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:ut; 86, identifier:get_modpath; 87, argument_list; 87, 88; 88, identifier:module; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:sourcecode; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:ut; 95, identifier:readfrom; 96, argument_list; 96, 97; 97, identifier:fpath; 98, import_statement; 98, 99; 99, dotted_name; 99, 100; 100, identifier:redbaron; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:baron; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:redbaron; 107, identifier:RedBaron; 108, argument_list; 108, 109; 109, identifier:sourcecode; 110, for_statement; 110, 111; 110, 112; 110, 113; 111, identifier:node; 112, identifier:baron; 113, block; 113, 114; 114, if_statement; 114, 115; 114, 126; 115, boolean_operator:and; 115, 116; 115, 121; 116, comparison_operator:==; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:node; 119, identifier:type; 120, string:'class'; 121, comparison_operator:==; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:node; 124, identifier:name; 125, identifier:classname; 126, block; 126, 127; 126, 131; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:classnode; 130, identifier:node; 131, break_statement; 132, function_definition; 132, 133; 132, 134; 132, 136; 133, function_name:find_parent_method; 134, parameters; 134, 135; 135, identifier:node; 136, block; 136, 137; 136, 146; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:par; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:node; 143, identifier:parent_find; 144, argument_list; 144, 145; 145, string:'def'; 146, if_statement; 146, 147; 146, 156; 147, boolean_operator:and; 147, 148; 147, 151; 148, comparison_operator:is; 148, 149; 148, 150; 149, identifier:par; 150, None; 151, comparison_operator:is; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:par; 154, identifier:parent; 155, None; 156, block; 156, 157; 157, if_statement; 157, 158; 157, 165; 157, 168; 158, comparison_operator:==; 158, 159; 158, 164; 159, attribute; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:par; 162, identifier:parent; 163, identifier:type; 164, string:'class'; 165, block; 165, 166; 166, return_statement; 166, 167; 167, identifier:par; 168, else_clause; 168, 169; 169, block; 169, 170; 170, return_statement; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:find_parent_method; 173, argument_list; 173, 174; 174, identifier:par; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:class_methods; 178, list:[]; 179, for_statement; 179, 180; 179, 181; 179, 182; 180, identifier:node; 181, identifier:classnode; 182, block; 182, 183; 183, if_statement; 183, 184; 183, 189; 184, comparison_operator:==; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:node; 187, identifier:type; 188, string:'def'; 189, block; 189, 190; 190, if_statement; 190, 191; 190, 192; 190, 207; 191, identifier:only_init; 192, block; 192, 193; 193, if_statement; 193, 194; 193, 199; 194, comparison_operator:==; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:node; 197, identifier:name; 198, string:'__init__'; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:class_methods; 204, identifier:append; 205, argument_list; 205, 206; 206, identifier:node; 207, else_clause; 207, 208; 208, block; 208, 209; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:class_methods; 213, identifier:append; 214, argument_list; 214, 215; 215, identifier:node; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:class_vars; 219, list:[]; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:self_vars; 223, list:[]; 224, for_statement; 224, 225; 224, 226; 224, 227; 225, identifier:method_node; 226, identifier:class_methods; 227, block; 227, 228; 227, 240; 227, 247; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:self_var; 231, call; 231, 232; 231, 239; 232, attribute; 232, 233; 232, 238; 233, subscript; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:method_node; 236, identifier:arguments; 237, integer:0; 238, identifier:dumps; 239, argument_list; 240, expression_statement; 240, 241; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:self_vars; 244, identifier:append; 245, argument_list; 245, 246; 246, identifier:self_var; 247, for_statement; 247, 248; 247, 249; 247, 255; 248, identifier:assign; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:method_node; 252, identifier:find_all; 253, argument_list; 253, 254; 254, string:'assignment'; 255, block; 255, 256; 256, if_statement; 256, 257; 256, 271; 257, call; 257, 258; 257, 267; 258, attribute; 258, 259; 258, 266; 259, call; 259, 260; 259, 265; 260, attribute; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:assign; 263, identifier:target; 264, identifier:dumps; 265, argument_list; 266, identifier:startswith; 267, argument_list; 267, 268; 268, binary_operator:+; 268, 269; 268, 270; 269, identifier:self_var; 270, string:'.'; 271, block; 271, 272; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:class_vars; 276, identifier:append; 277, argument_list; 277, 278; 278, call; 278, 279; 278, 288; 279, attribute; 279, 280; 279, 287; 280, subscript; 280, 281; 280, 286; 281, attribute; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:assign; 284, identifier:target; 285, identifier:value; 286, integer:1; 287, identifier:dumps; 288, argument_list; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 292; 291, identifier:static_attrs; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:ut; 295, identifier:unique; 296, argument_list; 296, 297; 297, identifier:class_vars; 298, return_statement; 298, 299; 299, identifier:static_attrs; 300, if_statement; 300, 301; 300, 302; 301, False; 302, block; 302, 303; 302, 309; 302, 313; 302, 317; 302, 338; 302, 397; 302, 401; 302, 437; 302, 446; 303, expression_statement; 303, 304; 304, assignment; 304, 305; 304, 306; 305, identifier:self_var; 306, subscript; 306, 307; 306, 308; 307, identifier:self_vars; 308, integer:0; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 312; 311, identifier:complex_cases; 312, list:[]; 313, expression_statement; 313, 314; 314, assignment; 314, 315; 314, 316; 315, identifier:simple_cases; 316, list:[]; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 320; 319, identifier:all_self_ref; 320, call; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:classnode; 323, identifier:find_all; 324, argument_list; 324, 325; 324, 326; 325, string:'name_'; 326, keyword_argument; 326, 327; 326, 328; 327, identifier:value; 328, call; 328, 329; 328, 332; 329, attribute; 329, 330; 329, 331; 330, identifier:re; 331, identifier:compile; 332, argument_list; 332, 333; 333, binary_operator:+; 333, 334; 333, 337; 334, binary_operator:+; 334, 335; 334, 336; 335, string:'.*'; 336, identifier:self_var; 337, string:'\\.*'; 338, for_statement; 338, 339; 338, 340; 338, 341; 339, identifier:x; 340, identifier:all_self_ref; 341, block; 341, 342; 341, 352; 342, if_statement; 342, 343; 342, 350; 343, comparison_operator:==; 343, 344; 343, 349; 344, attribute; 344, 345; 344, 348; 345, attribute; 345, 346; 345, 347; 346, identifier:x; 347, identifier:parent; 348, identifier:type; 349, string:'def_argument'; 350, block; 350, 351; 351, continue_statement; 352, if_statement; 352, 353; 352, 360; 353, comparison_operator:==; 353, 354; 353, 359; 354, attribute; 354, 355; 354, 358; 355, attribute; 355, 356; 355, 357; 356, identifier:x; 357, identifier:parent; 358, identifier:type; 359, string:'atomtrailers'; 360, block; 360, 361; 360, 367; 361, expression_statement; 361, 362; 362, assignment; 362, 363; 362, 364; 363, identifier:atom; 364, attribute; 364, 365; 364, 366; 365, identifier:x; 366, identifier:parent; 367, if_statement; 367, 368; 367, 380; 367, 388; 368, comparison_operator:<=; 368, 369; 368, 379; 369, call; 369, 370; 369, 373; 370, attribute; 370, 371; 370, 372; 371, identifier:ut; 372, identifier:depth; 373, argument_list; 373, 374; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:atom; 377, identifier:fst; 378, argument_list; 379, integer:3; 380, block; 380, 381; 381, expression_statement; 381, 382; 382, call; 382, 383; 382, 386; 383, attribute; 383, 384; 383, 385; 384, identifier:simple_cases; 385, identifier:append; 386, argument_list; 386, 387; 387, identifier:atom; 388, else_clause; 388, 389; 389, block; 389, 390; 390, expression_statement; 390, 391; 391, call; 391, 392; 391, 395; 392, attribute; 392, 393; 392, 394; 393, identifier:complex_cases; 394, identifier:append; 395, argument_list; 395, 396; 396, identifier:atom; 397, expression_statement; 397, 398; 398, assignment; 398, 399; 398, 400; 399, identifier:accessed_attrs; 400, list:[]; 401, for_statement; 401, 402; 401, 403; 401, 404; 402, identifier:x; 403, identifier:simple_cases; 404, block; 404, 405; 405, if_statement; 405, 406; 405, 417; 406, comparison_operator:==; 406, 407; 406, 416; 407, call; 407, 408; 407, 415; 408, attribute; 408, 409; 408, 414; 409, subscript; 409, 410; 409, 413; 410, attribute; 410, 411; 410, 412; 411, identifier:x; 412, identifier:value; 413, integer:0; 414, identifier:dumps; 415, argument_list; 416, identifier:self_var; 417, block; 417, 418; 417, 430; 418, expression_statement; 418, 419; 419, assignment; 419, 420; 419, 421; 420, identifier:attr; 421, call; 421, 422; 421, 429; 422, attribute; 422, 423; 422, 428; 423, subscript; 423, 424; 423, 427; 424, attribute; 424, 425; 424, 426; 425, identifier:x; 426, identifier:value; 427, integer:1; 428, identifier:dumps; 429, argument_list; 430, expression_statement; 430, 431; 431, call; 431, 432; 431, 435; 432, attribute; 432, 433; 432, 434; 433, identifier:accessed_attrs; 434, identifier:append; 435, argument_list; 435, 436; 436, identifier:attr; 437, expression_statement; 437, 438; 438, assignment; 438, 439; 438, 440; 439, identifier:accessed_attrs; 440, call; 440, 441; 440, 444; 441, attribute; 441, 442; 441, 443; 442, identifier:ut; 443, identifier:unique; 444, argument_list; 444, 445; 445, identifier:accessed_attrs; 446, expression_statement; 446, 447; 447, call; 447, 448; 447, 451; 448, attribute; 448, 449; 448, 450; 449, identifier:ut; 450, identifier:setdiff; 451, argument_list; 451, 452; 451, 453; 452, identifier:accessed_attrs; 453, identifier:class_vars | def check_static_member_vars(class_, fpath=None, only_init=True):
import utool as ut
if isinstance(class_, six.string_types):
classname = class_
if fpath is None:
raise Exception('must specify fpath')
else:
if not isinstance(class_, type):
class_instance = class_
class_ = class_instance.__class__
classname = class_.__name__
if fpath is None:
module = ut.get_module_from_class(class_)
fpath = ut.get_modpath(module)
sourcecode = ut.readfrom(fpath)
import redbaron
baron = redbaron.RedBaron(sourcecode)
for node in baron:
if node.type == 'class' and node.name == classname:
classnode = node
break
def find_parent_method(node):
par = node.parent_find('def')
if par is not None and par.parent is not None:
if par.parent.type == 'class':
return par
else:
return find_parent_method(par)
class_methods = []
for node in classnode:
if node.type == 'def':
if only_init:
if node.name == '__init__':
class_methods.append(node)
else:
class_methods.append(node)
class_vars = []
self_vars = []
for method_node in class_methods:
self_var = method_node.arguments[0].dumps()
self_vars.append(self_var)
for assign in method_node.find_all('assignment'):
if assign.target.dumps().startswith(self_var + '.'):
class_vars.append(assign.target.value[1].dumps())
static_attrs = ut.unique(class_vars)
return static_attrs
if False:
self_var = self_vars[0]
complex_cases = []
simple_cases = []
all_self_ref = classnode.find_all(
'name_', value=re.compile('.*' + self_var + '\\.*'))
for x in all_self_ref:
if x.parent.type == 'def_argument':
continue
if x.parent.type == 'atomtrailers':
atom = x.parent
if ut.depth(atom.fst()) <= 3:
simple_cases.append(atom)
else:
complex_cases.append(atom)
accessed_attrs = []
for x in simple_cases:
if x.value[0].dumps() == self_var:
attr = x.value[1].dumps()
accessed_attrs.append(attr)
accessed_attrs = ut.unique(accessed_attrs)
ut.setdiff(accessed_attrs, class_vars) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_funcnames_from_modpath; 3, parameters; 3, 4; 3, 5; 4, identifier:modpath; 5, default_parameter; 5, 6; 5, 7; 6, identifier:include_methods; 7, True; 8, block; 8, 9; 8, 14; 8, 165; 9, import_statement; 9, 10; 10, aliased_import; 10, 11; 10, 13; 11, dotted_name; 11, 12; 12, identifier:utool; 13, identifier:ut; 14, if_statement; 14, 15; 14, 16; 14, 114; 15, True; 16, block; 16, 17; 16, 20; 16, 29; 16, 38; 16, 54; 17, import_statement; 17, 18; 18, dotted_name; 18, 19; 19, identifier:jedi; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:source; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:ut; 26, identifier:read_from; 27, argument_list; 27, 28; 28, identifier:modpath; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:definition_list; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:jedi; 35, identifier:names; 36, argument_list; 36, 37; 37, identifier:source; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:funcname_list; 41, list_comprehension; 41, 42; 41, 45; 41, 48; 42, attribute; 42, 43; 42, 44; 43, identifier:definition; 44, identifier:name; 45, for_in_clause; 45, 46; 45, 47; 46, identifier:definition; 47, identifier:definition_list; 48, if_clause; 48, 49; 49, comparison_operator:==; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:definition; 52, identifier:type; 53, string:'function'; 54, if_statement; 54, 55; 54, 56; 55, identifier:include_methods; 56, block; 56, 57; 56, 71; 56, 88; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:classdef_list; 60, list_comprehension; 60, 61; 60, 62; 60, 65; 61, identifier:definition; 62, for_in_clause; 62, 63; 62, 64; 63, identifier:definition; 64, identifier:definition_list; 65, if_clause; 65, 66; 66, comparison_operator:==; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:definition; 69, identifier:type; 70, string:'class'; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:defined_methods; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:ut; 77, identifier:flatten; 78, argument_list; 78, 79; 79, list_comprehension; 79, 80; 79, 85; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:definition; 83, identifier:defined_names; 84, argument_list; 85, for_in_clause; 85, 86; 85, 87; 86, identifier:definition; 87, identifier:classdef_list; 88, expression_statement; 88, 89; 89, augmented_assignment:+=; 89, 90; 89, 91; 90, identifier:funcname_list; 91, list_comprehension; 91, 92; 91, 95; 91, 98; 92, attribute; 92, 93; 92, 94; 93, identifier:method; 94, identifier:name; 95, for_in_clause; 95, 96; 95, 97; 96, identifier:method; 97, identifier:defined_methods; 98, if_clause; 98, 99; 99, boolean_operator:and; 99, 100; 99, 105; 100, comparison_operator:==; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:method; 103, identifier:type; 104, string:'function'; 105, not_operator; 105, 106; 106, call; 106, 107; 106, 112; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:method; 110, identifier:name; 111, identifier:startswith; 112, argument_list; 112, 113; 113, string:'_'; 114, else_clause; 114, 115; 115, block; 115, 116; 115, 119; 115, 128; 115, 137; 116, import_statement; 116, 117; 117, dotted_name; 117, 118; 118, identifier:redbaron; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:sourcecode; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:ut; 125, identifier:read_from; 126, argument_list; 126, 127; 127, identifier:modpath; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:baron; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:redbaron; 134, identifier:RedBaron; 135, argument_list; 135, 136; 136, identifier:sourcecode; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:funcname_list; 140, list_comprehension; 140, 141; 140, 144; 140, 155; 141, attribute; 141, 142; 141, 143; 142, identifier:node; 143, identifier:name; 144, for_in_clause; 144, 145; 144, 146; 145, identifier:node; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:baron; 149, identifier:find_all; 150, argument_list; 150, 151; 150, 152; 151, string:'def'; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:recursive; 154, identifier:include_methods; 155, if_clause; 155, 156; 156, not_operator; 156, 157; 157, call; 157, 158; 157, 163; 158, attribute; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:node; 161, identifier:name; 162, identifier:startswith; 163, argument_list; 163, 164; 164, string:'_'; 165, return_statement; 165, 166; 166, identifier:funcname_list | def get_funcnames_from_modpath(modpath, include_methods=True):
import utool as ut
if True:
import jedi
source = ut.read_from(modpath)
definition_list = jedi.names(source)
funcname_list = [definition.name for definition in definition_list if definition.type == 'function']
if include_methods:
classdef_list = [definition for definition in definition_list if definition.type == 'class']
defined_methods = ut.flatten([definition.defined_names() for definition in classdef_list])
funcname_list += [method.name for method in defined_methods
if method.type == 'function' and not method.name.startswith('_')]
else:
import redbaron
sourcecode = ut.read_from(modpath)
baron = redbaron.RedBaron(sourcecode)
funcname_list = [node.name for node in baron.find_all('def', recursive=include_methods)
if not node.name.startswith('_')]
return funcname_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:is_defined_by_module; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:item; 5, identifier:module; 6, default_parameter; 6, 7; 6, 8; 7, identifier:parent; 8, None; 9, block; 9, 10; 9, 14; 9, 274; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:flag; 13, False; 14, if_statement; 14, 15; 14, 22; 14, 142; 14, 166; 15, call; 15, 16; 15, 17; 16, identifier:isinstance; 17, argument_list; 17, 18; 17, 19; 18, identifier:item; 19, attribute; 19, 20; 19, 21; 20, identifier:types; 21, identifier:ModuleType; 22, block; 22, 23; 23, if_statement; 23, 24; 23, 30; 23, 64; 24, not_operator; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:hasattr; 27, argument_list; 27, 28; 27, 29; 28, identifier:item; 29, string:'__file__'; 30, block; 30, 31; 31, try_statement; 31, 32; 31, 58; 32, block; 32, 33; 32, 38; 32, 49; 33, import_statement; 33, 34; 34, aliased_import; 34, 35; 34, 37; 35, dotted_name; 35, 36; 36, identifier:utool; 37, identifier:ut; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:name; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:ut; 44, identifier:get_modname_from_modpath; 45, argument_list; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:module; 48, identifier:__file__; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:flag; 52, comparison_operator:in; 52, 53; 52, 54; 53, identifier:name; 54, call; 54, 55; 54, 56; 55, identifier:str; 56, argument_list; 56, 57; 57, identifier:item; 58, except_clause; 58, 59; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:flag; 63, False; 64, else_clause; 64, 65; 65, block; 65, 66; 65, 82; 65, 94; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:item_modpath; 69, call; 69, 70; 69, 75; 70, attribute; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:os; 73, identifier:path; 74, identifier:realpath; 75, argument_list; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:dirname; 78, argument_list; 78, 79; 79, attribute; 79, 80; 79, 81; 80, identifier:item; 81, identifier:__file__; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:mod_fpath; 85, call; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:module; 89, identifier:__file__; 90, identifier:replace; 91, argument_list; 91, 92; 91, 93; 92, string:'.pyc'; 93, string:'.py'; 94, if_statement; 94, 95; 94, 102; 94, 107; 95, not_operator; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:mod_fpath; 99, identifier:endswith; 100, argument_list; 100, 101; 101, string:'__init__.py'; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:flag; 106, False; 107, else_clause; 107, 108; 108, block; 108, 109; 108, 123; 108, 133; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:modpath; 112, call; 112, 113; 112, 118; 113, attribute; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:os; 116, identifier:path; 117, identifier:realpath; 118, argument_list; 118, 119; 119, call; 119, 120; 119, 121; 120, identifier:dirname; 121, argument_list; 121, 122; 122, identifier:mod_fpath; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:modpath; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:modpath; 129, identifier:replace; 130, argument_list; 130, 131; 130, 132; 131, string:'.pyc'; 132, string:'.py'; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:flag; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:item_modpath; 139, identifier:startswith; 140, argument_list; 140, 141; 141, identifier:modpath; 142, elif_clause; 142, 143; 142, 148; 143, call; 143, 144; 143, 145; 144, identifier:hasattr; 145, argument_list; 145, 146; 145, 147; 146, identifier:item; 147, string:'_utinfo'; 148, block; 148, 149; 148, 157; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:orig_func; 152, subscript; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:item; 155, identifier:_utinfo; 156, string:'orig_func'; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:flag; 160, call; 160, 161; 160, 162; 161, identifier:is_defined_by_module; 162, argument_list; 162, 163; 162, 164; 162, 165; 163, identifier:orig_func; 164, identifier:module; 165, identifier:parent; 166, else_clause; 166, 167; 167, block; 167, 168; 167, 181; 168, if_statement; 168, 169; 168, 174; 169, call; 169, 170; 169, 171; 170, identifier:isinstance; 171, argument_list; 171, 172; 171, 173; 172, identifier:item; 173, identifier:staticmethod; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:item; 178, attribute; 178, 179; 178, 180; 179, identifier:item; 180, identifier:__func__; 181, try_statement; 181, 182; 181, 254; 182, block; 182, 183; 182, 192; 182, 198; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:func_globals; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:meta_util_six; 189, identifier:get_funcglobals; 190, argument_list; 190, 191; 191, identifier:item; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:func_module_name; 195, subscript; 195, 196; 195, 197; 196, identifier:func_globals; 197, string:'__name__'; 198, if_statement; 198, 199; 198, 202; 198, 243; 199, comparison_operator:==; 199, 200; 199, 201; 200, identifier:func_module_name; 201, string:'line_profiler'; 202, block; 202, 203; 202, 210; 202, 222; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:valid_names; 206, call; 206, 207; 206, 208; 207, identifier:dir; 208, argument_list; 208, 209; 209, identifier:module; 210, if_statement; 210, 211; 210, 214; 211, comparison_operator:is; 211, 212; 211, 213; 212, identifier:parent; 213, None; 214, block; 214, 215; 215, expression_statement; 215, 216; 216, augmented_assignment:+=; 216, 217; 216, 218; 217, identifier:valid_names; 218, call; 218, 219; 218, 220; 219, identifier:dir; 220, argument_list; 220, 221; 221, identifier:parent; 222, if_statement; 222, 223; 222, 228; 223, comparison_operator:in; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:item; 226, identifier:func_name; 227, identifier:valid_names; 228, block; 228, 229; 229, if_statement; 229, 230; 229, 238; 230, comparison_operator:>; 230, 231; 230, 237; 231, call; 231, 232; 231, 233; 232, identifier:len; 233, argument_list; 233, 234; 234, attribute; 234, 235; 234, 236; 235, identifier:item; 236, identifier:func_name; 237, integer:6; 238, block; 238, 239; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:flag; 242, True; 243, elif_clause; 243, 244; 243, 249; 244, comparison_operator:==; 244, 245; 244, 246; 245, identifier:func_module_name; 246, attribute; 246, 247; 246, 248; 247, identifier:module; 248, identifier:__name__; 249, block; 249, 250; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:flag; 253, True; 254, except_clause; 254, 255; 254, 256; 255, identifier:AttributeError; 256, block; 256, 257; 257, if_statement; 257, 258; 257, 263; 258, call; 258, 259; 258, 260; 259, identifier:hasattr; 260, argument_list; 260, 261; 260, 262; 261, identifier:item; 262, string:'__module__'; 263, block; 263, 264; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:flag; 267, comparison_operator:==; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:item; 270, identifier:__module__; 271, attribute; 271, 272; 271, 273; 272, identifier:module; 273, identifier:__name__; 274, return_statement; 274, 275; 275, identifier:flag | def is_defined_by_module(item, module, parent=None):
flag = False
if isinstance(item, types.ModuleType):
if not hasattr(item, '__file__'):
try:
import utool as ut
name = ut.get_modname_from_modpath(module.__file__)
flag = name in str(item)
except:
flag = False
else:
item_modpath = os.path.realpath(dirname(item.__file__))
mod_fpath = module.__file__.replace('.pyc', '.py')
if not mod_fpath.endswith('__init__.py'):
flag = False
else:
modpath = os.path.realpath(dirname(mod_fpath))
modpath = modpath.replace('.pyc', '.py')
flag = item_modpath.startswith(modpath)
elif hasattr(item, '_utinfo'):
orig_func = item._utinfo['orig_func']
flag = is_defined_by_module(orig_func, module, parent)
else:
if isinstance(item, staticmethod):
item = item.__func__
try:
func_globals = meta_util_six.get_funcglobals(item)
func_module_name = func_globals['__name__']
if func_module_name == 'line_profiler':
valid_names = dir(module)
if parent is not None:
valid_names += dir(parent)
if item.func_name in valid_names:
if len(item.func_name) > 6:
flag = True
elif func_module_name == module.__name__:
flag = True
except AttributeError:
if hasattr(item, '__module__'):
flag = item.__module__ == module.__name__
return flag |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:find_funcs_called_with_kwargs; 3, parameters; 3, 4; 3, 5; 4, identifier:sourcecode; 5, default_parameter; 5, 6; 5, 7; 6, identifier:target_kwargs_name; 7, string:'kwargs'; 8, block; 8, 9; 8, 11; 8, 14; 8, 20; 8, 29; 8, 33; 8, 39; 8, 83; 8, 399; 8, 415; 9, expression_statement; 9, 10; 10, identifier:r; 11, import_statement; 11, 12; 12, dotted_name; 12, 13; 13, identifier:ast; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:sourcecode; 17, binary_operator:+; 17, 18; 17, 19; 18, string:'from __future__ import print_function\n'; 19, identifier:sourcecode; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:pt; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:ast; 26, identifier:parse; 27, argument_list; 27, 28; 28, identifier:sourcecode; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:child_funcnamess; 32, list:[]; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:debug; 36, boolean_operator:or; 36, 37; 36, 38; 37, False; 38, identifier:VERYVERB_INSPECT; 39, if_statement; 39, 40; 39, 41; 40, identifier:debug; 41, block; 41, 42; 41, 47; 41, 55; 41, 60; 41, 65; 41, 68; 41, 73; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:print; 45, argument_list; 45, 46; 46, string:'\nInput:'; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:print; 50, argument_list; 50, 51; 51, binary_operator:%; 51, 52; 51, 53; 52, string:'target_kwargs_name = %r'; 53, tuple; 53, 54; 54, identifier:target_kwargs_name; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:print; 58, argument_list; 58, 59; 59, string:'\nSource:'; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:print; 63, argument_list; 63, 64; 64, identifier:sourcecode; 65, import_statement; 65, 66; 66, dotted_name; 66, 67; 67, identifier:astor; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:print; 71, argument_list; 71, 72; 72, string:'\nParse:'; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:print; 76, argument_list; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:astor; 80, identifier:dump; 81, argument_list; 81, 82; 82, identifier:pt; 83, class_definition; 83, 84; 83, 85; 83, 89; 84, identifier:KwargParseVisitor; 85, argument_list; 85, 86; 86, attribute; 86, 87; 86, 88; 87, identifier:ast; 88, identifier:NodeVisitor; 89, block; 89, 90; 89, 174; 90, function_definition; 90, 91; 90, 92; 90, 95; 91, function_name:visit_FunctionDef; 92, parameters; 92, 93; 92, 94; 93, identifier:self; 94, identifier:node; 95, block; 95, 96; 95, 119; 95, 159; 96, if_statement; 96, 97; 96, 98; 97, identifier:debug; 98, block; 98, 99; 98, 107; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:print; 102, argument_list; 102, 103; 103, binary_operator:%; 103, 104; 103, 105; 104, string:'\nVISIT FunctionDef node = %r'; 105, tuple; 105, 106; 106, identifier:node; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:print; 110, argument_list; 110, 111; 111, binary_operator:%; 111, 112; 111, 113; 112, string:'node.args.kwarg = %r'; 113, tuple; 113, 114; 114, attribute; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:node; 117, identifier:args; 118, identifier:kwarg; 119, if_statement; 119, 120; 119, 123; 119, 132; 120, attribute; 120, 121; 120, 122; 121, identifier:six; 122, identifier:PY2; 123, block; 123, 124; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:kwarg_name; 127, attribute; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:node; 130, identifier:args; 131, identifier:kwarg; 132, else_clause; 132, 133; 133, block; 133, 134; 134, if_statement; 134, 135; 134, 142; 134, 147; 135, comparison_operator:is; 135, 136; 135, 141; 136, attribute; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:node; 139, identifier:args; 140, identifier:kwarg; 141, None; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:kwarg_name; 146, None; 147, else_clause; 147, 148; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:kwarg_name; 152, attribute; 152, 153; 152, 158; 153, attribute; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:node; 156, identifier:args; 157, identifier:kwarg; 158, identifier:arg; 159, if_statement; 159, 160; 159, 163; 160, comparison_operator:!=; 160, 161; 160, 162; 161, identifier:kwarg_name; 162, identifier:target_kwargs_name; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 171; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:ast; 169, identifier:NodeVisitor; 170, identifier:generic_visit; 171, argument_list; 171, 172; 171, 173; 172, identifier:self; 173, identifier:node; 174, function_definition; 174, 175; 174, 176; 174, 179; 175, function_name:visit_Call; 176, parameters; 176, 177; 176, 178; 177, identifier:self; 178, identifier:node; 179, block; 179, 180; 179, 191; 179, 260; 179, 389; 180, if_statement; 180, 181; 180, 182; 181, identifier:debug; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 186; 185, identifier:print; 186, argument_list; 186, 187; 187, binary_operator:%; 187, 188; 187, 189; 188, string:'\nVISIT Call node = %r'; 189, tuple; 189, 190; 190, identifier:node; 191, if_statement; 191, 192; 191, 201; 191, 229; 191, 248; 192, call; 192, 193; 192, 194; 193, identifier:isinstance; 194, argument_list; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:node; 197, identifier:func; 198, attribute; 198, 199; 198, 200; 199, identifier:ast; 200, identifier:Attribute; 201, block; 201, 202; 202, try_statement; 202, 203; 202, 222; 203, block; 203, 204; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:funcname; 207, binary_operator:+; 207, 208; 207, 217; 208, binary_operator:+; 208, 209; 208, 216; 209, attribute; 209, 210; 209, 215; 210, attribute; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:node; 213, identifier:func; 214, identifier:value; 215, identifier:id; 216, string:'.'; 217, attribute; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:node; 220, identifier:func; 221, identifier:attr; 222, except_clause; 222, 223; 222, 224; 223, identifier:AttributeError; 224, block; 224, 225; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:funcname; 228, None; 229, elif_clause; 229, 230; 229, 239; 230, call; 230, 231; 230, 232; 231, identifier:isinstance; 232, argument_list; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:node; 235, identifier:func; 236, attribute; 236, 237; 236, 238; 237, identifier:ast; 238, identifier:Name; 239, block; 239, 240; 240, expression_statement; 240, 241; 241, assignment; 241, 242; 241, 243; 242, identifier:funcname; 243, attribute; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:node; 246, identifier:func; 247, identifier:id; 248, else_clause; 248, 249; 249, block; 249, 250; 250, raise_statement; 250, 251; 251, call; 251, 252; 251, 253; 252, identifier:NotImplementedError; 253, argument_list; 253, 254; 254, binary_operator:%; 254, 255; 254, 256; 255, string:'do not know how to parse: node.func = %r'; 256, tuple; 256, 257; 257, attribute; 257, 258; 257, 259; 258, identifier:node; 259, identifier:func; 260, if_statement; 260, 261; 260, 264; 260, 317; 261, attribute; 261, 262; 261, 263; 262, identifier:six; 263, identifier:PY2; 264, block; 264, 265; 264, 271; 264, 282; 264, 298; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:kwargs; 268, attribute; 268, 269; 268, 270; 269, identifier:node; 270, identifier:kwargs; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:kwargs_name; 274, conditional_expression:if; 274, 275; 274, 276; 274, 279; 275, None; 276, comparison_operator:is; 276, 277; 276, 278; 277, identifier:kwargs; 278, None; 279, attribute; 279, 280; 279, 281; 280, identifier:kwargs; 281, identifier:id; 282, if_statement; 282, 283; 282, 290; 283, boolean_operator:and; 283, 284; 283, 287; 284, comparison_operator:is; 284, 285; 284, 286; 285, identifier:funcname; 286, None; 287, comparison_operator:==; 287, 288; 287, 289; 288, identifier:kwargs_name; 289, identifier:target_kwargs_name; 290, block; 290, 291; 291, expression_statement; 291, 292; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:child_funcnamess; 295, identifier:append; 296, argument_list; 296, 297; 297, identifier:funcname; 298, if_statement; 298, 299; 298, 300; 299, identifier:debug; 300, block; 300, 301; 300, 309; 301, expression_statement; 301, 302; 302, call; 302, 303; 302, 304; 303, identifier:print; 304, argument_list; 304, 305; 305, binary_operator:%; 305, 306; 305, 307; 306, string:'funcname = %r'; 307, tuple; 307, 308; 308, identifier:funcname; 309, expression_statement; 309, 310; 310, call; 310, 311; 310, 312; 311, identifier:print; 312, argument_list; 312, 313; 313, binary_operator:%; 313, 314; 313, 315; 314, string:'kwargs_name = %r'; 315, tuple; 315, 316; 316, identifier:kwargs_name; 317, else_clause; 317, 318; 318, block; 318, 319; 319, if_statement; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:node; 322, identifier:keywords; 323, block; 323, 324; 324, for_statement; 324, 325; 324, 326; 324, 329; 325, identifier:kwargs; 326, attribute; 326, 327; 326, 328; 327, identifier:node; 328, identifier:keywords; 329, block; 329, 330; 330, if_statement; 330, 331; 330, 336; 331, comparison_operator:is; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:kwargs; 334, identifier:arg; 335, None; 336, block; 336, 337; 337, if_statement; 337, 338; 337, 345; 338, call; 338, 339; 338, 340; 339, identifier:hasattr; 340, argument_list; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:kwargs; 343, identifier:value; 344, string:'id'; 345, block; 345, 346; 345, 354; 345, 370; 346, expression_statement; 346, 347; 347, assignment; 347, 348; 347, 349; 348, identifier:kwargs_name; 349, attribute; 349, 350; 349, 353; 350, attribute; 350, 351; 350, 352; 351, identifier:kwargs; 352, identifier:value; 353, identifier:id; 354, if_statement; 354, 355; 354, 362; 355, boolean_operator:and; 355, 356; 355, 359; 356, comparison_operator:is; 356, 357; 356, 358; 357, identifier:funcname; 358, None; 359, comparison_operator:==; 359, 360; 359, 361; 360, identifier:kwargs_name; 361, identifier:target_kwargs_name; 362, block; 362, 363; 363, expression_statement; 363, 364; 364, call; 364, 365; 364, 368; 365, attribute; 365, 366; 365, 367; 366, identifier:child_funcnamess; 367, identifier:append; 368, argument_list; 368, 369; 369, identifier:funcname; 370, if_statement; 370, 371; 370, 372; 371, identifier:debug; 372, block; 372, 373; 372, 381; 373, expression_statement; 373, 374; 374, call; 374, 375; 374, 376; 375, identifier:print; 376, argument_list; 376, 377; 377, binary_operator:%; 377, 378; 377, 379; 378, string:'funcname = %r'; 379, tuple; 379, 380; 380, identifier:funcname; 381, expression_statement; 381, 382; 382, call; 382, 383; 382, 384; 383, identifier:print; 384, argument_list; 384, 385; 385, binary_operator:%; 385, 386; 385, 387; 386, string:'kwargs_name = %r'; 387, tuple; 387, 388; 388, identifier:kwargs_name; 389, expression_statement; 389, 390; 390, call; 390, 391; 390, 396; 391, attribute; 391, 392; 391, 395; 392, attribute; 392, 393; 392, 394; 393, identifier:ast; 394, identifier:NodeVisitor; 395, identifier:generic_visit; 396, argument_list; 396, 397; 396, 398; 397, identifier:self; 398, identifier:node; 399, try_statement; 399, 400; 399, 410; 400, block; 400, 401; 401, expression_statement; 401, 402; 402, call; 402, 403; 402, 408; 403, attribute; 403, 404; 403, 407; 404, call; 404, 405; 404, 406; 405, identifier:KwargParseVisitor; 406, argument_list; 407, identifier:visit; 408, argument_list; 408, 409; 409, identifier:pt; 410, except_clause; 410, 411; 410, 412; 411, identifier:Exception; 412, block; 412, 413; 412, 414; 413, raise_statement; 414, pass_statement; 415, return_statement; 415, 416; 416, identifier:child_funcnamess | def find_funcs_called_with_kwargs(sourcecode, target_kwargs_name='kwargs'):
r
import ast
sourcecode = 'from __future__ import print_function\n' + sourcecode
pt = ast.parse(sourcecode)
child_funcnamess = []
debug = False or VERYVERB_INSPECT
if debug:
print('\nInput:')
print('target_kwargs_name = %r' % (target_kwargs_name,))
print('\nSource:')
print(sourcecode)
import astor
print('\nParse:')
print(astor.dump(pt))
class KwargParseVisitor(ast.NodeVisitor):
def visit_FunctionDef(self, node):
if debug:
print('\nVISIT FunctionDef node = %r' % (node,))
print('node.args.kwarg = %r' % (node.args.kwarg,))
if six.PY2:
kwarg_name = node.args.kwarg
else:
if node.args.kwarg is None:
kwarg_name = None
else:
kwarg_name = node.args.kwarg.arg
if kwarg_name != target_kwargs_name:
ast.NodeVisitor.generic_visit(self, node)
def visit_Call(self, node):
if debug:
print('\nVISIT Call node = %r' % (node,))
if isinstance(node.func, ast.Attribute):
try:
funcname = node.func.value.id + '.' + node.func.attr
except AttributeError:
funcname = None
elif isinstance(node.func, ast.Name):
funcname = node.func.id
else:
raise NotImplementedError(
'do not know how to parse: node.func = %r' % (node.func,))
if six.PY2:
kwargs = node.kwargs
kwargs_name = None if kwargs is None else kwargs.id
if funcname is not None and kwargs_name == target_kwargs_name:
child_funcnamess.append(funcname)
if debug:
print('funcname = %r' % (funcname,))
print('kwargs_name = %r' % (kwargs_name,))
else:
if node.keywords:
for kwargs in node.keywords:
if kwargs.arg is None:
if hasattr(kwargs.value, 'id'):
kwargs_name = kwargs.value.id
if funcname is not None and kwargs_name == target_kwargs_name:
child_funcnamess.append(funcname)
if debug:
print('funcname = %r' % (funcname,))
print('kwargs_name = %r' % (kwargs_name,))
ast.NodeVisitor.generic_visit(self, node)
try:
KwargParseVisitor().visit(pt)
except Exception:
raise
pass
return child_funcnamess |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_qt_set_leaf_data; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:qvar; 6, block; 6, 7; 6, 76; 6, 90; 6, 471; 7, if_statement; 7, 8; 7, 9; 8, identifier:VERBOSE_PREF; 9, block; 9, 10; 9, 15; 9, 20; 9, 27; 9, 38; 9, 51; 9, 65; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 13; 12, identifier:print; 13, argument_list; 13, 14; 14, string:''; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:print; 18, argument_list; 18, 19; 19, string:'+--- [pref.qt_set_leaf_data]'; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:print; 23, argument_list; 23, 24; 24, binary_operator:%; 24, 25; 24, 26; 25, string:'[pref.qt_set_leaf_data] qvar = %r'; 26, identifier:qvar; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:print; 30, argument_list; 30, 31; 31, binary_operator:%; 31, 32; 31, 33; 32, string:'[pref.qt_set_leaf_data] _intern.name=%r'; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_intern; 37, identifier:name; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:print; 41, argument_list; 41, 42; 42, binary_operator:%; 42, 43; 42, 44; 43, string:'[pref.qt_set_leaf_data] _intern.type_=%r'; 44, call; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:_intern; 49, identifier:get_type; 50, argument_list; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:print; 54, argument_list; 54, 55; 55, binary_operator:%; 55, 56; 55, 57; 56, string:'[pref.qt_set_leaf_data] type(_intern.value)=%r'; 57, call; 57, 58; 57, 59; 58, identifier:type; 59, argument_list; 59, 60; 60, attribute; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:_intern; 64, identifier:value; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:print; 68, argument_list; 68, 69; 69, binary_operator:%; 69, 70; 69, 71; 70, string:'[pref.qt_set_leaf_data] _intern.value=%r'; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:_intern; 75, identifier:value; 76, if_statement; 76, 77; 76, 84; 77, comparison_operator:is; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:_tree; 82, identifier:parent; 83, None; 84, block; 84, 85; 85, raise_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:Exception; 88, argument_list; 88, 89; 89, string:'[Pref.qtleaf] Cannot set root preference'; 90, if_statement; 90, 91; 90, 96; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:qt_is_editable; 95, argument_list; 96, block; 96, 97; 96, 101; 96, 169; 96, 177; 96, 377; 96, 425; 96, 455; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:new_val; 100, string:'[Pref.qtleaf] BadThingsHappenedInPref'; 101, if_statement; 101, 102; 101, 109; 101, 115; 102, comparison_operator:==; 102, 103; 102, 108; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:_intern; 107, identifier:value; 108, identifier:PrefNode; 109, block; 109, 110; 110, raise_statement; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:Exception; 113, argument_list; 113, 114; 114, string:'[Pref.qtleaf] Qt can only change leafs'; 115, elif_clause; 115, 116; 115, 123; 116, comparison_operator:is; 116, 117; 116, 122; 117, attribute; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:_intern; 121, identifier:value; 122, None; 123, block; 123, 124; 123, 157; 124, function_definition; 124, 125; 124, 126; 124, 137; 125, function_name:cast_order; 126, parameters; 126, 127; 126, 128; 127, identifier:var; 128, default_parameter; 128, 129; 128, 130; 129, identifier:order; 130, list:[bool, int, float, six.text_type]; 130, 131; 130, 132; 130, 133; 130, 134; 131, identifier:bool; 132, identifier:int; 133, identifier:float; 134, attribute; 134, 135; 134, 136; 135, identifier:six; 136, identifier:text_type; 137, block; 137, 138; 138, for_statement; 138, 139; 138, 140; 138, 141; 139, identifier:type_; 140, identifier:order; 141, block; 141, 142; 142, try_statement; 142, 143; 142, 153; 143, block; 143, 144; 143, 151; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:ret; 147, call; 147, 148; 147, 149; 148, identifier:type_; 149, argument_list; 149, 150; 150, identifier:var; 151, return_statement; 151, 152; 152, identifier:ret; 153, except_clause; 153, 154; 153, 155; 154, identifier:Exception; 155, block; 155, 156; 156, continue_statement; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:new_val; 160, call; 160, 161; 160, 162; 161, identifier:cast_order; 162, argument_list; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:six; 166, identifier:text_type; 167, argument_list; 167, 168; 168, identifier:qvar; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 176; 171, attribute; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:_intern; 175, identifier:get_type; 176, argument_list; 177, if_statement; 177, 178; 177, 187; 177, 214; 177, 232; 177, 252; 177, 274; 177, 307; 178, call; 178, 179; 178, 180; 179, identifier:isinstance; 180, argument_list; 180, 181; 180, 186; 181, attribute; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:self; 184, identifier:_intern; 185, identifier:value; 186, identifier:bool; 187, block; 187, 188; 187, 196; 187, 206; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 191; 190, identifier:print; 191, argument_list; 191, 192; 192, binary_operator:%; 192, 193; 192, 194; 193, string:'qvar = %r'; 194, tuple; 194, 195; 195, identifier:qvar; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:new_val; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:util_type; 202, identifier:smart_cast; 203, argument_list; 203, 204; 203, 205; 204, identifier:qvar; 205, identifier:bool; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 209; 208, identifier:print; 209, argument_list; 209, 210; 210, binary_operator:%; 210, 211; 210, 212; 211, string:'new_val = %r'; 212, tuple; 212, 213; 213, identifier:new_val; 214, elif_clause; 214, 215; 214, 224; 215, call; 215, 216; 215, 217; 216, identifier:isinstance; 217, argument_list; 217, 218; 217, 223; 218, attribute; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:self; 221, identifier:_intern; 222, identifier:value; 223, identifier:int; 224, block; 224, 225; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:new_val; 228, call; 228, 229; 228, 230; 229, identifier:int; 230, argument_list; 230, 231; 231, identifier:qvar; 232, elif_clause; 232, 233; 232, 244; 233, comparison_operator:in; 233, 234; 233, 241; 234, call; 234, 235; 234, 240; 235, attribute; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:self; 238, identifier:_intern; 239, identifier:get_type; 240, argument_list; 241, attribute; 241, 242; 241, 243; 242, identifier:util_type; 243, identifier:VALID_FLOAT_TYPES; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:new_val; 248, call; 248, 249; 248, 250; 249, identifier:float; 250, argument_list; 250, 251; 251, identifier:qvar; 252, elif_clause; 252, 253; 252, 264; 253, call; 253, 254; 253, 255; 254, identifier:isinstance; 255, argument_list; 255, 256; 255, 261; 256, attribute; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:self; 259, identifier:_intern; 260, identifier:value; 261, attribute; 261, 262; 261, 263; 262, identifier:six; 263, identifier:string_types; 264, block; 264, 265; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:new_val; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:six; 271, identifier:text_type; 272, argument_list; 272, 273; 273, identifier:qvar; 274, elif_clause; 274, 275; 274, 284; 275, call; 275, 276; 275, 277; 276, identifier:isinstance; 277, argument_list; 277, 278; 277, 283; 278, attribute; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:self; 281, identifier:_intern; 282, identifier:value; 283, identifier:PrefChoice; 284, block; 284, 285; 284, 294; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:new_val; 288, call; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:six; 291, identifier:text_type; 292, argument_list; 292, 293; 293, identifier:qvar; 294, if_statement; 294, 295; 294, 302; 295, comparison_operator:==; 295, 296; 295, 301; 296, call; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:new_val; 299, identifier:upper; 300, argument_list; 301, string:'NONE'; 302, block; 302, 303; 303, expression_statement; 303, 304; 304, assignment; 304, 305; 304, 306; 305, identifier:new_val; 306, None; 307, else_clause; 307, 308; 308, block; 308, 309; 309, try_statement; 309, 310; 309, 349; 310, block; 310, 311; 310, 321; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 314; 313, identifier:type_; 314, call; 314, 315; 314, 320; 315, attribute; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:self; 318, identifier:_intern; 319, identifier:get_type; 320, argument_list; 321, if_statement; 321, 322; 321, 325; 321, 338; 322, comparison_operator:is; 322, 323; 322, 324; 323, identifier:type_; 324, None; 325, block; 325, 326; 326, expression_statement; 326, 327; 327, assignment; 327, 328; 327, 329; 328, identifier:new_val; 329, call; 329, 330; 329, 331; 330, identifier:type_; 331, argument_list; 331, 332; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:six; 335, identifier:text_type; 336, argument_list; 336, 337; 337, identifier:qvar; 338, else_clause; 338, 339; 339, block; 339, 340; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 343; 342, identifier:new_val; 343, call; 343, 344; 343, 347; 344, attribute; 344, 345; 344, 346; 345, identifier:six; 346, identifier:text_type; 347, argument_list; 347, 348; 348, identifier:qvar; 349, except_clause; 349, 350; 349, 351; 350, identifier:Exception; 351, block; 351, 352; 352, raise_statement; 352, 353; 353, call; 353, 354; 353, 355; 354, identifier:NotImplementedError; 355, argument_list; 355, 356; 355, 370; 356, binary_operator:%; 356, 357; 356, 362; 357, parenthesized_expression; 357, 358; 358, concatenated_string; 358, 359; 358, 360; 358, 361; 359, string:'[Pref.qtleaf] Unknown internal type. '; 360, string:'type(_intern.value) = %r, '; 361, string:'_intern.get_type() = %r, '; 362, call; 362, 363; 362, 364; 363, identifier:type; 364, argument_list; 364, 365; 365, attribute; 365, 366; 365, 369; 366, attribute; 366, 367; 366, 368; 367, identifier:self; 368, identifier:_intern; 369, identifier:value; 370, call; 370, 371; 370, 376; 371, attribute; 371, 372; 371, 375; 372, attribute; 372, 373; 372, 374; 373, identifier:self; 374, identifier:_intern; 375, identifier:get_type; 376, argument_list; 377, if_statement; 377, 378; 377, 385; 378, call; 378, 379; 378, 380; 379, identifier:isinstance; 380, argument_list; 380, 381; 380, 382; 381, identifier:new_val; 382, attribute; 382, 383; 382, 384; 383, identifier:six; 384, identifier:string_types; 385, block; 385, 386; 386, if_statement; 386, 387; 386, 394; 386, 399; 386, 412; 387, comparison_operator:==; 387, 388; 387, 393; 388, call; 388, 389; 388, 392; 389, attribute; 389, 390; 389, 391; 390, identifier:new_val; 391, identifier:lower; 392, argument_list; 393, string:'none'; 394, block; 394, 395; 395, expression_statement; 395, 396; 396, assignment; 396, 397; 396, 398; 397, identifier:new_val; 398, None; 399, elif_clause; 399, 400; 399, 407; 400, comparison_operator:==; 400, 401; 400, 406; 401, call; 401, 402; 401, 405; 402, attribute; 402, 403; 402, 404; 403, identifier:new_val; 404, identifier:lower; 405, argument_list; 406, string:'true'; 407, block; 407, 408; 408, expression_statement; 408, 409; 409, assignment; 409, 410; 409, 411; 410, identifier:new_val; 411, True; 412, elif_clause; 412, 413; 412, 420; 413, comparison_operator:==; 413, 414; 413, 419; 414, call; 414, 415; 414, 418; 415, attribute; 415, 416; 415, 417; 416, identifier:new_val; 417, identifier:lower; 418, argument_list; 419, string:'false'; 420, block; 420, 421; 421, expression_statement; 421, 422; 422, assignment; 422, 423; 422, 424; 423, identifier:new_val; 424, False; 425, if_statement; 425, 426; 425, 427; 426, identifier:VERBOSE_PREF; 427, block; 427, 428; 427, 433; 427, 440; 427, 450; 428, expression_statement; 428, 429; 429, call; 429, 430; 429, 431; 430, identifier:print; 431, argument_list; 431, 432; 432, string:'---'; 433, expression_statement; 433, 434; 434, call; 434, 435; 434, 436; 435, identifier:print; 436, argument_list; 436, 437; 437, binary_operator:%; 437, 438; 437, 439; 438, string:'[pref.qt_set_leaf_data] new_val=%r'; 439, identifier:new_val; 440, expression_statement; 440, 441; 441, call; 441, 442; 441, 443; 442, identifier:print; 443, argument_list; 443, 444; 444, binary_operator:%; 444, 445; 444, 446; 445, string:'[pref.qt_set_leaf_data] type(new_val)=%r'; 446, call; 446, 447; 446, 448; 447, identifier:type; 448, argument_list; 448, 449; 449, identifier:new_val; 450, expression_statement; 450, 451; 451, call; 451, 452; 451, 453; 452, identifier:print; 453, argument_list; 453, 454; 454, string:'L____ [pref.qt_set_leaf_data]'; 455, return_statement; 455, 456; 456, call; 456, 457; 456, 464; 457, attribute; 457, 458; 457, 463; 458, attribute; 458, 459; 458, 462; 459, attribute; 459, 460; 459, 461; 460, identifier:self; 461, identifier:_tree; 462, identifier:parent; 463, identifier:pref_update; 464, argument_list; 464, 465; 464, 470; 465, attribute; 465, 466; 465, 469; 466, attribute; 466, 467; 466, 468; 467, identifier:self; 468, identifier:_intern; 469, identifier:name; 470, identifier:new_val; 471, return_statement; 471, 472; 472, string:'PrefNotEditable' | def _qt_set_leaf_data(self, qvar):
if VERBOSE_PREF:
print('')
print('+--- [pref.qt_set_leaf_data]')
print('[pref.qt_set_leaf_data] qvar = %r' % qvar)
print('[pref.qt_set_leaf_data] _intern.name=%r' % self._intern.name)
print('[pref.qt_set_leaf_data] _intern.type_=%r' % self._intern.get_type())
print('[pref.qt_set_leaf_data] type(_intern.value)=%r' % type(self._intern.value))
print('[pref.qt_set_leaf_data] _intern.value=%r' % self._intern.value)
if self._tree.parent is None:
raise Exception('[Pref.qtleaf] Cannot set root preference')
if self.qt_is_editable():
new_val = '[Pref.qtleaf] BadThingsHappenedInPref'
if self._intern.value == PrefNode:
raise Exception('[Pref.qtleaf] Qt can only change leafs')
elif self._intern.value is None:
def cast_order(var, order=[bool, int, float, six.text_type]):
for type_ in order:
try:
ret = type_(var)
return ret
except Exception:
continue
new_val = cast_order(six.text_type(qvar))
self._intern.get_type()
if isinstance(self._intern.value, bool):
print('qvar = %r' % (qvar,))
new_val = util_type.smart_cast(qvar, bool)
print('new_val = %r' % (new_val,))
elif isinstance(self._intern.value, int):
new_val = int(qvar)
elif self._intern.get_type() in util_type.VALID_FLOAT_TYPES:
new_val = float(qvar)
elif isinstance(self._intern.value, six.string_types):
new_val = six.text_type(qvar)
elif isinstance(self._intern.value, PrefChoice):
new_val = six.text_type(qvar)
if new_val.upper() == 'NONE':
new_val = None
else:
try:
type_ = self._intern.get_type()
if type_ is not None:
new_val = type_(six.text_type(qvar))
else:
new_val = six.text_type(qvar)
except Exception:
raise NotImplementedError(
('[Pref.qtleaf] Unknown internal type. '
'type(_intern.value) = %r, '
'_intern.get_type() = %r, ')
% type(self._intern.value), self._intern.get_type())
if isinstance(new_val, six.string_types):
if new_val.lower() == 'none':
new_val = None
elif new_val.lower() == 'true':
new_val = True
elif new_val.lower() == 'false':
new_val = False
if VERBOSE_PREF:
print('---')
print('[pref.qt_set_leaf_data] new_val=%r' % new_val)
print('[pref.qt_set_leaf_data] type(new_val)=%r' % type(new_val))
print('L____ [pref.qt_set_leaf_data]')
return self._tree.parent.pref_update(self._intern.name, new_val)
return 'PrefNotEditable' |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:inject_all_external_modules; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:classname; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:allow_override; 10, string:'override+warn'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:strict; 13, True; 14, block; 14, 15; 14, 28; 14, 32; 14, 68; 14, 86; 15, if_statement; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:classname; 18, None; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:classname; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:__class__; 27, identifier:__name__; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:NEW; 31, True; 32, if_statement; 32, 33; 32, 34; 32, 49; 33, identifier:NEW; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:classkey_list; 38, list_comprehension; 38, 39; 38, 40; 38, 43; 39, identifier:key; 40, for_in_clause; 40, 41; 40, 42; 41, identifier:key; 42, identifier:__CLASSTYPE_ATTRIBUTES__; 43, if_clause; 43, 44; 44, comparison_operator:==; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:key; 47, integer:0; 48, identifier:classname; 49, else_clause; 49, 50; 50, block; 50, 51; 50, 58; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:injected_modules; 54, call; 54, 55; 54, 56; 55, identifier:get_injected_modules; 56, argument_list; 56, 57; 57, identifier:classname; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:classkey_list; 61, list_comprehension; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:module; 64, identifier:CLASS_INJECT_KEY; 65, for_in_clause; 65, 66; 65, 67; 66, identifier:module; 67, identifier:injected_modules; 68, for_statement; 68, 69; 68, 70; 68, 71; 69, identifier:classkey; 70, identifier:classkey_list; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:inject_instance; 75, argument_list; 75, 76; 75, 77; 75, 80; 75, 83; 76, identifier:self; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:classkey; 79, identifier:classkey; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:allow_override; 82, identifier:allow_override; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:strict; 85, False; 86, for_statement; 86, 87; 86, 88; 86, 89; 87, identifier:classkey; 88, identifier:classkey_list; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:postinject_instance; 93, argument_list; 93, 94; 93, 95; 94, identifier:self; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:classkey; 97, identifier:classkey | def inject_all_external_modules(self, classname=None,
allow_override='override+warn',
strict=True):
if classname is None:
classname = self.__class__.__name__
NEW = True
if NEW:
classkey_list = [key for key in __CLASSTYPE_ATTRIBUTES__
if key[0] == classname]
else:
injected_modules = get_injected_modules(classname)
classkey_list = [module.CLASS_INJECT_KEY
for module in injected_modules]
for classkey in classkey_list:
inject_instance(
self, classkey=classkey,
allow_override=allow_override, strict=False)
for classkey in classkey_list:
postinject_instance(
self, classkey=classkey) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 27; 2, function_name:inject_func_as_method; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 4, identifier:self; 5, identifier:func; 6, default_parameter; 6, 7; 6, 8; 7, identifier:method_name; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:class_; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:allow_override; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:allow_main; 17, False; 18, default_parameter; 18, 19; 18, 20; 19, identifier:verbose; 20, True; 21, default_parameter; 21, 22; 21, 23; 22, identifier:override; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:force; 26, False; 27, block; 27, 28; 27, 37; 27, 49; 27, 60; 27, 69; 27, 81; 27, 236; 28, if_statement; 28, 29; 28, 32; 29, comparison_operator:is; 29, 30; 29, 31; 30, identifier:override; 31, None; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:allow_override; 36, identifier:override; 37, if_statement; 37, 38; 37, 41; 38, comparison_operator:is; 38, 39; 38, 40; 39, identifier:method_name; 40, None; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:method_name; 45, call; 45, 46; 45, 47; 46, identifier:get_funcname; 47, argument_list; 47, 48; 48, identifier:func; 49, if_statement; 49, 50; 49, 51; 50, identifier:force; 51, block; 51, 52; 51, 56; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:allow_override; 55, True; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:allow_main; 59, True; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:old_method; 63, call; 63, 64; 63, 65; 64, identifier:getattr; 65, argument_list; 65, 66; 65, 67; 65, 68; 66, identifier:self; 67, identifier:method_name; 68, None; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:new_method; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:func; 75, identifier:__get__; 76, argument_list; 76, 77; 76, 78; 77, identifier:self; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:__class__; 81, if_statement; 81, 82; 81, 85; 82, comparison_operator:is; 82, 83; 82, 84; 83, identifier:old_method; 84, None; 85, block; 85, 86; 85, 93; 85, 100; 85, 140; 85, 234; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:old_im_func; 89, call; 89, 90; 89, 91; 90, identifier:get_method_func; 91, argument_list; 91, 92; 92, identifier:old_method; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:new_im_func; 96, call; 96, 97; 96, 98; 97, identifier:get_method_func; 98, argument_list; 98, 99; 99, identifier:new_method; 100, if_statement; 100, 101; 100, 126; 101, boolean_operator:and; 101, 102; 101, 108; 102, boolean_operator:and; 102, 103; 102, 105; 103, not_operator; 103, 104; 104, identifier:allow_main; 105, comparison_operator:is; 105, 106; 105, 107; 106, identifier:old_im_func; 107, None; 108, parenthesized_expression; 108, 109; 109, boolean_operator:and; 109, 110; 109, 118; 110, comparison_operator:!=; 110, 111; 110, 117; 111, subscript; 111, 112; 111, 116; 112, call; 112, 113; 112, 114; 113, identifier:get_funcglobals; 114, argument_list; 114, 115; 115, identifier:old_im_func; 116, string:'__name__'; 117, string:'__main__'; 118, comparison_operator:==; 118, 119; 118, 125; 119, subscript; 119, 120; 119, 124; 120, call; 120, 121; 120, 122; 121, identifier:get_funcglobals; 122, argument_list; 122, 123; 123, identifier:new_im_func; 124, string:'__name__'; 125, string:'__main__'; 126, block; 126, 127; 126, 139; 127, if_statement; 127, 128; 127, 131; 128, boolean_operator:or; 128, 129; 128, 130; 129, True; 130, identifier:VERBOSE_CLASS; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 135; 134, identifier:print; 135, argument_list; 135, 136; 136, binary_operator:%; 136, 137; 136, 138; 137, string:'[util_class] skipping re-inject of %r from __main__'; 138, identifier:method_name; 139, return_statement; 140, if_statement; 140, 141; 140, 148; 140, 150; 140, 163; 140, 177; 141, boolean_operator:or; 141, 142; 141, 145; 142, comparison_operator:is; 142, 143; 142, 144; 143, identifier:old_method; 144, identifier:new_method; 145, comparison_operator:is; 145, 146; 145, 147; 146, identifier:old_im_func; 147, identifier:new_im_func; 148, block; 148, 149; 149, return_statement; 150, elif_clause; 150, 151; 150, 154; 151, comparison_operator:is; 151, 152; 151, 153; 152, identifier:allow_override; 153, False; 154, block; 154, 155; 155, raise_statement; 155, 156; 156, call; 156, 157; 156, 158; 157, identifier:AssertionError; 158, argument_list; 158, 159; 159, binary_operator:%; 159, 160; 159, 161; 160, string:'Overrides are not allowed. Already have method_name=%r'; 161, parenthesized_expression; 161, 162; 162, identifier:method_name; 163, elif_clause; 163, 164; 163, 167; 164, comparison_operator:==; 164, 165; 164, 166; 165, identifier:allow_override; 166, string:'warn'; 167, block; 167, 168; 167, 176; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:print; 171, argument_list; 171, 172; 172, binary_operator:%; 172, 173; 172, 174; 173, string:'WARNING: Overrides are not allowed. Already have method_name=%r. Skipping'; 174, parenthesized_expression; 174, 175; 175, identifier:method_name; 176, return_statement; 177, elif_clause; 177, 178; 177, 181; 178, comparison_operator:==; 178, 179; 178, 180; 179, identifier:allow_override; 180, string:'override+warn'; 181, block; 181, 182; 181, 190; 181, 202; 181, 214; 181, 224; 182, expression_statement; 182, 183; 183, call; 183, 184; 183, 185; 184, identifier:print; 185, argument_list; 185, 186; 186, binary_operator:%; 186, 187; 186, 188; 187, string:'WARNING: Overrides are allowed, but dangerous. method_name=%r.'; 188, parenthesized_expression; 188, 189; 189, identifier:method_name; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 193; 192, identifier:print; 193, argument_list; 193, 194; 194, binary_operator:%; 194, 195; 194, 196; 195, string:'old_method = %r, im_func=%s'; 196, tuple; 196, 197; 196, 198; 197, identifier:old_method; 198, call; 198, 199; 198, 200; 199, identifier:str; 200, argument_list; 200, 201; 201, identifier:old_im_func; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 205; 204, identifier:print; 205, argument_list; 205, 206; 206, binary_operator:%; 206, 207; 206, 208; 207, string:'new_method = %r, im_func=%s'; 208, tuple; 208, 209; 208, 210; 209, identifier:new_method; 210, call; 210, 211; 210, 212; 211, identifier:str; 212, argument_list; 212, 213; 213, identifier:new_im_func; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 217; 216, identifier:print; 217, argument_list; 217, 218; 218, subscript; 218, 219; 218, 223; 219, call; 219, 220; 219, 221; 220, identifier:get_funcglobals; 221, argument_list; 221, 222; 222, identifier:old_im_func; 223, string:'__name__'; 224, expression_statement; 224, 225; 225, call; 225, 226; 225, 227; 226, identifier:print; 227, argument_list; 227, 228; 228, subscript; 228, 229; 228, 233; 229, call; 229, 230; 229, 231; 230, identifier:get_funcglobals; 231, argument_list; 231, 232; 232, identifier:new_im_func; 233, string:'__name__'; 234, delete_statement; 234, 235; 235, identifier:old_method; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 239; 238, identifier:setattr; 239, argument_list; 239, 240; 239, 241; 239, 242; 240, identifier:self; 241, identifier:method_name; 242, identifier:new_method | def inject_func_as_method(self, func, method_name=None, class_=None,
allow_override=False, allow_main=False,
verbose=True, override=None, force=False):
if override is not None:
allow_override = override
if method_name is None:
method_name = get_funcname(func)
if force:
allow_override = True
allow_main = True
old_method = getattr(self, method_name, None)
new_method = func.__get__(self, self.__class__)
if old_method is not None:
old_im_func = get_method_func(old_method)
new_im_func = get_method_func(new_method)
if not allow_main and old_im_func is not None and (
get_funcglobals(old_im_func)['__name__'] != '__main__' and
get_funcglobals(new_im_func)['__name__'] == '__main__'):
if True or VERBOSE_CLASS:
print('[util_class] skipping re-inject of %r from __main__' % method_name)
return
if old_method is new_method or old_im_func is new_im_func:
return
elif allow_override is False:
raise AssertionError(
'Overrides are not allowed. Already have method_name=%r' %
(method_name))
elif allow_override == 'warn':
print(
'WARNING: Overrides are not allowed. Already have method_name=%r. Skipping' %
(method_name))
return
elif allow_override == 'override+warn':
print('WARNING: Overrides are allowed, but dangerous. method_name=%r.' %
(method_name))
print('old_method = %r, im_func=%s' % (old_method, str(old_im_func)))
print('new_method = %r, im_func=%s' % (new_method, str(new_im_func)))
print(get_funcglobals(old_im_func)['__name__'])
print(get_funcglobals(new_im_func)['__name__'])
del old_method
setattr(self, method_name, new_method) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:reload_class; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:verbose; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reload_module; 10, True; 11, block; 11, 12; 11, 17; 11, 23; 11, 31; 12, import_statement; 12, 13; 13, aliased_import; 13, 14; 13, 16; 14, dotted_name; 14, 15; 15, identifier:utool; 16, identifier:ut; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:verbose; 20, boolean_operator:or; 20, 21; 20, 22; 21, identifier:verbose; 22, identifier:VERBOSE_CLASS; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:classname; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:__class__; 30, identifier:__name__; 31, try_statement; 31, 32; 31, 378; 32, block; 32, 33; 32, 41; 32, 55; 32, 94; 32, 141; 32, 147; 32, 155; 32, 160; 32, 172; 32, 339; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:modname; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:__class__; 40, identifier:__module__; 41, if_statement; 41, 42; 41, 43; 42, identifier:verbose; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:print; 47, argument_list; 47, 48; 48, binary_operator:+; 48, 49; 48, 54; 49, binary_operator:+; 49, 50; 49, 53; 50, binary_operator:+; 50, 51; 50, 52; 51, string:'[class] reloading '; 52, identifier:classname; 53, string:' from '; 54, identifier:modname; 55, if_statement; 55, 56; 55, 61; 55, 80; 56, call; 56, 57; 56, 58; 57, identifier:hasattr; 58, argument_list; 58, 59; 58, 60; 59, identifier:self; 60, string:'_on_reload'; 61, block; 61, 62; 61, 74; 62, if_statement; 62, 63; 62, 66; 63, comparison_operator:>; 63, 64; 63, 65; 64, identifier:verbose; 65, integer:1; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:print; 70, argument_list; 70, 71; 71, binary_operator:+; 71, 72; 71, 73; 72, string:'[class] calling _on_reload for '; 73, identifier:classname; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:_on_reload; 79, argument_list; 80, elif_clause; 80, 81; 80, 84; 81, comparison_operator:>; 81, 82; 81, 83; 82, identifier:verbose; 83, integer:1; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:print; 88, argument_list; 88, 89; 89, binary_operator:+; 89, 90; 89, 93; 90, binary_operator:+; 90, 91; 90, 92; 91, string:'[class] '; 92, identifier:classname; 93, string:' does not have an _on_reload function'; 94, function_definition; 94, 95; 94, 96; 94, 101; 95, function_name:find_base_clases; 96, parameters; 96, 97; 96, 98; 97, identifier:_class; 98, default_parameter; 98, 99; 98, 100; 99, identifier:find_base_clases; 100, None; 101, block; 101, 102; 101, 106; 101, 127; 101, 139; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:class_list; 105, list:[]; 106, for_statement; 106, 107; 106, 108; 106, 111; 107, identifier:_baseclass; 108, attribute; 108, 109; 108, 110; 109, identifier:_class; 110, identifier:__bases__; 111, block; 111, 112; 111, 120; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:parents; 115, call; 115, 116; 115, 117; 116, identifier:find_base_clases; 117, argument_list; 117, 118; 117, 119; 118, identifier:_baseclass; 119, identifier:find_base_clases; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:class_list; 124, identifier:extend; 125, argument_list; 125, 126; 126, identifier:parents; 127, if_statement; 127, 128; 127, 131; 128, comparison_operator:is; 128, 129; 128, 130; 129, identifier:_class; 130, identifier:object; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:class_list; 136, identifier:append; 137, argument_list; 137, 138; 138, identifier:_class; 139, return_statement; 139, 140; 140, identifier:class_list; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:head_class; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:__class__; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:class_list; 150, call; 150, 151; 150, 152; 151, identifier:find_base_clases; 152, argument_list; 152, 153; 152, 154; 153, identifier:head_class; 154, identifier:find_base_clases; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:ignore; 158, set; 158, 159; 159, identifier:HashComparable2; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:class_list; 163, list_comprehension; 163, 164; 163, 165; 163, 168; 164, identifier:_class; 165, for_in_clause; 165, 166; 165, 167; 166, identifier:_class; 167, identifier:class_list; 168, if_clause; 168, 169; 169, comparison_operator:not; 169, 170; 169, 171; 170, identifier:_class; 171, identifier:ignore; 172, for_statement; 172, 173; 172, 174; 172, 175; 173, identifier:_class; 174, identifier:class_list; 175, block; 175, 176; 175, 194; 175, 242; 175, 320; 175, 330; 176, if_statement; 176, 177; 176, 178; 177, identifier:verbose; 178, block; 178, 179; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 182; 181, identifier:print; 182, argument_list; 182, 183; 183, binary_operator:+; 183, 184; 183, 191; 184, binary_operator:+; 184, 185; 184, 190; 185, binary_operator:+; 185, 186; 185, 187; 186, string:'[class] reloading parent '; 187, attribute; 187, 188; 187, 189; 188, identifier:_class; 189, identifier:__name__; 190, string:' from '; 191, attribute; 191, 192; 191, 193; 192, identifier:_class; 193, identifier:__module__; 194, if_statement; 194, 195; 194, 200; 194, 230; 195, comparison_operator:==; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:_class; 198, identifier:__module__; 199, string:'__main__'; 200, block; 200, 201; 200, 211; 200, 222; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:main_module_; 204, subscript; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:sys; 207, identifier:modules; 208, attribute; 208, 209; 208, 210; 209, identifier:_class; 210, identifier:__module__; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:main_modname; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:ut; 217, identifier:get_modname_from_modpath; 218, argument_list; 218, 219; 219, attribute; 219, 220; 219, 221; 220, identifier:main_module_; 221, identifier:__file__; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:module_; 225, subscript; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:sys; 228, identifier:modules; 229, identifier:main_modname; 230, else_clause; 230, 231; 231, block; 231, 232; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:module_; 235, subscript; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:sys; 238, identifier:modules; 239, attribute; 239, 240; 239, 241; 240, identifier:_class; 241, identifier:__module__; 242, if_statement; 242, 243; 242, 248; 242, 261; 243, call; 243, 244; 243, 245; 244, identifier:hasattr; 245, argument_list; 245, 246; 245, 247; 246, identifier:module_; 247, string:'rrr'; 248, block; 248, 249; 249, if_statement; 249, 250; 249, 251; 250, identifier:reload_module; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:module_; 256, identifier:rrr; 257, argument_list; 257, 258; 258, keyword_argument; 258, 259; 258, 260; 259, identifier:verbose; 260, identifier:verbose; 261, else_clause; 261, 262; 262, block; 262, 263; 263, if_statement; 263, 264; 263, 265; 264, identifier:reload_module; 265, block; 265, 266; 265, 269; 265, 283; 266, import_statement; 266, 267; 267, dotted_name; 267, 268; 268, identifier:imp; 269, if_statement; 269, 270; 269, 271; 270, identifier:verbose; 271, block; 271, 272; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 275; 274, identifier:print; 275, argument_list; 275, 276; 276, binary_operator:+; 276, 277; 276, 282; 277, binary_operator:+; 277, 278; 277, 279; 278, string:'[class] reloading '; 279, attribute; 279, 280; 279, 281; 280, identifier:_class; 281, identifier:__module__; 282, string:' with imp'; 283, try_statement; 283, 284; 283, 292; 284, block; 284, 285; 285, expression_statement; 285, 286; 286, call; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:imp; 289, identifier:reload; 290, argument_list; 290, 291; 291, identifier:module_; 292, except_clause; 292, 293; 292, 296; 293, tuple; 293, 294; 293, 295; 294, identifier:ImportError; 295, identifier:AttributeError; 296, block; 296, 297; 296, 308; 297, expression_statement; 297, 298; 298, call; 298, 299; 298, 300; 299, identifier:print; 300, argument_list; 300, 301; 301, binary_operator:+; 301, 302; 301, 307; 302, binary_operator:+; 302, 303; 302, 304; 303, string:'[class] fallback reloading '; 304, attribute; 304, 305; 304, 306; 305, identifier:_class; 306, identifier:__module__; 307, string:' with imp'; 308, expression_statement; 308, 309; 309, call; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:imp; 312, identifier:load_source; 313, argument_list; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:module_; 316, identifier:__name__; 317, attribute; 317, 318; 317, 319; 318, identifier:module_; 319, identifier:__file__; 320, expression_statement; 320, 321; 321, assignment; 321, 322; 321, 323; 322, identifier:_newclass; 323, call; 323, 324; 323, 325; 324, identifier:getattr; 325, argument_list; 325, 326; 325, 327; 326, identifier:module_; 327, attribute; 327, 328; 327, 329; 328, identifier:_class; 329, identifier:__name__; 330, expression_statement; 330, 331; 331, call; 331, 332; 331, 333; 332, identifier:reload_class_methods; 333, argument_list; 333, 334; 333, 335; 333, 336; 334, identifier:self; 335, identifier:_newclass; 336, keyword_argument; 336, 337; 336, 338; 337, identifier:verbose; 338, identifier:verbose; 339, if_statement; 339, 340; 339, 345; 339, 364; 340, call; 340, 341; 340, 342; 341, identifier:hasattr; 342, argument_list; 342, 343; 342, 344; 343, identifier:self; 344, string:'_initialize_self'; 345, block; 345, 346; 345, 358; 346, if_statement; 346, 347; 346, 350; 347, comparison_operator:>; 347, 348; 347, 349; 348, identifier:verbose; 349, integer:1; 350, block; 350, 351; 351, expression_statement; 351, 352; 352, call; 352, 353; 352, 354; 353, identifier:print; 354, argument_list; 354, 355; 355, binary_operator:+; 355, 356; 355, 357; 356, string:'[class] calling _initialize_self for '; 357, identifier:classname; 358, expression_statement; 358, 359; 359, call; 359, 360; 359, 363; 360, attribute; 360, 361; 360, 362; 361, identifier:self; 362, identifier:_initialize_self; 363, argument_list; 364, elif_clause; 364, 365; 364, 368; 365, comparison_operator:>; 365, 366; 365, 367; 366, identifier:verbose; 367, integer:1; 368, block; 368, 369; 369, expression_statement; 369, 370; 370, call; 370, 371; 370, 372; 371, identifier:print; 372, argument_list; 372, 373; 373, binary_operator:+; 373, 374; 373, 377; 374, binary_operator:+; 374, 375; 374, 376; 375, string:'[class] '; 376, identifier:classname; 377, string:' does not have an _initialize_self function'; 378, except_clause; 378, 379; 378, 383; 379, as_pattern; 379, 380; 379, 381; 380, identifier:Exception; 381, as_pattern_target; 381, 382; 382, identifier:ex; 383, block; 383, 384; 383, 400; 384, expression_statement; 384, 385; 385, call; 385, 386; 385, 389; 386, attribute; 386, 387; 386, 388; 387, identifier:ut; 388, identifier:printex; 389, argument_list; 389, 390; 389, 391; 389, 392; 390, identifier:ex; 391, string:'Error Reloading Class'; 392, keyword_argument; 392, 393; 392, 394; 393, identifier:keys; 394, list:[
'modname', 'module', 'class_', 'class_list', 'self', ]; 394, 395; 394, 396; 394, 397; 394, 398; 394, 399; 395, string:'modname'; 396, string:'module'; 397, string:'class_'; 398, string:'class_list'; 399, string:'self'; 400, raise_statement | def reload_class(self, verbose=True, reload_module=True):
import utool as ut
verbose = verbose or VERBOSE_CLASS
classname = self.__class__.__name__
try:
modname = self.__class__.__module__
if verbose:
print('[class] reloading ' + classname + ' from ' + modname)
if hasattr(self, '_on_reload'):
if verbose > 1:
print('[class] calling _on_reload for ' + classname)
self._on_reload()
elif verbose > 1:
print('[class] ' + classname + ' does not have an _on_reload function')
def find_base_clases(_class, find_base_clases=None):
class_list = []
for _baseclass in _class.__bases__:
parents = find_base_clases(_baseclass, find_base_clases)
class_list.extend(parents)
if _class is not object:
class_list.append(_class)
return class_list
head_class = self.__class__
class_list = find_base_clases(head_class, find_base_clases)
ignore = {HashComparable2}
class_list = [_class for _class in class_list
if _class not in ignore]
for _class in class_list:
if verbose:
print('[class] reloading parent ' + _class.__name__ +
' from ' + _class.__module__)
if _class.__module__ == '__main__':
main_module_ = sys.modules[_class.__module__]
main_modname = ut.get_modname_from_modpath(main_module_.__file__)
module_ = sys.modules[main_modname]
else:
module_ = sys.modules[_class.__module__]
if hasattr(module_, 'rrr'):
if reload_module:
module_.rrr(verbose=verbose)
else:
if reload_module:
import imp
if verbose:
print('[class] reloading ' + _class.__module__ + ' with imp')
try:
imp.reload(module_)
except (ImportError, AttributeError):
print('[class] fallback reloading ' + _class.__module__ +
' with imp')
imp.load_source(module_.__name__, module_.__file__)
_newclass = getattr(module_, _class.__name__)
reload_class_methods(self, _newclass, verbose=verbose)
if hasattr(self, '_initialize_self'):
if verbose > 1:
print('[class] calling _initialize_self for ' + classname)
self._initialize_self()
elif verbose > 1:
print('[class] ' + classname + ' does not have an _initialize_self function')
except Exception as ex:
ut.printex(ex, 'Error Reloading Class', keys=[
'modname', 'module', 'class_', 'class_list', 'self', ])
raise |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:avl_join; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:t1; 5, identifier:t2; 6, identifier:node; 7, block; 7, 8; 7, 19; 7, 197; 8, if_statement; 8, 9; 8, 10; 9, identifier:DEBUG_JOIN; 10, block; 10, 11; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:print; 14, argument_list; 14, 15; 15, binary_operator:%; 15, 16; 15, 17; 16, string:'-- JOIN node=%r'; 17, tuple; 17, 18; 18, identifier:node; 19, if_statement; 19, 20; 19, 27; 19, 40; 19, 62; 19, 84; 20, boolean_operator:and; 20, 21; 20, 24; 21, comparison_operator:is; 21, 22; 21, 23; 22, identifier:t1; 23, None; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:t2; 26, None; 27, block; 27, 28; 27, 36; 28, if_statement; 28, 29; 28, 30; 29, identifier:DEBUG_JOIN; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:print; 34, argument_list; 34, 35; 35, string:'Join Case 1'; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:top; 39, identifier:node; 40, elif_clause; 40, 41; 40, 44; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:t1; 43, None; 44, block; 44, 45; 44, 53; 45, if_statement; 45, 46; 45, 47; 46, identifier:DEBUG_JOIN; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:print; 51, argument_list; 51, 52; 52, string:'Join Case 2'; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:top; 56, call; 56, 57; 56, 58; 57, identifier:avl_insert_dir; 58, argument_list; 58, 59; 58, 60; 58, 61; 59, identifier:t2; 60, identifier:node; 61, integer:0; 62, elif_clause; 62, 63; 62, 66; 63, comparison_operator:is; 63, 64; 63, 65; 64, identifier:t2; 65, None; 66, block; 66, 67; 66, 75; 67, if_statement; 67, 68; 67, 69; 68, identifier:DEBUG_JOIN; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:print; 73, argument_list; 73, 74; 74, string:'Join Case 3'; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:top; 78, call; 78, 79; 78, 80; 79, identifier:avl_insert_dir; 80, argument_list; 80, 81; 80, 82; 80, 83; 81, identifier:t1; 82, identifier:node; 83, integer:1; 84, else_clause; 84, 85; 85, block; 85, 86; 85, 93; 85, 100; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:h1; 89, call; 89, 90; 89, 91; 90, identifier:height; 91, argument_list; 91, 92; 92, identifier:t1; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:h2; 96, call; 96, 97; 96, 98; 97, identifier:height; 98, argument_list; 98, 99; 99, identifier:t2; 100, if_statement; 100, 101; 100, 106; 100, 134; 100, 177; 101, comparison_operator:>; 101, 102; 101, 103; 102, identifier:h1; 103, binary_operator:+; 103, 104; 103, 105; 104, identifier:h2; 105, integer:1; 106, block; 106, 107; 106, 115; 106, 125; 107, if_statement; 107, 108; 107, 109; 108, identifier:DEBUG_JOIN; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:print; 113, argument_list; 113, 114; 114, string:'Join Case 4'; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:top; 118, call; 118, 119; 118, 120; 119, identifier:avl_join_dir_recursive; 120, argument_list; 120, 121; 120, 122; 120, 123; 120, 124; 121, identifier:t1; 122, identifier:t2; 123, identifier:node; 124, integer:1; 125, if_statement; 125, 126; 125, 127; 126, identifier:DEBUG_JOIN; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:ascii_tree; 131, argument_list; 131, 132; 131, 133; 132, identifier:t1; 133, string:'top'; 134, elif_clause; 134, 135; 134, 140; 135, comparison_operator:>; 135, 136; 135, 137; 136, identifier:h2; 137, binary_operator:+; 137, 138; 137, 139; 138, identifier:h1; 139, integer:1; 140, block; 140, 141; 140, 159; 140, 169; 141, if_statement; 141, 142; 141, 143; 142, identifier:DEBUG_JOIN; 143, block; 143, 144; 143, 149; 143, 154; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:print; 147, argument_list; 147, 148; 148, string:'Join Case 5'; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:ascii_tree; 152, argument_list; 152, 153; 153, identifier:t1; 154, expression_statement; 154, 155; 155, call; 155, 156; 155, 157; 156, identifier:ascii_tree; 157, argument_list; 157, 158; 158, identifier:t2; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:top; 162, call; 162, 163; 162, 164; 163, identifier:avl_join_dir_recursive; 164, argument_list; 164, 165; 164, 166; 164, 167; 164, 168; 165, identifier:t1; 166, identifier:t2; 167, identifier:node; 168, integer:0; 169, if_statement; 169, 170; 169, 171; 170, identifier:DEBUG_JOIN; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 175; 174, identifier:ascii_tree; 175, argument_list; 175, 176; 176, identifier:top; 177, else_clause; 177, 178; 178, block; 178, 179; 178, 187; 179, if_statement; 179, 180; 179, 181; 180, identifier:DEBUG_JOIN; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, call; 183, 184; 183, 185; 184, identifier:print; 185, argument_list; 185, 186; 186, string:'Join Case 6'; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:top; 190, call; 190, 191; 190, 192; 191, identifier:avl_new_top; 192, argument_list; 192, 193; 192, 194; 192, 195; 192, 196; 193, identifier:t1; 194, identifier:t2; 195, identifier:node; 196, integer:0; 197, return_statement; 197, 198; 198, identifier:top | def avl_join(t1, t2, node):
if DEBUG_JOIN:
print('-- JOIN node=%r' % (node,))
if t1 is None and t2 is None:
if DEBUG_JOIN:
print('Join Case 1')
top = node
elif t1 is None:
if DEBUG_JOIN:
print('Join Case 2')
top = avl_insert_dir(t2, node, 0)
elif t2 is None:
if DEBUG_JOIN:
print('Join Case 3')
top = avl_insert_dir(t1, node, 1)
else:
h1 = height(t1)
h2 = height(t2)
if h1 > h2 + 1:
if DEBUG_JOIN:
print('Join Case 4')
top = avl_join_dir_recursive(t1, t2, node, 1)
if DEBUG_JOIN:
ascii_tree(t1, 'top')
elif h2 > h1 + 1:
if DEBUG_JOIN:
print('Join Case 5')
ascii_tree(t1)
ascii_tree(t2)
top = avl_join_dir_recursive(t1, t2, node, 0)
if DEBUG_JOIN:
ascii_tree(top)
else:
if DEBUG_JOIN:
print('Join Case 6')
top = avl_new_top(t1, t2, node, 0)
return top |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:git_sequence_editor_squash; 3, parameters; 3, 4; 4, identifier:fpath; 5, block; 5, 6; 5, 8; 5, 13; 5, 22; 5, 27; 5, 31; 5, 35; 5, 39; 5, 92; 5, 286; 5, 295; 5, 322; 5, 327; 6, expression_statement; 6, 7; 7, identifier:r; 8, import_statement; 8, 9; 9, aliased_import; 9, 10; 9, 12; 10, dotted_name; 10, 11; 11, identifier:utool; 12, identifier:ut; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:text; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:ut; 19, identifier:read_from; 20, argument_list; 20, 21; 21, identifier:fpath; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:print; 25, argument_list; 25, 26; 26, identifier:text; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:prev_msg; 30, None; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:prev_dt; 34, None; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:new_lines; 38, list:[]; 39, function_definition; 39, 40; 39, 41; 39, 43; 40, function_name:get_commit_date; 41, parameters; 41, 42; 42, identifier:hashid; 43, block; 43, 44; 43, 67; 43, 72; 43, 81; 43, 90; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 50; 46, pattern_list; 46, 47; 46, 48; 46, 49; 47, identifier:out; 48, identifier:err; 49, identifier:ret; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:ut; 53, identifier:cmd; 54, argument_list; 54, 55; 54, 58; 54, 61; 54, 64; 55, binary_operator:+; 55, 56; 55, 57; 56, string:'git show -s --format=%ci '; 57, identifier:hashid; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:verbose; 60, False; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:quiet; 63, True; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:pad_stdout; 66, False; 67, import_from_statement; 67, 68; 67, 70; 68, dotted_name; 68, 69; 69, identifier:dateutil; 70, dotted_name; 70, 71; 71, identifier:parser; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:stamp; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:out; 78, identifier:strip; 79, argument_list; 79, 80; 80, string:'\n'; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:dt; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:parser; 87, identifier:parse; 88, argument_list; 88, 89; 89, identifier:stamp; 90, return_statement; 90, 91; 91, identifier:dt; 92, for_statement; 92, 93; 92, 94; 92, 100; 93, identifier:line; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:text; 97, identifier:split; 98, argument_list; 98, 99; 99, string:'\n'; 100, block; 100, 101; 100, 110; 100, 132; 100, 138; 100, 144; 100, 157; 100, 183; 100, 187; 100, 201; 100, 251; 100, 278; 100, 282; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:commit_line; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:line; 107, identifier:split; 108, argument_list; 108, 109; 109, string:' '; 110, if_statement; 110, 111; 110, 117; 111, comparison_operator:<; 111, 112; 111, 116; 112, call; 112, 113; 112, 114; 113, identifier:len; 114, argument_list; 114, 115; 115, identifier:commit_line; 116, integer:3; 117, block; 117, 118; 117, 122; 117, 126; 117, 131; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:prev_msg; 121, None; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:prev_dt; 125, None; 126, expression_statement; 126, 127; 127, augmented_assignment:+=; 127, 128; 127, 129; 128, identifier:new_lines; 129, list:[line]; 129, 130; 130, identifier:line; 131, continue_statement; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:action; 135, subscript; 135, 136; 135, 137; 136, identifier:commit_line; 137, integer:0; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:hashid; 141, subscript; 141, 142; 141, 143; 142, identifier:commit_line; 143, integer:1; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:msg; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, string:' '; 150, identifier:join; 151, argument_list; 151, 152; 152, subscript; 152, 153; 152, 154; 153, identifier:commit_line; 154, slice; 154, 155; 154, 156; 155, integer:2; 156, colon; 157, try_statement; 157, 158; 157, 166; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:dt; 162, call; 162, 163; 162, 164; 163, identifier:get_commit_date; 164, argument_list; 164, 165; 165, identifier:hashid; 166, except_clause; 166, 167; 166, 168; 167, identifier:ValueError; 168, block; 168, 169; 168, 173; 168, 177; 168, 182; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:prev_msg; 172, None; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:prev_dt; 176, None; 177, expression_statement; 177, 178; 178, augmented_assignment:+=; 178, 179; 178, 180; 179, identifier:new_lines; 180, list:[line]; 180, 181; 181, identifier:line; 182, continue_statement; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:orig_msg; 186, identifier:msg; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:can_squash; 190, boolean_operator:and; 190, 191; 190, 198; 191, boolean_operator:and; 191, 192; 191, 195; 192, comparison_operator:==; 192, 193; 192, 194; 193, identifier:action; 194, string:'pick'; 195, comparison_operator:==; 195, 196; 195, 197; 196, identifier:msg; 197, string:'wip'; 198, comparison_operator:==; 198, 199; 198, 200; 199, identifier:prev_msg; 200, string:'wip'; 201, if_statement; 201, 202; 201, 209; 202, boolean_operator:and; 202, 203; 202, 206; 203, comparison_operator:is; 203, 204; 203, 205; 204, identifier:prev_dt; 205, None; 206, comparison_operator:==; 206, 207; 206, 208; 207, identifier:prev_msg; 208, string:'wip'; 209, block; 209, 210; 209, 216; 209, 220; 209, 231; 209, 237; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:tdelta; 213, binary_operator:-; 213, 214; 213, 215; 214, identifier:dt; 215, identifier:prev_dt; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:threshold_minutes; 219, integer:45; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:td_min; 223, parenthesized_expression; 223, 224; 224, binary_operator:/; 224, 225; 224, 230; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:tdelta; 228, identifier:total_seconds; 229, argument_list; 230, float:60.; 231, expression_statement; 231, 232; 232, augmented_assignment:&=; 232, 233; 232, 234; 233, identifier:can_squash; 234, comparison_operator:<; 234, 235; 234, 236; 235, identifier:td_min; 236, identifier:threshold_minutes; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:msg; 240, binary_operator:+; 240, 241; 240, 242; 241, identifier:msg; 242, binary_operator:%; 242, 243; 242, 244; 243, string:' -- tdelta=%r'; 244, tuple; 244, 245; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:ut; 248, identifier:get_timedelta_str; 249, argument_list; 249, 250; 250, identifier:tdelta; 251, if_statement; 251, 252; 251, 253; 251, 271; 252, identifier:can_squash; 253, block; 253, 254; 253, 266; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:new_line; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, string:' '; 260, identifier:join; 261, argument_list; 261, 262; 262, list:['squash', hashid, msg]; 262, 263; 262, 264; 262, 265; 263, string:'squash'; 264, identifier:hashid; 265, identifier:msg; 266, expression_statement; 266, 267; 267, augmented_assignment:+=; 267, 268; 267, 269; 268, identifier:new_lines; 269, list:[new_line]; 269, 270; 270, identifier:new_line; 271, else_clause; 271, 272; 272, block; 272, 273; 273, expression_statement; 273, 274; 274, augmented_assignment:+=; 274, 275; 274, 276; 275, identifier:new_lines; 276, list:[line]; 276, 277; 277, identifier:line; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:prev_msg; 281, identifier:orig_msg; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 285; 284, identifier:prev_dt; 285, identifier:dt; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:new_text; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, string:'\n'; 292, identifier:join; 293, argument_list; 293, 294; 294, identifier:new_lines; 295, function_definition; 295, 296; 295, 297; 295, 299; 296, function_name:get_commit_date; 297, parameters; 297, 298; 298, identifier:hashid; 299, block; 299, 300; 299, 314; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:out; 303, call; 303, 304; 303, 307; 304, attribute; 304, 305; 304, 306; 305, identifier:ut; 306, identifier:cmd; 307, argument_list; 307, 308; 307, 311; 308, binary_operator:+; 308, 309; 308, 310; 309, string:'git show -s --format=%ci '; 310, identifier:hashid; 311, keyword_argument; 311, 312; 311, 313; 312, identifier:verbose; 313, False; 314, expression_statement; 314, 315; 315, call; 315, 316; 315, 317; 316, identifier:print; 317, argument_list; 317, 318; 318, binary_operator:%; 318, 319; 318, 320; 319, string:'out = %r'; 320, tuple; 320, 321; 321, identifier:out; 322, expression_statement; 322, 323; 323, call; 323, 324; 323, 325; 324, identifier:print; 325, argument_list; 325, 326; 326, identifier:new_text; 327, expression_statement; 327, 328; 328, call; 328, 329; 328, 332; 329, attribute; 329, 330; 329, 331; 330, identifier:ut; 331, identifier:write_to; 332, argument_list; 332, 333; 332, 334; 332, 335; 333, identifier:fpath; 334, identifier:new_text; 335, keyword_argument; 335, 336; 335, 337; 336, identifier:n; 337, None | def git_sequence_editor_squash(fpath):
r
import utool as ut
text = ut.read_from(fpath)
print(text)
prev_msg = None
prev_dt = None
new_lines = []
def get_commit_date(hashid):
out, err, ret = ut.cmd('git show -s --format=%ci ' + hashid, verbose=False, quiet=True, pad_stdout=False)
from dateutil import parser
stamp = out.strip('\n')
dt = parser.parse(stamp)
return dt
for line in text.split('\n'):
commit_line = line.split(' ')
if len(commit_line) < 3:
prev_msg = None
prev_dt = None
new_lines += [line]
continue
action = commit_line[0]
hashid = commit_line[1]
msg = ' ' .join(commit_line[2:])
try:
dt = get_commit_date(hashid)
except ValueError:
prev_msg = None
prev_dt = None
new_lines += [line]
continue
orig_msg = msg
can_squash = action == 'pick' and msg == 'wip' and prev_msg == 'wip'
if prev_dt is not None and prev_msg == 'wip':
tdelta = dt - prev_dt
threshold_minutes = 45
td_min = (tdelta.total_seconds() / 60.)
can_squash &= td_min < threshold_minutes
msg = msg + ' -- tdelta=%r' % (ut.get_timedelta_str(tdelta),)
if can_squash:
new_line = ' ' .join(['squash', hashid, msg])
new_lines += [new_line]
else:
new_lines += [line]
prev_msg = orig_msg
prev_dt = dt
new_text = '\n'.join(new_lines)
def get_commit_date(hashid):
out = ut.cmd('git show -s --format=%ci ' + hashid, verbose=False)
print('out = %r' % (out,))
print(new_text)
ut.write_to(fpath, new_text, n=None) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 25; 2, function_name:build_proteintable; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 4, identifier:pqdb; 5, identifier:headerfields; 6, identifier:mergecutoff; 7, default_parameter; 7, 8; 7, 9; 8, identifier:isobaric; 9, False; 10, default_parameter; 10, 11; 10, 12; 11, identifier:precursor; 12, False; 13, default_parameter; 13, 14; 13, 15; 14, identifier:probability; 15, False; 16, default_parameter; 16, 17; 16, 18; 17, identifier:fdr; 18, False; 19, default_parameter; 19, 20; 19, 21; 20, identifier:pep; 21, False; 22, default_parameter; 22, 23; 22, 24; 23, identifier:genecentric; 24, False; 25, block; 25, 26; 25, 54; 25, 63; 25, 75; 25, 87; 25, 99; 25, 111; 25, 123; 25, 137; 25, 152; 25, 160; 25, 169; 25, 176; 25, 187; 25, 203; 25, 230; 25, 308; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:pdmap; 29, call; 29, 30; 29, 31; 30, identifier:create_featuredata_map; 31, argument_list; 31, 32; 31, 33; 31, 36; 31, 41; 31, 46; 31, 51; 32, identifier:pqdb; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:genecentric; 35, identifier:genecentric; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:psm_fill_fun; 38, attribute; 38, 39; 38, 40; 39, identifier:pinfo; 40, identifier:add_psms_to_proteindata; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:pgene_fill_fun; 43, attribute; 43, 44; 43, 45; 44, identifier:pinfo; 45, identifier:add_protgene_to_protdata; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:count_fun; 48, attribute; 48, 49; 48, 50; 49, identifier:pinfo; 50, identifier:count_peps_psms; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:get_uniques; 53, True; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:empty_return; 57, lambda; 57, 58; 57, 62; 58, lambda_parameters; 58, 59; 58, 60; 58, 61; 59, identifier:x; 60, identifier:y; 61, identifier:z; 62, dictionary; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:iso_fun; 66, subscript; 66, 67; 66, 74; 67, dictionary; 67, 68; 67, 71; 68, pair; 68, 69; 68, 70; 69, True; 70, identifier:get_isobaric_quant; 71, pair; 71, 72; 71, 73; 72, False; 73, identifier:empty_return; 74, identifier:isobaric; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:ms1_fun; 78, subscript; 78, 79; 78, 86; 79, dictionary; 79, 80; 79, 83; 80, pair; 80, 81; 80, 82; 81, True; 82, identifier:get_precursor_quant; 83, pair; 83, 84; 83, 85; 84, False; 85, identifier:empty_return; 86, identifier:precursor; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:prob_fun; 90, subscript; 90, 91; 90, 98; 91, dictionary; 91, 92; 91, 95; 92, pair; 92, 93; 92, 94; 93, True; 94, identifier:get_prot_probability; 95, pair; 95, 96; 95, 97; 96, False; 97, identifier:empty_return; 98, identifier:probability; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:fdr_fun; 102, subscript; 102, 103; 102, 110; 103, dictionary; 103, 104; 103, 107; 104, pair; 104, 105; 104, 106; 105, True; 106, identifier:get_prot_fdr; 107, pair; 107, 108; 107, 109; 108, False; 109, identifier:empty_return; 110, identifier:fdr; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:pep_fun; 114, subscript; 114, 115; 114, 122; 115, dictionary; 115, 116; 115, 119; 116, pair; 116, 117; 116, 118; 117, True; 118, identifier:get_prot_pep; 119, pair; 119, 120; 119, 121; 120, False; 121, identifier:empty_return; 122, identifier:pep; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:pdata_fun; 126, subscript; 126, 127; 126, 134; 127, dictionary; 127, 128; 127, 131; 128, pair; 128, 129; 128, 130; 129, True; 130, identifier:get_protein_data_genecentric; 131, pair; 131, 132; 131, 133; 132, False; 133, identifier:get_protein_data; 134, comparison_operator:is; 134, 135; 134, 136; 135, identifier:genecentric; 136, False; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 142; 139, pattern_list; 139, 140; 139, 141; 140, identifier:protein_sql; 141, identifier:sqlfieldmap; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:pqdb; 145, identifier:prepare_mergetable_sql; 146, argument_list; 146, 147; 146, 148; 146, 149; 146, 150; 146, 151; 147, identifier:precursor; 148, identifier:isobaric; 149, identifier:probability; 150, identifier:fdr; 151, identifier:pep; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:accession_field; 155, subscript; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:prottabledata; 158, identifier:ACCESSIONS; 159, identifier:genecentric; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:proteins; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:pqdb; 166, identifier:get_merged_features; 167, argument_list; 167, 168; 168, identifier:protein_sql; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:protein; 172, call; 172, 173; 172, 174; 173, identifier:next; 174, argument_list; 174, 175; 175, identifier:proteins; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:outprotein; 179, dictionary; 179, 180; 180, pair; 180, 181; 180, 182; 181, identifier:accession_field; 182, subscript; 182, 183; 182, 184; 183, identifier:protein; 184, subscript; 184, 185; 184, 186; 185, identifier:sqlfieldmap; 186, string:'p_acc'; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:check_prot; 190, dictionary_comprehension; 190, 191; 190, 194; 191, pair; 191, 192; 191, 193; 192, identifier:k; 193, identifier:v; 194, for_in_clause; 194, 195; 194, 198; 195, pattern_list; 195, 196; 195, 197; 196, identifier:k; 197, identifier:v; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:outprotein; 201, identifier:items; 202, argument_list; 203, if_statement; 203, 204; 203, 213; 204, boolean_operator:or; 204, 205; 204, 207; 205, not_operator; 205, 206; 206, identifier:mergecutoff; 207, call; 207, 208; 207, 209; 208, identifier:protein_pool_fdr_cutoff; 209, argument_list; 209, 210; 209, 211; 209, 212; 210, identifier:protein; 211, identifier:sqlfieldmap; 212, identifier:mergecutoff; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 217; 216, identifier:fill_mergefeature; 217, argument_list; 217, 218; 217, 219; 217, 220; 217, 221; 217, 222; 217, 223; 217, 224; 217, 225; 217, 226; 217, 227; 217, 228; 217, 229; 218, identifier:outprotein; 219, identifier:iso_fun; 220, identifier:ms1_fun; 221, identifier:prob_fun; 222, identifier:fdr_fun; 223, identifier:pep_fun; 224, identifier:pdata_fun; 225, identifier:protein; 226, identifier:sqlfieldmap; 227, identifier:headerfields; 228, identifier:pdmap; 229, identifier:accession_field; 230, for_statement; 230, 231; 230, 232; 230, 233; 231, identifier:protein; 232, identifier:proteins; 233, block; 233, 234; 233, 246; 233, 254; 233, 292; 234, if_statement; 234, 235; 234, 244; 235, boolean_operator:and; 235, 236; 235, 237; 236, identifier:mergecutoff; 237, not_operator; 237, 238; 238, call; 238, 239; 238, 240; 239, identifier:protein_pool_fdr_cutoff; 240, argument_list; 240, 241; 240, 242; 240, 243; 241, identifier:protein; 242, identifier:sqlfieldmap; 243, identifier:mergecutoff; 244, block; 244, 245; 245, continue_statement; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:p_acc; 249, subscript; 249, 250; 249, 251; 250, identifier:protein; 251, subscript; 251, 252; 251, 253; 252, identifier:sqlfieldmap; 253, string:'p_acc'; 254, if_statement; 254, 255; 254, 260; 255, comparison_operator:!=; 255, 256; 255, 257; 256, identifier:p_acc; 257, subscript; 257, 258; 257, 259; 258, identifier:outprotein; 259, identifier:accession_field; 260, block; 260, 261; 260, 269; 260, 276; 261, if_statement; 261, 262; 261, 265; 262, comparison_operator:!=; 262, 263; 262, 264; 263, identifier:outprotein; 264, identifier:check_prot; 265, block; 265, 266; 266, expression_statement; 266, 267; 267, yield; 267, 268; 268, identifier:outprotein; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:outprotein; 272, dictionary; 272, 273; 273, pair; 273, 274; 273, 275; 274, identifier:accession_field; 275, identifier:p_acc; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:check_prot; 279, dictionary_comprehension; 279, 280; 279, 283; 280, pair; 280, 281; 280, 282; 281, identifier:k; 282, identifier:v; 283, for_in_clause; 283, 284; 283, 287; 284, pattern_list; 284, 285; 284, 286; 285, identifier:k; 286, identifier:v; 287, call; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:outprotein; 290, identifier:items; 291, argument_list; 292, expression_statement; 292, 293; 293, call; 293, 294; 293, 295; 294, identifier:fill_mergefeature; 295, argument_list; 295, 296; 295, 297; 295, 298; 295, 299; 295, 300; 295, 301; 295, 302; 295, 303; 295, 304; 295, 305; 295, 306; 295, 307; 296, identifier:outprotein; 297, identifier:iso_fun; 298, identifier:ms1_fun; 299, identifier:prob_fun; 300, identifier:fdr_fun; 301, identifier:pep_fun; 302, identifier:pdata_fun; 303, identifier:protein; 304, identifier:sqlfieldmap; 305, identifier:headerfields; 306, identifier:pdmap; 307, identifier:accession_field; 308, if_statement; 308, 309; 308, 312; 309, comparison_operator:!=; 309, 310; 309, 311; 310, identifier:outprotein; 311, identifier:check_prot; 312, block; 312, 313; 313, expression_statement; 313, 314; 314, yield; 314, 315; 315, identifier:outprotein | def build_proteintable(pqdb, headerfields, mergecutoff, isobaric=False,
precursor=False, probability=False, fdr=False,
pep=False, genecentric=False):
pdmap = create_featuredata_map(pqdb, genecentric=genecentric,
psm_fill_fun=pinfo.add_psms_to_proteindata,
pgene_fill_fun=pinfo.add_protgene_to_protdata,
count_fun=pinfo.count_peps_psms,
get_uniques=True)
empty_return = lambda x, y, z: {}
iso_fun = {True: get_isobaric_quant, False: empty_return}[isobaric]
ms1_fun = {True: get_precursor_quant, False: empty_return}[precursor]
prob_fun = {True: get_prot_probability,
False: empty_return}[probability]
fdr_fun = {True: get_prot_fdr,
False: empty_return}[fdr]
pep_fun = {True: get_prot_pep,
False: empty_return}[pep]
pdata_fun = {True: get_protein_data_genecentric,
False: get_protein_data}[genecentric is not False]
protein_sql, sqlfieldmap = pqdb.prepare_mergetable_sql(precursor, isobaric,
probability, fdr,
pep)
accession_field = prottabledata.ACCESSIONS[genecentric]
proteins = pqdb.get_merged_features(protein_sql)
protein = next(proteins)
outprotein = {accession_field: protein[sqlfieldmap['p_acc']]}
check_prot = {k: v for k, v in outprotein.items()}
if not mergecutoff or protein_pool_fdr_cutoff(protein, sqlfieldmap,
mergecutoff):
fill_mergefeature(outprotein, iso_fun, ms1_fun, prob_fun, fdr_fun,
pep_fun, pdata_fun, protein, sqlfieldmap,
headerfields, pdmap, accession_field)
for protein in proteins:
if mergecutoff and not protein_pool_fdr_cutoff(protein, sqlfieldmap,
mergecutoff):
continue
p_acc = protein[sqlfieldmap['p_acc']]
if p_acc != outprotein[accession_field]:
if outprotein != check_prot:
yield outprotein
outprotein = {accession_field: p_acc}
check_prot = {k: v for k, v in outprotein.items()}
fill_mergefeature(outprotein, iso_fun, ms1_fun, prob_fun, fdr_fun,
pep_fun, pdata_fun, protein, sqlfieldmap,
headerfields, pdmap, accession_field)
if outprotein != check_prot:
yield outprotein |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:start_logging; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 4, default_parameter; 4, 5; 4, 6; 5, identifier:log_fpath; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:mode; 9, string:'a'; 10, default_parameter; 10, 11; 10, 12; 11, identifier:appname; 12, string:'default'; 13, default_parameter; 13, 14; 13, 15; 14, identifier:log_dir; 15, None; 16, block; 16, 17; 16, 19; 16, 21; 16, 23; 16, 25; 16, 27; 16, 29; 16, 37; 17, expression_statement; 17, 18; 18, identifier:r; 19, global_statement; 19, 20; 20, identifier:__UTOOL_ROOT_LOGGER__; 21, global_statement; 21, 22; 22, identifier:__UTOOL_PRINT__; 23, global_statement; 23, 24; 24, identifier:__UTOOL_WRITE__; 25, global_statement; 25, 26; 26, identifier:__UTOOL_FLUSH__; 27, global_statement; 27, 28; 28, identifier:__CURRENT_LOG_FPATH__; 29, if_statement; 29, 30; 29, 31; 30, identifier:LOGGING_VERBOSE; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:print; 35, argument_list; 35, 36; 36, string:'[utool] start_logging()'; 37, if_statement; 37, 38; 37, 48; 37, 394; 38, boolean_operator:and; 38, 39; 38, 44; 39, boolean_operator:and; 39, 40; 39, 43; 40, comparison_operator:is; 40, 41; 40, 42; 41, identifier:__UTOOL_ROOT_LOGGER__; 42, None; 43, identifier:__IN_MAIN_PROCESS__; 44, not_operator; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:__inside_doctest; 47, argument_list; 48, block; 48, 49; 48, 57; 48, 77; 48, 81; 48, 100; 48, 109; 48, 116; 48, 128; 48, 135; 48, 141; 48, 149; 48, 157; 48, 163; 48, 172; 48, 184; 48, 212; 48, 343; 48, 367; 48, 371; 48, 375; 48, 379; 49, if_statement; 49, 50; 49, 51; 50, identifier:LOGGING_VERBOSE; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:print; 55, argument_list; 55, 56; 56, string:'[utool] start_logging()... rootcheck OK'; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:log_fpath; 60, None; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:log_fpath; 65, call; 65, 66; 65, 67; 66, identifier:get_log_fpath; 67, argument_list; 67, 68; 67, 71; 67, 74; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:num; 70, string:'next'; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:appname; 73, identifier:appname; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:log_dir; 76, identifier:log_dir; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:__CURRENT_LOG_FPATH__; 80, identifier:log_fpath; 81, if_statement; 81, 82; 81, 85; 82, boolean_operator:or; 82, 83; 82, 84; 83, identifier:VERBOSE; 84, identifier:LOGGING_VERBOSE; 85, block; 85, 86; 85, 93; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:startmsg; 89, parenthesized_expression; 89, 90; 90, binary_operator:%; 90, 91; 90, 92; 91, string:'logging to log_fpath=%r'; 92, identifier:log_fpath; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, call; 95, 96; 95, 97; 96, identifier:_utool_print; 97, argument_list; 98, argument_list; 98, 99; 99, identifier:startmsg; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:__UTOOL_ROOT_LOGGER__; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:logging; 106, identifier:getLogger; 107, argument_list; 107, 108; 108, string:'root'; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:__UTOOL_ROOT_LOGGER__; 113, identifier:setLevel; 114, argument_list; 114, 115; 115, string:'DEBUG'; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:logfile_handler; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:logging; 122, identifier:FileHandler; 123, argument_list; 123, 124; 123, 125; 124, identifier:log_fpath; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:mode; 127, identifier:mode; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:stdout_handler; 131, call; 131, 132; 131, 133; 132, identifier:CustomStreamHandler; 133, argument_list; 133, 134; 134, identifier:__UTOOL_STDOUT__; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:stdout_handler; 139, identifier:terminator; 140, string:''; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:add_logging_handler; 144, argument_list; 144, 145; 144, 146; 145, identifier:logfile_handler; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:format_; 148, string:'file'; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:add_logging_handler; 152, argument_list; 152, 153; 152, 154; 153, identifier:stdout_handler; 154, keyword_argument; 154, 155; 154, 156; 155, identifier:format_; 156, string:'stdout'; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:__UTOOL_ROOT_LOGGER__; 161, identifier:propagate; 162, False; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:__UTOOL_ROOT_LOGGER__; 167, identifier:setLevel; 168, argument_list; 168, 169; 169, attribute; 169, 170; 169, 171; 170, identifier:logging; 171, identifier:DEBUG; 172, function_definition; 172, 173; 172, 174; 172, 177; 173, function_name:utool_flush; 174, parameters; 174, 175; 175, list_splat_pattern; 175, 176; 176, identifier:args; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:stdout_handler; 182, identifier:flush; 183, argument_list; 184, function_definition; 184, 185; 184, 186; 184, 189; 185, function_name:utool_write; 186, parameters; 186, 187; 187, list_splat_pattern; 187, 188; 188, identifier:args; 189, block; 189, 190; 189, 205; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:msg; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, string:', '; 196, identifier:join; 197, argument_list; 197, 198; 198, call; 198, 199; 198, 200; 199, identifier:map; 200, argument_list; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:six; 203, identifier:text_type; 204, identifier:args; 205, expression_statement; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:__UTOOL_ROOT_LOGGER__; 209, identifier:info; 210, argument_list; 210, 211; 211, identifier:msg; 212, if_statement; 212, 213; 212, 215; 212, 279; 213, not_operator; 213, 214; 214, identifier:PRINT_ALL_CALLERS; 215, block; 215, 216; 216, function_definition; 216, 217; 216, 218; 216, 221; 217, function_name:utool_print; 218, parameters; 218, 219; 219, list_splat_pattern; 219, 220; 220, identifier:args; 221, block; 221, 222; 221, 226; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:endline; 225, string:'\n'; 226, try_statement; 226, 227; 226, 252; 227, block; 227, 228; 227, 243; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:msg; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, string:', '; 234, identifier:join; 235, argument_list; 235, 236; 236, call; 236, 237; 236, 238; 237, identifier:map; 238, argument_list; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:six; 241, identifier:text_type; 242, identifier:args; 243, return_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:__UTOOL_ROOT_LOGGER__; 247, identifier:info; 248, argument_list; 248, 249; 249, binary_operator:+; 249, 250; 249, 251; 250, identifier:msg; 251, identifier:endline; 252, except_clause; 252, 253; 252, 254; 253, identifier:UnicodeDecodeError; 254, block; 254, 255; 254, 270; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:new_msg; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, string:', '; 261, identifier:join; 262, argument_list; 262, 263; 263, call; 263, 264; 263, 265; 264, identifier:map; 265, argument_list; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:meta_util_six; 268, identifier:ensure_unicode; 269, identifier:args; 270, return_statement; 270, 271; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:__UTOOL_ROOT_LOGGER__; 274, identifier:info; 275, argument_list; 275, 276; 276, binary_operator:+; 276, 277; 276, 278; 277, identifier:new_msg; 278, identifier:endline; 279, else_clause; 279, 280; 280, block; 280, 281; 281, function_definition; 281, 282; 281, 283; 281, 286; 282, function_name:utool_print; 283, parameters; 283, 284; 284, list_splat_pattern; 284, 285; 285, identifier:args; 286, block; 286, 287; 286, 292; 286, 296; 286, 300; 286, 307; 286, 323; 287, import_statement; 287, 288; 288, aliased_import; 288, 289; 288, 291; 289, dotted_name; 289, 290; 290, identifier:utool; 291, identifier:ut; 292, expression_statement; 292, 293; 293, call; 293, 294; 293, 295; 294, identifier:utool_flush; 295, argument_list; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 299; 298, identifier:endline; 299, string:'\n'; 300, expression_statement; 300, 301; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:__UTOOL_ROOT_LOGGER__; 304, identifier:info; 305, argument_list; 305, 306; 306, string:'\n\n----------'; 307, expression_statement; 307, 308; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:__UTOOL_ROOT_LOGGER__; 311, identifier:info; 312, argument_list; 312, 313; 313, call; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:ut; 316, identifier:get_caller_name; 317, argument_list; 317, 318; 318, call; 318, 319; 318, 320; 319, identifier:range; 320, argument_list; 320, 321; 320, 322; 321, integer:0; 322, integer:20; 323, return_statement; 323, 324; 324, call; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:__UTOOL_ROOT_LOGGER__; 327, identifier:info; 328, argument_list; 328, 329; 329, binary_operator:+; 329, 330; 329, 342; 330, call; 330, 331; 330, 334; 331, attribute; 331, 332; 331, 333; 332, string:', '; 333, identifier:join; 334, argument_list; 334, 335; 335, call; 335, 336; 335, 337; 336, identifier:map; 337, argument_list; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:six; 340, identifier:text_type; 341, identifier:args; 342, identifier:endline; 343, function_definition; 343, 344; 343, 345; 343, 348; 344, function_name:utool_printdbg; 345, parameters; 345, 346; 346, list_splat_pattern; 346, 347; 347, identifier:args; 348, block; 348, 349; 349, return_statement; 349, 350; 350, call; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:__UTOOL_ROOT_LOGGER__; 353, identifier:debug; 354, argument_list; 354, 355; 355, call; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, string:', '; 358, identifier:join; 359, argument_list; 359, 360; 360, call; 360, 361; 360, 362; 361, identifier:map; 362, argument_list; 362, 363; 362, 366; 363, attribute; 363, 364; 363, 365; 364, identifier:six; 365, identifier:text_type; 366, identifier:args; 367, expression_statement; 367, 368; 368, assignment; 368, 369; 368, 370; 369, identifier:__UTOOL_WRITE__; 370, identifier:utool_write; 371, expression_statement; 371, 372; 372, assignment; 372, 373; 372, 374; 373, identifier:__UTOOL_FLUSH__; 374, identifier:utool_flush; 375, expression_statement; 375, 376; 376, assignment; 376, 377; 376, 378; 377, identifier:__UTOOL_PRINT__; 378, identifier:utool_print; 379, if_statement; 379, 380; 379, 383; 380, boolean_operator:or; 380, 381; 380, 382; 381, identifier:VERBOSE; 382, identifier:LOGGING_VERBOSE; 383, block; 383, 384; 383, 389; 384, expression_statement; 384, 385; 385, call; 385, 386; 385, 387; 386, identifier:__UTOOL_PRINT__; 387, argument_list; 387, 388; 388, string:'<__LOG_START__>'; 389, expression_statement; 389, 390; 390, call; 390, 391; 390, 392; 391, identifier:__UTOOL_PRINT__; 392, argument_list; 392, 393; 393, identifier:startmsg; 394, else_clause; 394, 395; 395, block; 395, 396; 396, if_statement; 396, 397; 396, 398; 397, identifier:LOGGING_VERBOSE; 398, block; 398, 399; 398, 404; 398, 409; 398, 419; 398, 427; 399, expression_statement; 399, 400; 400, call; 400, 401; 400, 402; 401, identifier:print; 402, argument_list; 402, 403; 403, string:'[utool] start_logging()... FAILED TO START'; 404, expression_statement; 404, 405; 405, call; 405, 406; 405, 407; 406, identifier:print; 407, argument_list; 407, 408; 408, string:'DEBUG INFO'; 409, expression_statement; 409, 410; 410, call; 410, 411; 410, 412; 411, identifier:print; 412, argument_list; 412, 413; 413, binary_operator:%; 413, 414; 413, 415; 414, string:'__inside_doctest() = %r'; 415, tuple; 415, 416; 416, call; 416, 417; 416, 418; 417, identifier:__inside_doctest; 418, argument_list; 419, expression_statement; 419, 420; 420, call; 420, 421; 420, 422; 421, identifier:print; 422, argument_list; 422, 423; 423, binary_operator:%; 423, 424; 423, 425; 424, string:'__IN_MAIN_PROCESS__ = %r'; 425, tuple; 425, 426; 426, identifier:__IN_MAIN_PROCESS__; 427, expression_statement; 427, 428; 428, call; 428, 429; 428, 430; 429, identifier:print; 430, argument_list; 430, 431; 431, binary_operator:%; 431, 432; 431, 433; 432, string:'__UTOOL_ROOT_LOGGER__ = %r'; 433, tuple; 433, 434; 434, identifier:__UTOOL_ROOT_LOGGER__ | def start_logging(log_fpath=None, mode='a', appname='default', log_dir=None):
r
global __UTOOL_ROOT_LOGGER__
global __UTOOL_PRINT__
global __UTOOL_WRITE__
global __UTOOL_FLUSH__
global __CURRENT_LOG_FPATH__
if LOGGING_VERBOSE:
print('[utool] start_logging()')
if __UTOOL_ROOT_LOGGER__ is None and __IN_MAIN_PROCESS__ and not __inside_doctest():
if LOGGING_VERBOSE:
print('[utool] start_logging()... rootcheck OK')
if log_fpath is None:
log_fpath = get_log_fpath(num='next', appname=appname, log_dir=log_dir)
__CURRENT_LOG_FPATH__ = log_fpath
if VERBOSE or LOGGING_VERBOSE:
startmsg = ('logging to log_fpath=%r' % log_fpath)
_utool_print()(startmsg)
__UTOOL_ROOT_LOGGER__ = logging.getLogger('root')
__UTOOL_ROOT_LOGGER__.setLevel('DEBUG')
logfile_handler = logging.FileHandler(log_fpath, mode=mode)
stdout_handler = CustomStreamHandler(__UTOOL_STDOUT__)
stdout_handler.terminator = ''
add_logging_handler(logfile_handler, format_='file')
add_logging_handler(stdout_handler, format_='stdout')
__UTOOL_ROOT_LOGGER__.propagate = False
__UTOOL_ROOT_LOGGER__.setLevel(logging.DEBUG)
def utool_flush(*args):
stdout_handler.flush()
def utool_write(*args):
msg = ', '.join(map(six.text_type, args))
__UTOOL_ROOT_LOGGER__.info(msg)
if not PRINT_ALL_CALLERS:
def utool_print(*args):
endline = '\n'
try:
msg = ', '.join(map(six.text_type, args))
return __UTOOL_ROOT_LOGGER__.info(msg + endline)
except UnicodeDecodeError:
new_msg = ', '.join(map(meta_util_six.ensure_unicode, args))
return __UTOOL_ROOT_LOGGER__.info(new_msg + endline)
else:
def utool_print(*args):
import utool as ut
utool_flush()
endline = '\n'
__UTOOL_ROOT_LOGGER__.info('\n\n----------')
__UTOOL_ROOT_LOGGER__.info(ut.get_caller_name(range(0, 20)))
return __UTOOL_ROOT_LOGGER__.info(', '.join(map(six.text_type, args)) + endline)
def utool_printdbg(*args):
return __UTOOL_ROOT_LOGGER__.debug(', '.join(map(six.text_type, args)))
__UTOOL_WRITE__ = utool_write
__UTOOL_FLUSH__ = utool_flush
__UTOOL_PRINT__ = utool_print
if VERBOSE or LOGGING_VERBOSE:
__UTOOL_PRINT__('<__LOG_START__>')
__UTOOL_PRINT__(startmsg)
else:
if LOGGING_VERBOSE:
print('[utool] start_logging()... FAILED TO START')
print('DEBUG INFO')
print('__inside_doctest() = %r' % (__inside_doctest(),))
print('__IN_MAIN_PROCESS__ = %r' % (__IN_MAIN_PROCESS__,))
print('__UTOOL_ROOT_LOGGER__ = %r' % (__UTOOL_ROOT_LOGGER__,)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:list_all_eq_to; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:list_; 5, identifier:val; 6, default_parameter; 6, 7; 6, 8; 7, identifier:strict; 8, True; 9, block; 9, 10; 9, 39; 10, if_statement; 10, 11; 10, 22; 11, boolean_operator:and; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:util_type; 14, identifier:HAVE_NUMPY; 15, call; 15, 16; 15, 17; 16, identifier:isinstance; 17, argument_list; 17, 18; 17, 19; 18, identifier:val; 19, attribute; 19, 20; 19, 21; 20, identifier:np; 21, identifier:ndarray; 22, block; 22, 23; 23, return_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:all; 26, argument_list; 26, 27; 27, list_comprehension; 27, 28; 27, 36; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:np; 31, identifier:all; 32, argument_list; 32, 33; 33, comparison_operator:==; 33, 34; 33, 35; 34, identifier:item; 35, identifier:val; 36, for_in_clause; 36, 37; 36, 38; 37, identifier:item; 38, identifier:list_; 39, try_statement; 39, 40; 39, 91; 40, block; 40, 41; 41, with_statement; 41, 42; 41, 49; 42, with_clause; 42, 43; 43, with_item; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:warnings; 47, identifier:catch_warnings; 48, argument_list; 49, block; 49, 50; 49, 60; 49, 70; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:warnings; 54, identifier:filterwarnings; 55, argument_list; 55, 56; 55, 57; 56, string:'ignore'; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:category; 59, identifier:FutureWarning; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:flags; 63, list_comprehension; 63, 64; 63, 67; 64, comparison_operator:==; 64, 65; 64, 66; 65, identifier:item; 66, identifier:val; 67, for_in_clause; 67, 68; 67, 69; 68, identifier:item; 69, identifier:list_; 70, return_statement; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:all; 73, argument_list; 73, 74; 74, list_comprehension; 74, 75; 74, 88; 75, conditional_expression:if; 75, 76; 75, 82; 75, 87; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:np; 79, identifier:all; 80, argument_list; 80, 81; 81, identifier:flag; 82, call; 82, 83; 82, 84; 83, identifier:hasattr; 84, argument_list; 84, 85; 84, 86; 85, identifier:flag; 86, string:'__array__'; 87, identifier:flag; 88, for_in_clause; 88, 89; 88, 90; 89, identifier:flag; 90, identifier:flags; 91, except_clause; 91, 92; 91, 93; 92, identifier:ValueError; 93, block; 93, 94; 94, if_statement; 94, 95; 94, 97; 94, 115; 95, not_operator; 95, 96; 96, identifier:strict; 97, block; 97, 98; 98, return_statement; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:all; 101, argument_list; 101, 102; 102, list_comprehension; 102, 103; 102, 112; 103, comparison_operator:==; 103, 104; 103, 108; 104, call; 104, 105; 104, 106; 105, identifier:repr; 106, argument_list; 106, 107; 107, identifier:item; 108, call; 108, 109; 108, 110; 109, identifier:repr; 110, argument_list; 110, 111; 111, identifier:val; 112, for_in_clause; 112, 113; 112, 114; 113, identifier:item; 114, identifier:list_; 115, else_clause; 115, 116; 116, block; 116, 117; 117, raise_statement | def list_all_eq_to(list_, val, strict=True):
if util_type.HAVE_NUMPY and isinstance(val, np.ndarray):
return all([np.all(item == val) for item in list_])
try:
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=FutureWarning)
flags = [item == val for item in list_]
return all([np.all(flag) if hasattr(flag, '__array__') else flag
for flag in flags])
except ValueError:
if not strict:
return all([repr(item) == repr(val) for item in list_])
else:
raise |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:isect; 3, parameters; 3, 4; 3, 5; 4, identifier:list1; 5, identifier:list2; 6, block; 6, 7; 6, 9; 6, 16; 7, expression_statement; 7, 8; 8, identifier:r; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:set2; 12, call; 12, 13; 12, 14; 13, identifier:set; 14, argument_list; 14, 15; 15, identifier:list2; 16, return_statement; 16, 17; 17, list_comprehension; 17, 18; 17, 19; 17, 22; 18, identifier:item; 19, for_in_clause; 19, 20; 19, 21; 20, identifier:item; 21, identifier:list1; 22, if_clause; 22, 23; 23, comparison_operator:in; 23, 24; 23, 25; 24, identifier:item; 25, identifier:set2 | def isect(list1, list2):
r
set2 = set(list2)
return [item for item in list1 if item in set2] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:argsort; 3, parameters; 3, 4; 3, 6; 4, list_splat_pattern; 4, 5; 5, identifier:args; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 9, if_statement; 9, 10; 9, 24; 9, 59; 10, boolean_operator:and; 10, 11; 10, 17; 11, comparison_operator:==; 11, 12; 11, 16; 12, call; 12, 13; 12, 14; 13, identifier:len; 14, argument_list; 14, 15; 15, identifier:args; 16, integer:1; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 23; 20, subscript; 20, 21; 20, 22; 21, identifier:args; 22, integer:0; 23, identifier:dict; 24, block; 24, 25; 24, 31; 24, 42; 24, 53; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:dict_; 28, subscript; 28, 29; 28, 30; 29, identifier:args; 30, integer:0; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:index_list; 34, call; 34, 35; 34, 36; 35, identifier:list; 36, argument_list; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:dict_; 40, identifier:keys; 41, argument_list; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:value_list; 45, call; 45, 46; 45, 47; 46, identifier:list; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:dict_; 51, identifier:values; 52, argument_list; 53, return_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:sortedby2; 56, argument_list; 56, 57; 56, 58; 57, identifier:index_list; 58, identifier:value_list; 59, else_clause; 59, 60; 60, block; 60, 61; 60, 76; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:index_list; 64, call; 64, 65; 64, 66; 65, identifier:list; 66, argument_list; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:range; 69, argument_list; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:len; 72, argument_list; 72, 73; 73, subscript; 73, 74; 73, 75; 74, identifier:args; 75, integer:0; 76, return_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:sortedby2; 79, argument_list; 79, 80; 79, 81; 79, 83; 80, identifier:index_list; 81, list_splat; 81, 82; 82, identifier:args; 83, dictionary_splat; 83, 84; 84, identifier:kwargs | def argsort(*args, **kwargs):
if len(args) == 1 and isinstance(args[0], dict):
dict_ = args[0]
index_list = list(dict_.keys())
value_list = list(dict_.values())
return sortedby2(index_list, value_list)
else:
index_list = list(range(len(args[0])))
return sortedby2(index_list, *args, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:argsort2; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:indexable; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, block; 11, 12; 11, 52; 11, 102; 12, if_statement; 12, 13; 12, 18; 12, 35; 13, call; 13, 14; 13, 15; 14, identifier:isinstance; 15, argument_list; 15, 16; 15, 17; 16, identifier:indexable; 17, identifier:dict; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:vk_iter; 22, generator_expression; 22, 23; 22, 26; 23, tuple; 23, 24; 23, 25; 24, identifier:v; 25, identifier:k; 26, for_in_clause; 26, 27; 26, 30; 27, pattern_list; 27, 28; 27, 29; 28, identifier:k; 29, identifier:v; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:indexable; 33, identifier:items; 34, argument_list; 35, else_clause; 35, 36; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:vk_iter; 40, generator_expression; 40, 41; 40, 44; 41, tuple; 41, 42; 41, 43; 42, identifier:v; 43, identifier:k; 44, for_in_clause; 44, 45; 44, 48; 45, pattern_list; 45, 46; 45, 47; 46, identifier:k; 47, identifier:v; 48, call; 48, 49; 48, 50; 49, identifier:enumerate; 50, argument_list; 50, 51; 51, identifier:indexable; 52, if_statement; 52, 53; 52, 56; 52, 73; 53, comparison_operator:is; 53, 54; 53, 55; 54, identifier:key; 55, None; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:indices; 60, list_comprehension; 60, 61; 60, 62; 61, identifier:k; 62, for_in_clause; 62, 63; 62, 66; 63, pattern_list; 63, 64; 63, 65; 64, identifier:v; 65, identifier:k; 66, call; 66, 67; 66, 68; 67, identifier:sorted; 68, argument_list; 68, 69; 68, 70; 69, identifier:vk_iter; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:reverse; 72, identifier:reverse; 73, else_clause; 73, 74; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:indices; 78, list_comprehension; 78, 79; 78, 80; 79, identifier:k; 80, for_in_clause; 80, 81; 80, 84; 81, pattern_list; 81, 82; 81, 83; 82, identifier:v; 83, identifier:k; 84, call; 84, 85; 84, 86; 85, identifier:sorted; 86, argument_list; 86, 87; 86, 88; 86, 99; 87, identifier:vk_iter; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:key; 90, lambda; 90, 91; 90, 93; 91, lambda_parameters; 91, 92; 92, identifier:vk; 93, call; 93, 94; 93, 95; 94, identifier:key; 95, argument_list; 95, 96; 96, subscript; 96, 97; 96, 98; 97, identifier:vk; 98, integer:0; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:reverse; 101, identifier:reverse; 102, return_statement; 102, 103; 103, identifier:indices | def argsort2(indexable, key=None, reverse=False):
if isinstance(indexable, dict):
vk_iter = ((v, k) for k, v in indexable.items())
else:
vk_iter = ((v, k) for k, v in enumerate(indexable))
if key is None:
indices = [k for v, k in sorted(vk_iter, reverse=reverse)]
else:
indices = [k for v, k in sorted(vk_iter, key=lambda vk: key(vk[0]),
reverse=reverse)]
return indices |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:issorted; 3, parameters; 3, 4; 3, 5; 4, identifier:list_; 5, default_parameter; 5, 6; 5, 7; 6, identifier:op; 7, attribute; 7, 8; 7, 9; 8, identifier:operator; 9, identifier:le; 10, block; 10, 11; 11, return_statement; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:all; 14, generator_expression; 14, 15; 14, 26; 15, call; 15, 16; 15, 17; 16, identifier:op; 17, argument_list; 17, 18; 17, 21; 18, subscript; 18, 19; 18, 20; 19, identifier:list_; 20, identifier:ix; 21, subscript; 21, 22; 21, 23; 22, identifier:list_; 23, binary_operator:+; 23, 24; 23, 25; 24, identifier:ix; 25, integer:1; 26, for_in_clause; 26, 27; 26, 28; 27, identifier:ix; 28, call; 28, 29; 28, 30; 29, identifier:range; 30, argument_list; 30, 31; 31, binary_operator:-; 31, 32; 31, 36; 32, call; 32, 33; 32, 34; 33, identifier:len; 34, argument_list; 34, 35; 35, identifier:list_; 36, integer:1 | def issorted(list_, op=operator.le):
return all(op(list_[ix], list_[ix + 1]) for ix in range(len(list_) - 1)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:depth_profile; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:list_; 5, default_parameter; 5, 6; 5, 7; 6, identifier:max_depth; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:compress_homogenous; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:compress_consecutive; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:new_depth; 16, False; 17, block; 17, 18; 17, 20; 17, 38; 17, 42; 17, 60; 17, 158; 17, 211; 17, 353; 18, expression_statement; 18, 19; 19, identifier:r; 20, if_statement; 20, 21; 20, 26; 21, call; 21, 22; 21, 23; 22, identifier:isinstance; 23, argument_list; 23, 24; 23, 25; 24, identifier:list_; 25, identifier:dict; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:list_; 30, call; 30, 31; 30, 32; 31, identifier:list; 32, argument_list; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:list_; 36, identifier:values; 37, argument_list; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:level_shape_list; 41, list:[]; 42, if_statement; 42, 43; 42, 54; 43, not_operator; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:any; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 49; 48, identifier:map; 49, argument_list; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:util_type; 52, identifier:is_listlike; 53, identifier:list_; 54, block; 54, 55; 55, return_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, identifier:list_; 60, if_statement; 60, 61; 60, 64; 60, 66; 61, boolean_operator:and; 61, 62; 61, 63; 62, False; 63, identifier:new_depth; 64, block; 64, 65; 65, pass_statement; 66, else_clause; 66, 67; 67, block; 67, 68; 68, for_statement; 68, 69; 68, 70; 68, 71; 69, identifier:item; 70, identifier:list_; 71, block; 71, 72; 71, 90; 72, if_statement; 72, 73; 72, 78; 73, call; 73, 74; 73, 75; 74, identifier:isinstance; 75, argument_list; 75, 76; 75, 77; 76, identifier:item; 77, identifier:dict; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:item; 82, call; 82, 83; 82, 84; 83, identifier:list; 84, argument_list; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:item; 88, identifier:values; 89, argument_list; 90, if_statement; 90, 91; 90, 97; 90, 149; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:util_type; 94, identifier:is_listlike; 95, argument_list; 95, 96; 96, identifier:item; 97, block; 97, 98; 98, if_statement; 98, 99; 98, 102; 98, 114; 99, comparison_operator:is; 99, 100; 99, 101; 100, identifier:max_depth; 101, None; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:level_shape_list; 107, identifier:append; 108, argument_list; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:depth_profile; 111, argument_list; 111, 112; 111, 113; 112, identifier:item; 113, None; 114, else_clause; 114, 115; 115, block; 115, 116; 116, if_statement; 116, 117; 116, 120; 116, 134; 117, comparison_operator:>=; 117, 118; 117, 119; 118, identifier:max_depth; 119, integer:0; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:level_shape_list; 125, identifier:append; 126, argument_list; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:depth_profile; 129, argument_list; 129, 130; 129, 131; 130, identifier:item; 131, binary_operator:-; 131, 132; 131, 133; 132, identifier:max_depth; 133, integer:1; 134, else_clause; 134, 135; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:level_shape_list; 140, identifier:append; 141, argument_list; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:str; 144, argument_list; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:len; 147, argument_list; 147, 148; 148, identifier:item; 149, else_clause; 149, 150; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:level_shape_list; 155, identifier:append; 156, argument_list; 156, 157; 157, integer:1; 158, if_statement; 158, 159; 158, 160; 159, identifier:compress_homogenous; 160, block; 160, 161; 161, if_statement; 161, 162; 161, 166; 162, call; 162, 163; 162, 164; 163, identifier:allsame; 164, argument_list; 164, 165; 165, identifier:level_shape_list; 166, block; 166, 167; 166, 173; 166, 180; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:dim_; 170, subscript; 170, 171; 170, 172; 171, identifier:level_shape_list; 172, integer:0; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:len_; 176, call; 176, 177; 176, 178; 177, identifier:len; 178, argument_list; 178, 179; 179, identifier:level_shape_list; 180, if_statement; 180, 181; 180, 186; 180, 200; 181, call; 181, 182; 181, 183; 182, identifier:isinstance; 183, argument_list; 183, 184; 183, 185; 184, identifier:dim_; 185, identifier:tuple; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:level_shape_list; 190, call; 190, 191; 190, 192; 191, identifier:tuple; 192, argument_list; 192, 193; 193, binary_operator:+; 193, 194; 193, 196; 194, list:[len_]; 194, 195; 195, identifier:len_; 196, call; 196, 197; 196, 198; 197, identifier:list; 198, argument_list; 198, 199; 199, identifier:dim_; 200, else_clause; 200, 201; 201, block; 201, 202; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:level_shape_list; 205, call; 205, 206; 205, 207; 206, identifier:tuple; 207, argument_list; 207, 208; 208, list:[len_, dim_]; 208, 209; 208, 210; 209, identifier:len_; 210, identifier:dim_; 211, if_statement; 211, 212; 211, 213; 212, identifier:compress_consecutive; 213, block; 213, 214; 213, 229; 213, 237; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:hash_list; 217, call; 217, 218; 217, 219; 218, identifier:list; 219, argument_list; 219, 220; 220, call; 220, 221; 220, 222; 221, identifier:map; 222, argument_list; 222, 223; 222, 224; 223, identifier:hash; 224, call; 224, 225; 224, 226; 225, identifier:map; 226, argument_list; 226, 227; 226, 228; 227, identifier:str; 228, identifier:level_shape_list; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:consec_list; 232, call; 232, 233; 232, 234; 233, identifier:group_consecutives; 234, argument_list; 234, 235; 234, 236; 235, identifier:hash_list; 236, integer:0; 237, if_statement; 237, 238; 237, 247; 238, comparison_operator:!=; 238, 239; 238, 243; 239, call; 239, 240; 239, 241; 240, identifier:len; 241, argument_list; 241, 242; 242, identifier:consec_list; 243, call; 243, 244; 243, 245; 244, identifier:len; 245, argument_list; 245, 246; 246, identifier:level_shape_list; 247, block; 247, 248; 247, 259; 247, 268; 247, 272; 247, 276; 247, 328; 247, 345; 247, 349; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 251; 250, identifier:len_list; 251, call; 251, 252; 251, 253; 252, identifier:list; 253, argument_list; 253, 254; 254, call; 254, 255; 254, 256; 255, identifier:map; 256, argument_list; 256, 257; 256, 258; 257, identifier:len; 258, identifier:consec_list; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:cumsum_list; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:np; 265, identifier:cumsum; 266, argument_list; 266, 267; 267, identifier:len_list; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:consec_str; 271, string:'['; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:thresh; 275, integer:1; 276, for_statement; 276, 277; 276, 280; 276, 285; 277, pattern_list; 277, 278; 277, 279; 278, identifier:len_; 279, identifier:cumsum; 280, call; 280, 281; 280, 282; 281, identifier:zip; 282, argument_list; 282, 283; 282, 284; 283, identifier:len_list; 284, identifier:cumsum_list; 285, block; 285, 286; 285, 294; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:value; 289, subscript; 289, 290; 289, 291; 290, identifier:level_shape_list; 291, binary_operator:-; 291, 292; 291, 293; 292, identifier:cumsum; 293, integer:1; 294, if_statement; 294, 295; 294, 298; 294, 317; 295, comparison_operator:>; 295, 296; 295, 297; 296, identifier:len_; 297, identifier:thresh; 298, block; 298, 299; 298, 313; 299, expression_statement; 299, 300; 300, augmented_assignment:+=; 300, 301; 300, 302; 301, identifier:consec_str; 302, binary_operator:+; 302, 303; 302, 309; 303, binary_operator:+; 303, 304; 303, 308; 304, call; 304, 305; 304, 306; 305, identifier:str; 306, argument_list; 306, 307; 307, identifier:value; 308, string:'] * '; 309, call; 309, 310; 309, 311; 310, identifier:str; 311, argument_list; 311, 312; 312, identifier:len_; 313, expression_statement; 313, 314; 314, augmented_assignment:+=; 314, 315; 314, 316; 315, identifier:consec_str; 316, string:' + ['; 317, else_clause; 317, 318; 318, block; 318, 319; 319, expression_statement; 319, 320; 320, augmented_assignment:+=; 320, 321; 320, 322; 321, identifier:consec_str; 322, binary_operator:+; 322, 323; 322, 327; 323, call; 323, 324; 323, 325; 324, identifier:str; 325, argument_list; 325, 326; 326, identifier:value; 327, string:', '; 328, if_statement; 328, 329; 328, 335; 329, call; 329, 330; 329, 333; 330, attribute; 330, 331; 330, 332; 331, identifier:consec_str; 332, identifier:endswith; 333, argument_list; 333, 334; 334, string:', '; 335, block; 335, 336; 336, expression_statement; 336, 337; 337, assignment; 337, 338; 337, 339; 338, identifier:consec_str; 339, subscript; 339, 340; 339, 341; 340, identifier:consec_str; 341, slice; 341, 342; 341, 343; 342, colon; 343, unary_operator:-; 343, 344; 344, integer:2; 345, expression_statement; 345, 346; 346, augmented_assignment:+=; 346, 347; 346, 348; 347, identifier:consec_str; 348, string:']'; 349, expression_statement; 349, 350; 350, assignment; 350, 351; 350, 352; 351, identifier:level_shape_list; 352, identifier:consec_str; 353, return_statement; 353, 354; 354, identifier:level_shape_list | def depth_profile(list_, max_depth=None, compress_homogenous=True, compress_consecutive=False, new_depth=False):
r
if isinstance(list_, dict):
list_ = list(list_.values())
level_shape_list = []
if not any(map(util_type.is_listlike, list_)):
return len(list_)
if False and new_depth:
pass
else:
for item in list_:
if isinstance(item, dict):
item = list(item.values())
if util_type.is_listlike(item):
if max_depth is None:
level_shape_list.append(depth_profile(item, None))
else:
if max_depth >= 0:
level_shape_list.append(depth_profile(item, max_depth - 1))
else:
level_shape_list.append(str(len(item)))
else:
level_shape_list.append(1)
if compress_homogenous:
if allsame(level_shape_list):
dim_ = level_shape_list[0]
len_ = len(level_shape_list)
if isinstance(dim_, tuple):
level_shape_list = tuple([len_] + list(dim_))
else:
level_shape_list = tuple([len_, dim_])
if compress_consecutive:
hash_list = list(map(hash, map(str, level_shape_list)))
consec_list = group_consecutives(hash_list, 0)
if len(consec_list) != len(level_shape_list):
len_list = list(map(len, consec_list))
cumsum_list = np.cumsum(len_list)
consec_str = '['
thresh = 1
for len_, cumsum in zip(len_list, cumsum_list):
value = level_shape_list[cumsum - 1]
if len_ > thresh:
consec_str += str(value) + '] * ' + str(len_)
consec_str += ' + ['
else:
consec_str += str(value) + ', '
if consec_str.endswith(', '):
consec_str = consec_str[:-2]
consec_str += ']'
level_shape_list = consec_str
return level_shape_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:list_alignment; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:list1; 5, identifier:list2; 6, default_parameter; 6, 7; 6, 8; 7, identifier:missing; 8, False; 9, block; 9, 10; 9, 15; 9, 22; 9, 48; 10, import_statement; 10, 11; 11, aliased_import; 11, 12; 11, 14; 12, dotted_name; 12, 13; 13, identifier:utool; 14, identifier:ut; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:item1_to_idx; 18, call; 18, 19; 18, 20; 19, identifier:make_index_lookup; 20, argument_list; 20, 21; 21, identifier:list1; 22, if_statement; 22, 23; 22, 24; 22, 36; 23, identifier:missing; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:sortx; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:ut; 31, identifier:dict_take; 32, argument_list; 32, 33; 32, 34; 32, 35; 33, identifier:item1_to_idx; 34, identifier:list2; 35, None; 36, else_clause; 36, 37; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:sortx; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:ut; 44, identifier:take; 45, argument_list; 45, 46; 45, 47; 46, identifier:item1_to_idx; 47, identifier:list2; 48, return_statement; 48, 49; 49, identifier:sortx | def list_alignment(list1, list2, missing=False):
import utool as ut
item1_to_idx = make_index_lookup(list1)
if missing:
sortx = ut.dict_take(item1_to_idx, list2, None)
else:
sortx = ut.take(item1_to_idx, list2)
return sortx |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_update_hasher; 3, parameters; 3, 4; 3, 5; 4, identifier:hasher; 5, identifier:data; 6, block; 6, 7; 6, 53; 7, if_statement; 7, 8; 7, 16; 7, 21; 7, 47; 8, call; 8, 9; 8, 10; 9, identifier:isinstance; 10, argument_list; 10, 11; 10, 12; 11, identifier:data; 12, tuple; 12, 13; 12, 14; 12, 15; 13, identifier:tuple; 14, identifier:list; 15, identifier:zip; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:needs_iteration; 20, True; 21, elif_clause; 21, 22; 21, 42; 22, parenthesized_expression; 22, 23; 23, boolean_operator:and; 23, 24; 23, 35; 24, boolean_operator:and; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:util_type; 27, identifier:HAVE_NUMPY; 28, call; 28, 29; 28, 30; 29, identifier:isinstance; 30, argument_list; 30, 31; 30, 32; 31, identifier:data; 32, attribute; 32, 33; 32, 34; 33, identifier:np; 34, identifier:ndarray; 35, comparison_operator:==; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:data; 39, identifier:dtype; 40, identifier:kind; 41, string:'O'; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:needs_iteration; 46, True; 47, else_clause; 47, 48; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:needs_iteration; 52, False; 53, if_statement; 53, 54; 53, 55; 53, 134; 54, identifier:needs_iteration; 55, block; 55, 56; 55, 60; 55, 64; 55, 71; 55, 78; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:SEP; 59, string:b'SEP'; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:iter_prefix; 63, string:b'ITER'; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:iter_; 67, call; 67, 68; 67, 69; 68, identifier:iter; 69, argument_list; 69, 70; 70, identifier:data; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:hasher; 75, identifier:update; 76, argument_list; 76, 77; 77, identifier:iter_prefix; 78, try_statement; 78, 79; 78, 108; 79, block; 79, 80; 80, for_statement; 80, 81; 80, 82; 80, 83; 81, identifier:item; 82, identifier:iter_; 83, block; 83, 84; 83, 93; 83, 101; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, pattern_list; 86, 87; 86, 88; 87, identifier:prefix; 88, identifier:hashable; 89, call; 89, 90; 89, 91; 90, identifier:_covert_to_hashable; 91, argument_list; 91, 92; 92, identifier:data; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:binary_data; 96, binary_operator:+; 96, 97; 96, 100; 97, binary_operator:+; 97, 98; 97, 99; 98, identifier:SEP; 99, identifier:prefix; 100, identifier:hashable; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:hasher; 105, identifier:update; 106, argument_list; 106, 107; 107, identifier:binary_data; 108, except_clause; 108, 109; 108, 110; 109, identifier:TypeError; 110, block; 110, 111; 110, 117; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:_update_hasher; 114, argument_list; 114, 115; 114, 116; 115, identifier:hasher; 116, identifier:item; 117, for_statement; 117, 118; 117, 119; 117, 120; 118, identifier:item; 119, identifier:iter_; 120, block; 120, 121; 120, 128; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:hasher; 125, identifier:update; 126, argument_list; 126, 127; 127, identifier:SEP; 128, expression_statement; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:_update_hasher; 131, argument_list; 131, 132; 131, 133; 132, identifier:hasher; 133, identifier:item; 134, else_clause; 134, 135; 135, block; 135, 136; 135, 145; 135, 151; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 141; 138, pattern_list; 138, 139; 138, 140; 139, identifier:prefix; 140, identifier:hashable; 141, call; 141, 142; 141, 143; 142, identifier:_covert_to_hashable; 143, argument_list; 143, 144; 144, identifier:data; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:binary_data; 148, binary_operator:+; 148, 149; 148, 150; 149, identifier:prefix; 150, identifier:hashable; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:hasher; 155, identifier:update; 156, argument_list; 156, 157; 157, identifier:binary_data | def _update_hasher(hasher, data):
if isinstance(data, (tuple, list, zip)):
needs_iteration = True
elif (util_type.HAVE_NUMPY and isinstance(data, np.ndarray) and
data.dtype.kind == 'O'):
needs_iteration = True
else:
needs_iteration = False
if needs_iteration:
SEP = b'SEP'
iter_prefix = b'ITER'
iter_ = iter(data)
hasher.update(iter_prefix)
try:
for item in iter_:
prefix, hashable = _covert_to_hashable(data)
binary_data = SEP + prefix + hashable
hasher.update(binary_data)
except TypeError:
_update_hasher(hasher, item)
for item in iter_:
hasher.update(SEP)
_update_hasher(hasher, item)
else:
prefix, hashable = _covert_to_hashable(data)
binary_data = prefix + hashable
hasher.update(binary_data) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:hash_data; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:data; 5, default_parameter; 5, 6; 5, 7; 6, identifier:hashlen; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:alphabet; 10, None; 11, block; 11, 12; 11, 14; 11, 23; 11, 32; 12, expression_statement; 12, 13; 13, identifier:r; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:is; 15, 16; 15, 17; 16, identifier:alphabet; 17, None; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:alphabet; 22, identifier:ALPHABET_27; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:hashlen; 26, None; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:hashlen; 31, identifier:HASH_LEN2; 32, if_statement; 32, 33; 32, 45; 32, 55; 33, boolean_operator:and; 33, 34; 33, 39; 34, call; 34, 35; 34, 36; 35, identifier:isinstance; 36, argument_list; 36, 37; 36, 38; 37, identifier:data; 38, identifier:stringlike; 39, comparison_operator:==; 39, 40; 39, 44; 40, call; 40, 41; 40, 42; 41, identifier:len; 42, argument_list; 42, 43; 43, identifier:data; 44, integer:0; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:text; 49, parenthesized_expression; 49, 50; 50, binary_operator:*; 50, 51; 50, 54; 51, subscript; 51, 52; 51, 53; 52, identifier:alphabet; 53, integer:0; 54, identifier:hashlen; 55, else_clause; 55, 56; 56, block; 56, 57; 56, 65; 56, 71; 56, 79; 56, 93; 56, 101; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:hasher; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:hashlib; 63, identifier:sha512; 64, argument_list; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:_update_hasher; 68, argument_list; 68, 69; 68, 70; 69, identifier:hasher; 70, identifier:data; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:text; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:hasher; 77, identifier:hexdigest; 78, argument_list; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:hashstr2; 82, call; 82, 83; 82, 84; 83, identifier:convert_hexstr_to_bigbase; 84, argument_list; 84, 85; 84, 86; 84, 87; 85, identifier:text; 86, identifier:alphabet; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:bigbase; 89, call; 89, 90; 89, 91; 90, identifier:len; 91, argument_list; 91, 92; 92, identifier:alphabet; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:text; 96, subscript; 96, 97; 96, 98; 97, identifier:hashstr2; 98, slice; 98, 99; 98, 100; 99, colon; 100, identifier:hashlen; 101, return_statement; 101, 102; 102, identifier:text | def hash_data(data, hashlen=None, alphabet=None):
r
if alphabet is None:
alphabet = ALPHABET_27
if hashlen is None:
hashlen = HASH_LEN2
if isinstance(data, stringlike) and len(data) == 0:
text = (alphabet[0] * hashlen)
else:
hasher = hashlib.sha512()
_update_hasher(hasher, data)
text = hasher.hexdigest()
hashstr2 = convert_hexstr_to_bigbase(text, alphabet, bigbase=len(alphabet))
text = hashstr2[:hashlen]
return text |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:quick_search; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:name; 6, default_parameter; 6, 7; 6, 8; 7, identifier:platform; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort_by; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:desc; 14, True; 15, block; 15, 16; 15, 42; 15, 49; 15, 90; 15, 99; 16, if_statement; 16, 17; 16, 20; 16, 30; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:platform; 19, None; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:query_filter; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, string:"name:{0}"; 27, identifier:format; 28, argument_list; 28, 29; 29, identifier:name; 30, else_clause; 30, 31; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:query_filter; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, string:"name:{0},platforms:{1}"; 38, identifier:format; 39, argument_list; 39, 40; 39, 41; 40, identifier:name; 41, identifier:platform; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:search_params; 45, dictionary; 45, 46; 46, pair; 46, 47; 46, 48; 47, string:"filter"; 48, identifier:query_filter; 49, if_statement; 49, 50; 49, 53; 50, comparison_operator:is; 50, 51; 50, 52; 51, identifier:sort_by; 52, None; 53, block; 53, 54; 53, 61; 53, 78; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_validate_sort_field; 59, argument_list; 59, 60; 60, identifier:sort_by; 61, if_statement; 61, 62; 61, 63; 61, 70; 62, identifier:desc; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:direction; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:SORT_ORDER_DESCENDING; 70, else_clause; 70, 71; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:direction; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:SORT_ORDER_ASCENDING; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, subscript; 80, 81; 80, 82; 81, identifier:search_params; 82, string:"sort"; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, string:"{0}:{1}"; 86, identifier:format; 87, argument_list; 87, 88; 87, 89; 88, identifier:sort_by; 89, identifier:direction; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:response; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:_query; 97, argument_list; 97, 98; 98, identifier:search_params; 99, return_statement; 99, 100; 100, identifier:response | def quick_search(self, name, platform=None, sort_by=None, desc=True):
if platform is None:
query_filter = "name:{0}".format(name)
else:
query_filter = "name:{0},platforms:{1}".format(name, platform)
search_params = {"filter": query_filter}
if sort_by is not None:
self._validate_sort_field(sort_by)
if desc:
direction = self.SORT_ORDER_DESCENDING
else:
direction = self.SORT_ORDER_ASCENDING
search_params["sort"] = "{0}:{1}".format(sort_by, direction)
response = self._query(search_params)
return response |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:smart_cast; 3, parameters; 3, 4; 3, 5; 4, identifier:var; 5, identifier:type_; 6, block; 6, 7; 6, 18; 6, 36; 6, 151; 7, if_statement; 7, 8; 7, 15; 8, boolean_operator:or; 8, 9; 8, 12; 9, comparison_operator:is; 9, 10; 9, 11; 10, identifier:type_; 11, None; 12, comparison_operator:is; 12, 13; 12, 14; 13, identifier:var; 14, None; 15, block; 15, 16; 16, return_statement; 16, 17; 17, identifier:var; 18, try_statement; 18, 19; 18, 32; 19, block; 19, 20; 20, if_statement; 20, 21; 20, 29; 21, call; 21, 22; 21, 23; 22, identifier:issubclass; 23, argument_list; 23, 24; 23, 25; 24, identifier:type_; 25, call; 25, 26; 25, 27; 26, identifier:type; 27, argument_list; 27, 28; 28, None; 29, block; 29, 30; 30, return_statement; 30, 31; 31, identifier:var; 32, except_clause; 32, 33; 32, 34; 33, identifier:TypeError; 34, block; 34, 35; 35, pass_statement; 36, if_statement; 36, 37; 36, 41; 37, call; 37, 38; 37, 39; 38, identifier:is_str; 39, argument_list; 39, 40; 40, identifier:var; 41, block; 41, 42; 42, if_statement; 42, 43; 42, 46; 42, 52; 42, 87; 42, 110; 43, comparison_operator:in; 43, 44; 43, 45; 44, identifier:type_; 45, identifier:VALID_BOOL_TYPES; 46, block; 46, 47; 47, return_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:bool_from_str; 50, argument_list; 50, 51; 51, identifier:var; 52, elif_clause; 52, 53; 52, 56; 53, comparison_operator:is; 53, 54; 53, 55; 54, identifier:type_; 55, identifier:slice; 56, block; 56, 57; 56, 81; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:args; 60, list_comprehension; 60, 61; 60, 73; 61, conditional_expression:if; 61, 62; 61, 63; 61, 69; 62, None; 63, comparison_operator:==; 63, 64; 63, 68; 64, call; 64, 65; 64, 66; 65, identifier:len; 66, argument_list; 66, 67; 67, identifier:arg; 68, integer:0; 69, call; 69, 70; 69, 71; 70, identifier:int; 71, argument_list; 71, 72; 72, identifier:arg; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:arg; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:var; 78, identifier:split; 79, argument_list; 79, 80; 80, string:':'; 81, return_statement; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:slice; 84, argument_list; 84, 85; 85, list_splat; 85, 86; 86, identifier:args; 87, elif_clause; 87, 88; 87, 91; 88, comparison_operator:is; 88, 89; 88, 90; 89, identifier:type_; 90, identifier:list; 91, block; 91, 92; 91, 101; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:subvar_list; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:var; 98, identifier:split; 99, argument_list; 99, 100; 100, string:','; 101, return_statement; 101, 102; 102, list_comprehension; 102, 103; 102, 107; 103, call; 103, 104; 103, 105; 104, identifier:smart_cast2; 105, argument_list; 105, 106; 106, identifier:subvar; 107, for_in_clause; 107, 108; 107, 109; 108, identifier:subvar; 109, identifier:subvar_list; 110, elif_clause; 110, 111; 110, 118; 111, call; 111, 112; 111, 113; 112, identifier:isinstance; 113, argument_list; 113, 114; 113, 115; 114, identifier:type_; 115, attribute; 115, 116; 115, 117; 116, identifier:six; 117, identifier:string_types; 118, block; 118, 119; 118, 129; 119, if_statement; 119, 120; 119, 123; 120, comparison_operator:==; 120, 121; 120, 122; 121, identifier:type_; 122, string:'fuzzy_subset'; 123, block; 123, 124; 124, return_statement; 124, 125; 125, call; 125, 126; 125, 127; 126, identifier:fuzzy_subset; 127, argument_list; 127, 128; 128, identifier:var; 129, if_statement; 129, 130; 129, 133; 129, 141; 130, comparison_operator:==; 130, 131; 130, 132; 131, identifier:type_; 132, string:'eval'; 133, block; 133, 134; 134, return_statement; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:eval; 137, argument_list; 137, 138; 137, 139; 137, 140; 138, identifier:var; 139, dictionary; 140, dictionary; 141, else_clause; 141, 142; 142, block; 142, 143; 143, raise_statement; 143, 144; 144, call; 144, 145; 144, 146; 145, identifier:NotImplementedError; 146, argument_list; 146, 147; 147, binary_operator:%; 147, 148; 147, 149; 148, string:'Uknown smart type_=%r'; 149, tuple; 149, 150; 150, identifier:type_; 151, return_statement; 151, 152; 152, call; 152, 153; 152, 154; 153, identifier:type_; 154, argument_list; 154, 155; 155, identifier:var | def smart_cast(var, type_):
if type_ is None or var is None:
return var
try:
if issubclass(type_, type(None)):
return var
except TypeError:
pass
if is_str(var):
if type_ in VALID_BOOL_TYPES:
return bool_from_str(var)
elif type_ is slice:
args = [None if len(arg) == 0 else int(arg) for arg in var.split(':')]
return slice(*args)
elif type_ is list:
subvar_list = var.split(',')
return [smart_cast2(subvar) for subvar in subvar_list]
elif isinstance(type_, six.string_types):
if type_ == 'fuzzy_subset':
return fuzzy_subset(var)
if type_ == 'eval':
return eval(var, {}, {})
else:
raise NotImplementedError('Uknown smart type_=%r' % (type_,))
return type_(var) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:dump_autogen_code; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:fpath; 5, identifier:autogen_text; 6, default_parameter; 6, 7; 6, 8; 7, identifier:codetype; 8, string:'python'; 9, default_parameter; 9, 10; 9, 11; 10, identifier:fullprint; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:show_diff; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:dowrite; 17, None; 18, block; 18, 19; 18, 24; 18, 40; 18, 54; 18, 69; 18, 77; 18, 92; 18, 101; 18, 115; 18, 123; 18, 165; 19, import_statement; 19, 20; 20, aliased_import; 20, 21; 20, 23; 21, dotted_name; 21, 22; 22, identifier:utool; 23, identifier:ut; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:dowrite; 27, None; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:dowrite; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:ut; 35, identifier:get_argflag; 36, argument_list; 36, 37; 37, tuple; 37, 38; 37, 39; 38, string:'-w'; 39, string:'--write'; 40, if_statement; 40, 41; 40, 44; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:show_diff; 43, None; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:show_diff; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:ut; 51, identifier:get_argflag; 52, argument_list; 52, 53; 53, string:'--diff'; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:num_context_lines; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:ut; 60, identifier:get_argval; 61, argument_list; 61, 62; 61, 63; 61, 66; 62, string:'--diff'; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:type_; 65, identifier:int; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:default; 68, None; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:show_diff; 72, boolean_operator:or; 72, 73; 72, 74; 73, identifier:show_diff; 74, comparison_operator:is; 74, 75; 74, 76; 75, identifier:num_context_lines; 76, None; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:num_context_lines; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:ut; 83, identifier:get_argval; 84, argument_list; 84, 85; 84, 86; 84, 89; 85, string:'--diff'; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:type_; 88, identifier:int; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:default; 91, None; 92, if_statement; 92, 93; 92, 96; 93, comparison_operator:is; 93, 94; 93, 95; 94, identifier:fullprint; 95, None; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:fullprint; 100, True; 101, if_statement; 101, 102; 101, 105; 102, comparison_operator:is; 102, 103; 102, 104; 103, identifier:fullprint; 104, False; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:fullprint; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:ut; 112, identifier:get_argflag; 113, argument_list; 113, 114; 114, string:'--print'; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:print; 118, argument_list; 118, 119; 119, binary_operator:%; 119, 120; 119, 121; 120, string:'[autogen] Autogenerated %s...\n+---\n'; 121, tuple; 121, 122; 122, identifier:fpath; 123, if_statement; 123, 124; 123, 126; 124, not_operator; 124, 125; 125, identifier:dowrite; 126, block; 126, 127; 126, 153; 126, 158; 127, if_statement; 127, 128; 127, 129; 127, 145; 128, identifier:fullprint; 129, block; 129, 130; 129, 140; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:ut; 134, identifier:print_code; 135, argument_list; 135, 136; 135, 137; 136, identifier:autogen_text; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:lexer_name; 139, identifier:codetype; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 143; 142, identifier:print; 143, argument_list; 143, 144; 144, string:'\nL___'; 145, else_clause; 145, 146; 146, block; 146, 147; 146, 152; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 150; 149, identifier:print; 150, argument_list; 150, 151; 151, string:'specify --print to write to stdout'; 152, pass_statement; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 156; 155, identifier:print; 156, argument_list; 156, 157; 157, string:'specify -w to write, or --diff to compare'; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 161; 160, identifier:print; 161, argument_list; 161, 162; 162, binary_operator:%; 162, 163; 162, 164; 163, string:'...would write to: %s'; 164, identifier:fpath; 165, if_statement; 165, 166; 165, 167; 165, 247; 166, identifier:show_diff; 167, block; 167, 168; 167, 239; 168, if_statement; 168, 169; 168, 178; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:ut; 172, identifier:checkpath; 173, argument_list; 173, 174; 173, 175; 174, identifier:fpath; 175, keyword_argument; 175, 176; 175, 177; 176, identifier:verbose; 177, True; 178, block; 178, 179; 178, 188; 178, 201; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:prev_text; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:ut; 185, identifier:read_from; 186, argument_list; 186, 187; 187, identifier:fpath; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:textdiff; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:ut; 194, identifier:get_textdiff; 195, argument_list; 195, 196; 195, 197; 195, 198; 196, identifier:prev_text; 197, identifier:autogen_text; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:num_context_lines; 200, identifier:num_context_lines; 201, try_statement; 201, 202; 201, 210; 202, block; 202, 203; 203, expression_statement; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:ut; 207, identifier:print_difftext; 208, argument_list; 208, 209; 209, identifier:textdiff; 210, except_clause; 210, 211; 210, 212; 211, identifier:UnicodeDecodeError; 212, block; 212, 213; 212, 216; 212, 232; 213, import_statement; 213, 214; 214, dotted_name; 214, 215; 215, identifier:unicodedata; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:textdiff; 219, call; 219, 220; 219, 229; 220, attribute; 220, 221; 220, 228; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:unicodedata; 224, identifier:normalize; 225, argument_list; 225, 226; 225, 227; 226, string:'NFKD'; 227, identifier:textdiff; 228, identifier:encode; 229, argument_list; 229, 230; 229, 231; 230, string:'ascii'; 231, string:'ignore'; 232, expression_statement; 232, 233; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:ut; 236, identifier:print_difftext; 237, argument_list; 237, 238; 238, identifier:textdiff; 239, if_statement; 239, 240; 239, 241; 240, identifier:dowrite; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 245; 244, identifier:print; 245, argument_list; 245, 246; 246, string:'WARNING: Not writing. Remove --diff from command line'; 247, elif_clause; 247, 248; 247, 249; 248, identifier:dowrite; 249, block; 249, 250; 250, expression_statement; 250, 251; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:ut; 254, identifier:write_to; 255, argument_list; 255, 256; 255, 257; 256, identifier:fpath; 257, identifier:autogen_text | def dump_autogen_code(fpath, autogen_text, codetype='python', fullprint=None,
show_diff=None, dowrite=None):
import utool as ut
if dowrite is None:
dowrite = ut.get_argflag(('-w', '--write'))
if show_diff is None:
show_diff = ut.get_argflag('--diff')
num_context_lines = ut.get_argval('--diff', type_=int, default=None)
show_diff = show_diff or num_context_lines is not None
num_context_lines = ut.get_argval('--diff', type_=int, default=None)
if fullprint is None:
fullprint = True
if fullprint is False:
fullprint = ut.get_argflag('--print')
print('[autogen] Autogenerated %s...\n+---\n' % (fpath,))
if not dowrite:
if fullprint:
ut.print_code(autogen_text, lexer_name=codetype)
print('\nL___')
else:
print('specify --print to write to stdout')
pass
print('specify -w to write, or --diff to compare')
print('...would write to: %s' % fpath)
if show_diff:
if ut.checkpath(fpath, verbose=True):
prev_text = ut.read_from(fpath)
textdiff = ut.get_textdiff(prev_text, autogen_text,
num_context_lines=num_context_lines)
try:
ut.print_difftext(textdiff)
except UnicodeDecodeError:
import unicodedata
textdiff = unicodedata.normalize('NFKD', textdiff).encode('ascii', 'ignore')
ut.print_difftext(textdiff)
if dowrite:
print('WARNING: Not writing. Remove --diff from command line')
elif dowrite:
ut.write_to(fpath, autogen_text) |
0, module; 0, 1; 0, 356; 0, 361; 0, 370; 0, 381; 0, 390; 0, 400; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:make_default_docstr; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:func; 5, default_parameter; 5, 6; 5, 7; 6, identifier:with_args; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:with_ret; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:with_commandline; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:with_example; 16, True; 17, default_parameter; 17, 18; 17, 19; 18, identifier:with_header; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:with_debug; 22, False; 23, block; 23, 24; 23, 26; 23, 31; 23, 42; 23, 48; 23, 54; 23, 60; 23, 66; 23, 72; 23, 78; 23, 84; 23, 90; 23, 96; 23, 102; 23, 108; 23, 114; 23, 120; 23, 126; 23, 132; 23, 138; 23, 144; 23, 148; 23, 162; 23, 204; 23, 240; 23, 270; 23, 315; 23, 353; 24, expression_statement; 24, 25; 25, identifier:r; 26, import_statement; 26, 27; 27, aliased_import; 27, 28; 27, 30; 28, dotted_name; 28, 29; 29, identifier:utool; 30, identifier:ut; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:funcinfo; 34, call; 34, 35; 34, 40; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:ut; 38, identifier:util_inspect; 39, identifier:infer_function_info; 40, argument_list; 40, 41; 41, identifier:func; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:argname_list; 45, attribute; 45, 46; 45, 47; 46, identifier:funcinfo; 47, identifier:argname_list; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:argtype_list; 51, attribute; 51, 52; 51, 53; 52, identifier:funcinfo; 53, identifier:argtype_list; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:argdesc_list; 57, attribute; 57, 58; 57, 59; 58, identifier:funcinfo; 59, identifier:argdesc_list; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:return_header; 63, attribute; 63, 64; 63, 65; 64, identifier:funcinfo; 65, identifier:return_header; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:return_type; 69, attribute; 69, 70; 69, 71; 70, identifier:funcinfo; 71, identifier:return_type; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:return_name; 75, attribute; 75, 76; 75, 77; 76, identifier:funcinfo; 77, identifier:return_name; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:return_desc; 81, attribute; 81, 82; 81, 83; 82, identifier:funcinfo; 83, identifier:return_desc; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:funcname; 87, attribute; 87, 88; 87, 89; 88, identifier:funcinfo; 89, identifier:funcname; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:modname; 93, attribute; 93, 94; 93, 95; 94, identifier:funcinfo; 95, identifier:modname; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:defaults; 99, attribute; 99, 100; 99, 101; 100, identifier:funcinfo; 101, identifier:defaults; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:num_indent; 105, attribute; 105, 106; 105, 107; 106, identifier:funcinfo; 107, identifier:num_indent; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:needs_surround; 111, attribute; 111, 112; 111, 113; 112, identifier:funcinfo; 113, identifier:needs_surround; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:funcname; 117, attribute; 117, 118; 117, 119; 118, identifier:funcinfo; 119, identifier:funcname; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:ismethod; 123, attribute; 123, 124; 123, 125; 124, identifier:funcinfo; 125, identifier:ismethod; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:va_name; 129, attribute; 129, 130; 129, 131; 130, identifier:funcinfo; 131, identifier:va_name; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:kw_name; 135, attribute; 135, 136; 135, 137; 136, identifier:funcinfo; 137, identifier:kw_name; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:kw_keys; 141, attribute; 141, 142; 141, 143; 142, identifier:funcinfo; 143, identifier:kw_keys; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:docstr_parts; 147, list:[]; 148, if_statement; 148, 149; 148, 150; 149, identifier:with_header; 150, block; 150, 151; 150, 155; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:header_block; 154, identifier:funcname; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:docstr_parts; 159, identifier:append; 160, argument_list; 160, 161; 161, identifier:header_block; 162, if_statement; 162, 163; 162, 171; 163, boolean_operator:and; 163, 164; 163, 165; 164, identifier:with_args; 165, comparison_operator:>; 165, 166; 165, 170; 166, call; 166, 167; 166, 168; 167, identifier:len; 168, argument_list; 168, 169; 169, identifier:argname_list; 170, integer:0; 171, block; 171, 172; 171, 176; 171, 189; 171, 197; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:argheader; 175, string:'Args'; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:arg_docstr; 179, call; 179, 180; 179, 181; 180, identifier:make_args_docstr; 181, argument_list; 181, 182; 181, 183; 181, 184; 181, 185; 181, 186; 181, 187; 181, 188; 182, identifier:argname_list; 183, identifier:argtype_list; 184, identifier:argdesc_list; 185, identifier:ismethod; 186, identifier:va_name; 187, identifier:kw_name; 188, identifier:kw_keys; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:argsblock; 192, call; 192, 193; 192, 194; 193, identifier:make_docstr_block; 194, argument_list; 194, 195; 194, 196; 195, identifier:argheader; 196, identifier:arg_docstr; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:docstr_parts; 201, identifier:append; 202, argument_list; 202, 203; 203, identifier:argsblock; 204, if_statement; 204, 205; 204, 210; 205, boolean_operator:and; 205, 206; 205, 207; 206, identifier:with_ret; 207, comparison_operator:is; 207, 208; 207, 209; 208, identifier:return_header; 209, None; 210, block; 210, 211; 211, if_statement; 211, 212; 211, 215; 212, comparison_operator:is; 212, 213; 212, 214; 213, identifier:return_header; 214, None; 215, block; 215, 216; 215, 225; 215, 233; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:return_doctr; 219, call; 219, 220; 219, 221; 220, identifier:make_returns_or_yeilds_docstr; 221, argument_list; 221, 222; 221, 223; 221, 224; 222, identifier:return_type; 223, identifier:return_name; 224, identifier:return_desc; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:returnblock; 228, call; 228, 229; 228, 230; 229, identifier:make_docstr_block; 230, argument_list; 230, 231; 230, 232; 231, identifier:return_header; 232, identifier:return_doctr; 233, expression_statement; 233, 234; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:docstr_parts; 237, identifier:append; 238, argument_list; 238, 239; 239, identifier:returnblock; 240, if_statement; 240, 241; 240, 242; 241, identifier:with_commandline; 242, block; 242, 243; 242, 247; 242, 255; 242, 263; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:cmdlineheader; 246, string:'CommandLine'; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:cmdlinecode; 250, call; 250, 251; 250, 252; 251, identifier:make_cmdline_docstr; 252, argument_list; 252, 253; 252, 254; 253, identifier:funcname; 254, identifier:modname; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:cmdlineblock; 258, call; 258, 259; 258, 260; 259, identifier:make_docstr_block; 260, argument_list; 260, 261; 260, 262; 261, identifier:cmdlineheader; 262, identifier:cmdlinecode; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:docstr_parts; 267, identifier:append; 268, argument_list; 268, 269; 269, identifier:cmdlineblock; 270, if_statement; 270, 271; 270, 272; 271, identifier:with_example; 272, block; 272, 273; 272, 277; 272, 290; 272, 300; 272, 308; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:exampleheader; 276, string:'Example'; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:examplecode; 280, call; 280, 281; 280, 282; 281, identifier:make_example_docstr; 282, argument_list; 282, 283; 282, 284; 282, 285; 282, 286; 282, 287; 282, 288; 282, 289; 283, identifier:funcname; 284, identifier:modname; 285, identifier:argname_list; 286, identifier:defaults; 287, identifier:return_type; 288, identifier:return_name; 289, identifier:ismethod; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:examplecode_; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:ut; 296, identifier:indent; 297, argument_list; 297, 298; 297, 299; 298, identifier:examplecode; 299, string:'>>> '; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:exampleblock; 303, call; 303, 304; 303, 305; 304, identifier:make_docstr_block; 305, argument_list; 305, 306; 305, 307; 306, identifier:exampleheader; 307, identifier:examplecode_; 308, expression_statement; 308, 309; 309, call; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:docstr_parts; 312, identifier:append; 313, argument_list; 313, 314; 314, identifier:exampleblock; 315, if_statement; 315, 316; 315, 317; 316, identifier:with_debug; 317, block; 317, 318; 317, 322; 317, 338; 317, 346; 318, expression_statement; 318, 319; 319, assignment; 319, 320; 319, 321; 320, identifier:debugheader; 321, string:'Debug'; 322, expression_statement; 322, 323; 323, assignment; 323, 324; 323, 325; 324, identifier:debugblock; 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:ut; 330, identifier:codeblock; 331, argument_list; 331, 332; 332, string:'''
num_indent = {num_indent}
'''; 333, identifier:format; 334, argument_list; 334, 335; 335, keyword_argument; 335, 336; 335, 337; 336, identifier:num_indent; 337, identifier:num_indent; 338, expression_statement; 338, 339; 339, assignment; 339, 340; 339, 341; 340, identifier:debugblock; 341, call; 341, 342; 341, 343; 342, identifier:make_docstr_block; 343, argument_list; 343, 344; 343, 345; 344, identifier:debugheader; 345, identifier:debugblock; 346, expression_statement; 346, 347; 347, call; 347, 348; 347, 351; 348, attribute; 348, 349; 348, 350; 349, identifier:docstr_parts; 350, identifier:append; 351, argument_list; 351, 352; 352, identifier:debugblock; 353, if_statement; 353, 354; 353, 355; 354, identifier:needs_surround; 355, block:; 356, expression_statement; 356, 357; 357, assignment; 357, 358; 357, 359; 358, identifier:docstr_parts; 359, list:['r']; 359, 360; 360, string:'r'; 361, expression_statement; 361, 362; 362, assignment; 362, 363; 362, 364; 363, identifier:default_docstr; 364, call; 364, 365; 364, 368; 365, attribute; 365, 366; 365, 367; 366, string:'\n'; 367, identifier:join; 368, argument_list; 368, 369; 369, identifier:docstr_parts; 370, expression_statement; 370, 371; 371, assignment; 371, 372; 371, 373; 371, 375; 372, identifier:else; 373, type; 373, 374; 374, identifier:default_docstr; 375, call; 375, 376; 375, 379; 376, attribute; 376, 377; 376, 378; 377, string:'\n\n'; 378, identifier:join; 379, argument_list; 379, 380; 380, identifier:docstr_parts; 381, expression_statement; 381, 382; 382, assignment; 382, 383; 382, 384; 383, identifier:docstr_indent; 384, binary_operator:*; 384, 385; 384, 386; 385, string:' '; 386, parenthesized_expression; 386, 387; 387, binary_operator:+; 387, 388; 387, 389; 388, identifier:num_indent; 389, integer:4; 390, expression_statement; 390, 391; 391, assignment; 391, 392; 391, 393; 392, identifier:default_docstr; 393, call; 393, 394; 393, 397; 394, attribute; 394, 395; 394, 396; 395, identifier:ut; 396, identifier:indent; 397, argument_list; 397, 398; 397, 399; 398, identifier:default_docstr; 399, identifier:docstr_indent; 400, return_statement; 400, 401; 401, identifier:default_docstr | def make_default_docstr(func, with_args=True, with_ret=True,
with_commandline=True, with_example=True,
with_header=False, with_debug=False):
r
import utool as ut
funcinfo = ut.util_inspect.infer_function_info(func)
argname_list = funcinfo.argname_list
argtype_list = funcinfo.argtype_list
argdesc_list = funcinfo.argdesc_list
return_header = funcinfo.return_header
return_type = funcinfo.return_type
return_name = funcinfo.return_name
return_desc = funcinfo.return_desc
funcname = funcinfo.funcname
modname = funcinfo.modname
defaults = funcinfo.defaults
num_indent = funcinfo.num_indent
needs_surround = funcinfo.needs_surround
funcname = funcinfo.funcname
ismethod = funcinfo.ismethod
va_name = funcinfo.va_name
kw_name = funcinfo.kw_name
kw_keys = funcinfo.kw_keys
docstr_parts = []
if with_header:
header_block = funcname
docstr_parts.append(header_block)
if with_args and len(argname_list) > 0:
argheader = 'Args'
arg_docstr = make_args_docstr(argname_list, argtype_list, argdesc_list,
ismethod, va_name, kw_name, kw_keys)
argsblock = make_docstr_block(argheader, arg_docstr)
docstr_parts.append(argsblock)
if with_ret and return_header is not None:
if return_header is not None:
return_doctr = make_returns_or_yeilds_docstr(return_type, return_name, return_desc)
returnblock = make_docstr_block(return_header, return_doctr)
docstr_parts.append(returnblock)
if with_commandline:
cmdlineheader = 'CommandLine'
cmdlinecode = make_cmdline_docstr(funcname, modname)
cmdlineblock = make_docstr_block(cmdlineheader, cmdlinecode)
docstr_parts.append(cmdlineblock)
if with_example:
exampleheader = 'Example'
examplecode = make_example_docstr(funcname, modname, argname_list,
defaults, return_type, return_name,
ismethod)
examplecode_ = ut.indent(examplecode, '>>> ')
exampleblock = make_docstr_block(exampleheader, examplecode_)
docstr_parts.append(exampleblock)
if with_debug:
debugheader = 'Debug'
debugblock = ut.codeblock(
'''
num_indent = {num_indent}
'''
).format(num_indent=num_indent)
debugblock = make_docstr_block(debugheader, debugblock)
docstr_parts.append(debugblock)
if needs_surround:
docstr_parts = ['r']
default_docstr = '\n'.join(docstr_parts)
else:
default_docstr = '\n\n'.join(docstr_parts)
docstr_indent = ' ' * (num_indent + 4)
default_docstr = ut.indent(default_docstr, docstr_indent)
return default_docstr |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:sort_protein_group; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:pgroup; 5, identifier:sortfunctions; 6, identifier:sortfunc_index; 7, block; 7, 8; 7, 12; 7, 21; 7, 25; 7, 65; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:pgroup_out; 11, list:[]; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:subgroups; 15, call; 15, 16; 15, 19; 16, subscript; 16, 17; 16, 18; 17, identifier:sortfunctions; 18, identifier:sortfunc_index; 19, argument_list; 19, 20; 20, identifier:pgroup; 21, expression_statement; 21, 22; 22, augmented_assignment:+=; 22, 23; 22, 24; 23, identifier:sortfunc_index; 24, integer:1; 25, for_statement; 25, 26; 25, 27; 25, 28; 26, identifier:subgroup; 27, identifier:subgroups; 28, block; 28, 29; 29, if_statement; 29, 30; 29, 43; 29, 56; 30, boolean_operator:and; 30, 31; 30, 37; 31, comparison_operator:>; 31, 32; 31, 36; 32, call; 32, 33; 32, 34; 33, identifier:len; 34, argument_list; 34, 35; 35, identifier:subgroup; 36, integer:1; 37, comparison_operator:<; 37, 38; 37, 39; 38, identifier:sortfunc_index; 39, call; 39, 40; 39, 41; 40, identifier:len; 41, argument_list; 41, 42; 42, identifier:sortfunctions; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:pgroup_out; 48, identifier:extend; 49, argument_list; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:sort_protein_group; 52, argument_list; 52, 53; 52, 54; 52, 55; 53, identifier:subgroup; 54, identifier:sortfunctions; 55, identifier:sortfunc_index; 56, else_clause; 56, 57; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:pgroup_out; 62, identifier:extend; 63, argument_list; 63, 64; 64, identifier:subgroup; 65, return_statement; 65, 66; 66, identifier:pgroup_out | def sort_protein_group(pgroup, sortfunctions, sortfunc_index):
pgroup_out = []
subgroups = sortfunctions[sortfunc_index](pgroup)
sortfunc_index += 1
for subgroup in subgroups:
if len(subgroup) > 1 and sortfunc_index < len(sortfunctions):
pgroup_out.extend(sort_protein_group(subgroup,
sortfunctions,
sortfunc_index))
else:
pgroup_out.extend(subgroup)
return pgroup_out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_amounts; 3, parameters; 3, 4; 3, 5; 4, identifier:proteins; 5, identifier:sort_index; 6, block; 6, 7; 6, 11; 6, 42; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:amounts; 10, dictionary; 11, for_statement; 11, 12; 11, 13; 11, 14; 12, identifier:protein; 13, identifier:proteins; 14, block; 14, 15; 14, 21; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:amount_x_for_protein; 18, subscript; 18, 19; 18, 20; 19, identifier:protein; 20, identifier:sort_index; 21, try_statement; 21, 22; 21, 32; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, subscript; 26, 27; 26, 28; 27, identifier:amounts; 28, identifier:amount_x_for_protein; 29, identifier:append; 30, argument_list; 30, 31; 31, identifier:protein; 32, except_clause; 32, 33; 32, 34; 33, identifier:KeyError; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:amounts; 39, identifier:amount_x_for_protein; 40, list:[protein]; 40, 41; 41, identifier:protein; 42, return_statement; 42, 43; 43, list_comprehension; 43, 44; 43, 45; 44, identifier:v; 45, for_in_clause; 45, 46; 45, 49; 46, pattern_list; 46, 47; 46, 48; 47, identifier:k; 48, identifier:v; 49, call; 49, 50; 49, 51; 50, identifier:sorted; 51, argument_list; 51, 52; 51, 57; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:amounts; 55, identifier:items; 56, argument_list; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:reverse; 59, True | def sort_amounts(proteins, sort_index):
amounts = {}
for protein in proteins:
amount_x_for_protein = protein[sort_index]
try:
amounts[amount_x_for_protein].append(protein)
except KeyError:
amounts[amount_x_for_protein] = [protein]
return [v for k, v in sorted(amounts.items(), reverse=True)] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:compare_groups; 3, parameters; 3, 4; 3, 5; 4, identifier:true_groups; 5, identifier:pred_groups; 6, block; 6, 7; 6, 9; 6, 14; 6, 25; 6, 36; 6, 45; 6, 54; 6, 63; 6, 79; 6, 95; 6, 99; 6, 103; 6, 151; 6, 155; 6, 159; 6, 207; 6, 216; 6, 225; 6, 246; 6, 267; 6, 292; 7, expression_statement; 7, 8; 8, identifier:r; 9, import_statement; 9, 10; 10, aliased_import; 10, 11; 10, 13; 11, dotted_name; 11, 12; 12, identifier:utool; 13, identifier:ut; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:true; 17, set_comprehension; 17, 18; 17, 22; 18, call; 18, 19; 18, 20; 19, identifier:frozenset; 20, argument_list; 20, 21; 21, identifier:_group; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:_group; 24, identifier:true_groups; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:pred; 28, set_comprehension; 28, 29; 28, 33; 29, call; 29, 30; 29, 31; 30, identifier:frozenset; 31, argument_list; 31, 32; 32, identifier:_group; 33, for_in_clause; 33, 34; 33, 35; 34, identifier:_group; 35, identifier:pred_groups; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:common; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:true; 42, identifier:intersection; 43, argument_list; 43, 44; 44, identifier:pred; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:true_sets; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:true; 51, identifier:difference; 52, argument_list; 52, 53; 53, identifier:common; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:pred_sets; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:pred; 60, identifier:difference; 61, argument_list; 61, 62; 62, identifier:common; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:pred_conn; 66, dictionary_comprehension; 66, 67; 66, 73; 66, 76; 67, pair; 67, 68; 67, 69; 68, identifier:p; 69, call; 69, 70; 69, 71; 70, identifier:frozenset; 71, argument_list; 71, 72; 72, identifier:ps; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:ps; 75, identifier:pred; 76, for_in_clause; 76, 77; 76, 78; 77, identifier:p; 78, identifier:ps; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:true_conn; 82, dictionary_comprehension; 82, 83; 82, 89; 82, 92; 83, pair; 83, 84; 83, 85; 84, identifier:t; 85, call; 85, 86; 85, 87; 86, identifier:frozenset; 87, argument_list; 87, 88; 88, identifier:ts; 89, for_in_clause; 89, 90; 89, 91; 90, identifier:ts; 91, identifier:true; 92, for_in_clause; 92, 93; 92, 94; 93, identifier:t; 94, identifier:ts; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:pred_merges; 98, list:[]; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:true_merges; 102, list:[]; 103, for_statement; 103, 104; 103, 105; 103, 106; 104, identifier:ts; 105, identifier:true_sets; 106, block; 106, 107; 106, 126; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:ccs; 110, call; 110, 111; 110, 112; 111, identifier:set; 112, argument_list; 112, 113; 113, list_comprehension; 113, 114; 113, 123; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:pred_conn; 117, identifier:get; 118, argument_list; 118, 119; 118, 120; 119, identifier:t; 120, call; 120, 121; 120, 122; 121, identifier:frozenset; 122, argument_list; 123, for_in_clause; 123, 124; 123, 125; 124, identifier:t; 125, identifier:ts; 126, if_statement; 126, 127; 126, 136; 127, comparison_operator:==; 127, 128; 127, 135; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:frozenset; 131, identifier:union; 132, argument_list; 132, 133; 133, list_splat; 133, 134; 134, identifier:ccs; 135, identifier:ts; 136, block; 136, 137; 136, 144; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:pred_merges; 141, identifier:append; 142, argument_list; 142, 143; 143, identifier:ccs; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:true_merges; 148, identifier:append; 149, argument_list; 149, 150; 150, identifier:ts; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:true_splits; 154, list:[]; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:pred_splits; 158, list:[]; 159, for_statement; 159, 160; 159, 161; 159, 162; 160, identifier:ps; 161, identifier:pred_sets; 162, block; 162, 163; 162, 182; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:ccs; 166, call; 166, 167; 166, 168; 167, identifier:set; 168, argument_list; 168, 169; 169, list_comprehension; 169, 170; 169, 179; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:true_conn; 173, identifier:get; 174, argument_list; 174, 175; 174, 176; 175, identifier:p; 176, call; 176, 177; 176, 178; 177, identifier:frozenset; 178, argument_list; 179, for_in_clause; 179, 180; 179, 181; 180, identifier:p; 181, identifier:ps; 182, if_statement; 182, 183; 182, 192; 183, comparison_operator:==; 183, 184; 183, 191; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:frozenset; 187, identifier:union; 188, argument_list; 188, 189; 189, list_splat; 189, 190; 190, identifier:ccs; 191, identifier:ps; 192, block; 192, 193; 192, 200; 193, expression_statement; 193, 194; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:true_splits; 197, identifier:append; 198, argument_list; 198, 199; 199, identifier:ccs; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:pred_splits; 204, identifier:append; 205, argument_list; 205, 206; 206, identifier:ps; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:pred_merges_flat; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:ut; 213, identifier:flatten; 214, argument_list; 214, 215; 215, identifier:pred_merges; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:true_splits_flat; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:ut; 222, identifier:flatten; 223, argument_list; 223, 224; 224, identifier:true_splits; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:pred_hybrid; 228, call; 228, 229; 228, 239; 229, attribute; 229, 230; 229, 238; 230, call; 230, 231; 230, 232; 231, identifier:frozenset; 232, argument_list; 232, 233; 233, call; 233, 234; 233, 235; 234, identifier:map; 235, argument_list; 235, 236; 235, 237; 236, identifier:frozenset; 237, identifier:pred_sets; 238, identifier:difference; 239, argument_list; 239, 240; 240, call; 240, 241; 240, 242; 241, identifier:set; 242, argument_list; 242, 243; 243, binary_operator:+; 243, 244; 243, 245; 244, identifier:pred_splits; 245, identifier:pred_merges_flat; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:true_hybrid; 249, call; 249, 250; 249, 260; 250, attribute; 250, 251; 250, 259; 251, call; 251, 252; 251, 253; 252, identifier:frozenset; 253, argument_list; 253, 254; 254, call; 254, 255; 254, 256; 255, identifier:map; 256, argument_list; 256, 257; 256, 258; 257, identifier:frozenset; 258, identifier:true_sets; 259, identifier:difference; 260, argument_list; 260, 261; 261, call; 261, 262; 261, 263; 262, identifier:set; 263, argument_list; 263, 264; 264, binary_operator:+; 264, 265; 264, 266; 265, identifier:true_merges; 266, identifier:true_splits_flat; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:comparisons; 270, dictionary; 270, 271; 270, 274; 270, 277; 270, 280; 270, 283; 270, 286; 270, 289; 271, pair; 271, 272; 271, 273; 272, string:'common'; 273, identifier:common; 274, pair; 274, 275; 274, 276; 275, string:'true_splits'; 276, identifier:true_splits; 277, pair; 277, 278; 277, 279; 278, string:'true_merges'; 279, identifier:true_merges; 280, pair; 280, 281; 280, 282; 281, string:'true_hybrid'; 282, identifier:true_hybrid; 283, pair; 283, 284; 283, 285; 284, string:'pred_splits'; 285, identifier:pred_splits; 286, pair; 286, 287; 286, 288; 287, string:'pred_merges'; 288, identifier:pred_merges; 289, pair; 289, 290; 289, 291; 290, string:'pred_hybrid'; 291, identifier:pred_hybrid; 292, return_statement; 292, 293; 293, identifier:comparisons | def compare_groups(true_groups, pred_groups):
r
import utool as ut
true = {frozenset(_group) for _group in true_groups}
pred = {frozenset(_group) for _group in pred_groups}
common = true.intersection(pred)
true_sets = true.difference(common)
pred_sets = pred.difference(common)
pred_conn = {p: frozenset(ps) for ps in pred for p in ps}
true_conn = {t: frozenset(ts) for ts in true for t in ts}
pred_merges = []
true_merges = []
for ts in true_sets:
ccs = set([pred_conn.get(t, frozenset()) for t in ts])
if frozenset.union(*ccs) == ts:
pred_merges.append(ccs)
true_merges.append(ts)
true_splits = []
pred_splits = []
for ps in pred_sets:
ccs = set([true_conn.get(p, frozenset()) for p in ps])
if frozenset.union(*ccs) == ps:
true_splits.append(ccs)
pred_splits.append(ps)
pred_merges_flat = ut.flatten(pred_merges)
true_splits_flat = ut.flatten(true_splits)
pred_hybrid = frozenset(map(frozenset, pred_sets)).difference(
set(pred_splits + pred_merges_flat))
true_hybrid = frozenset(map(frozenset, true_sets)).difference(
set(true_merges + true_splits_flat))
comparisons = {
'common': common,
'true_splits': true_splits,
'true_merges': true_merges,
'true_hybrid': true_hybrid,
'pred_splits': pred_splits,
'pred_merges': pred_merges,
'pred_hybrid': pred_hybrid,
}
return comparisons |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:colwise_diag_idxs; 3, parameters; 3, 4; 3, 5; 4, identifier:size; 5, default_parameter; 5, 6; 5, 7; 6, identifier:num; 7, integer:2; 8, block; 8, 9; 8, 11; 8, 16; 8, 36; 8, 68; 9, expression_statement; 9, 10; 10, identifier:r; 11, import_statement; 11, 12; 12, aliased_import; 12, 13; 12, 15; 13, dotted_name; 13, 14; 14, identifier:utool; 15, identifier:ut; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:diag_idxs; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:ut; 22, identifier:iprod; 23, argument_list; 23, 24; 24, list_splat; 24, 25; 25, list_comprehension; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:range; 28, argument_list; 28, 29; 29, identifier:size; 30, for_in_clause; 30, 31; 30, 32; 31, identifier:_; 32, call; 32, 33; 32, 34; 33, identifier:range; 34, argument_list; 34, 35; 35, identifier:num; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:upper_diag_idxs; 39, list_comprehension; 39, 40; 39, 47; 39, 50; 40, subscript; 40, 41; 40, 42; 41, identifier:tup; 42, slice; 42, 43; 42, 44; 42, 45; 43, colon; 44, colon; 45, unary_operator:-; 45, 46; 46, integer:1; 47, for_in_clause; 47, 48; 47, 49; 48, identifier:tup; 49, identifier:diag_idxs; 50, if_clause; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:all; 53, argument_list; 53, 54; 54, list_comprehension; 54, 55; 54, 58; 55, comparison_operator:>; 55, 56; 55, 57; 56, identifier:a; 57, identifier:b; 58, for_in_clause; 58, 59; 58, 62; 59, pattern_list; 59, 60; 59, 61; 60, identifier:a; 61, identifier:b; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:ut; 65, identifier:itertwo; 66, argument_list; 66, 67; 67, identifier:tup; 68, return_statement; 68, 69; 69, identifier:upper_diag_idxs | def colwise_diag_idxs(size, num=2):
r
import utool as ut
diag_idxs = ut.iprod(*[range(size) for _ in range(num)])
upper_diag_idxs = [
tup[::-1] for tup in diag_idxs
if all([a > b for a, b in ut.itertwo(tup)])
]
return upper_diag_idxs |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.