sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 1, 16; 2, function_name:select_segment; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:segs; 6, identifier:segs_tips; 7, identifier:segs_undecided; 8, type; 8, 9; 9, generic_type; 9, 10; 9, 11; 10, identifier:Tuple; 11, type_parameter; 11, 12; 11, 14; 12, type; 12, 13; 13, identifier:int; 14, type; 14, 15; 15, identifier:int; 16, block; 16, 17; 16, 31; 16, 49; 16, 387; 16, 400; 16, 413; 16, 427; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:scores_tips; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:np; 23, identifier:zeros; 24, argument_list; 24, 25; 25, tuple; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, identifier:segs; 30, integer:4; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:allindices; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:np; 37, identifier:arange; 38, argument_list; 38, 39; 38, 46; 39, subscript; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_adata; 44, identifier:shape; 45, integer:0; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:dtype; 48, identifier:int; 49, for_statement; 49, 50; 49, 53; 49, 57; 50, pattern_list; 50, 51; 50, 52; 51, identifier:iseg; 52, identifier:seg; 53, call; 53, 54; 53, 55; 54, identifier:enumerate; 55, argument_list; 55, 56; 56, identifier:segs; 57, block; 57, 58; 57, 69; 57, 106; 57, 110; 57, 176; 57, 199; 57, 213; 57, 227; 57, 236; 57, 289; 57, 299; 57, 316; 57, 328; 57, 357; 57, 371; 57, 378; 58, if_statement; 58, 59; 58, 67; 59, comparison_operator:==; 59, 60; 59, 65; 60, subscript; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:segs_tips; 63, identifier:iseg; 64, integer:0; 65, unary_operator:-; 65, 66; 66, integer:1; 67, block; 67, 68; 68, continue_statement; 69, if_statement; 69, 70; 69, 78; 69, 93; 70, not_operator; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:isinstance; 73, argument_list; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:distances_dpt; 77, identifier:OnFlySymMatrix; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:Dseg; 82, subscript; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:distances_dpt; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:np; 89, identifier:ix_; 90, argument_list; 90, 91; 90, 92; 91, identifier:seg; 92, identifier:seg; 93, else_clause; 93, 94; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:Dseg; 98, call; 98, 99; 98, 104; 99, attribute; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:distances_dpt; 103, identifier:restrict; 104, argument_list; 104, 105; 105, identifier:seg; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:third_maximizer; 109, None; 110, if_statement; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:segs_undecided; 113, identifier:iseg; 114, block; 114, 115; 115, for_statement; 115, 116; 115, 117; 115, 124; 116, identifier:jseg; 117, call; 117, 118; 117, 119; 118, identifier:range; 119, argument_list; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:len; 122, argument_list; 122, 123; 123, identifier:segs; 124, block; 124, 125; 125, if_statement; 125, 126; 125, 129; 126, comparison_operator:!=; 126, 127; 126, 128; 127, identifier:jseg; 128, identifier:iseg; 129, block; 129, 130; 130, for_statement; 130, 131; 130, 132; 130, 136; 131, identifier:itip; 132, call; 132, 133; 132, 134; 133, identifier:range; 134, argument_list; 134, 135; 135, integer:2; 136, block; 136, 137; 137, if_statement; 137, 138; 137, 171; 138, parenthesized_expression; 138, 139; 139, comparison_operator:<; 139, 140; 139, 154; 140, subscript; 140, 141; 140, 144; 140, 149; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:distances_dpt; 144, subscript; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:segs_tips; 147, identifier:jseg; 148, integer:1; 149, subscript; 149, 150; 149, 153; 150, subscript; 150, 151; 150, 152; 151, identifier:segs_tips; 152, identifier:iseg; 153, identifier:itip; 154, binary_operator:*; 154, 155; 154, 156; 155, float:0.5; 156, subscript; 156, 157; 156, 160; 156, 166; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:distances_dpt; 160, subscript; 160, 161; 160, 164; 161, subscript; 161, 162; 161, 163; 162, identifier:segs_tips; 163, identifier:iseg; 164, unary_operator:~; 164, 165; 165, identifier:itip; 166, subscript; 166, 167; 166, 170; 167, subscript; 167, 168; 167, 169; 168, identifier:segs_tips; 169, identifier:iseg; 170, identifier:itip; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:third_maximizer; 175, identifier:itip; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:tips; 179, list_comprehension; 179, 180; 179, 194; 180, subscript; 180, 181; 180, 193; 181, subscript; 181, 182; 181, 192; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:np; 185, identifier:where; 186, argument_list; 186, 187; 187, comparison_operator:==; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:allindices; 190, identifier:seg; 191, identifier:tip; 192, integer:0; 193, integer:0; 194, for_in_clause; 194, 195; 194, 196; 195, identifier:tip; 196, subscript; 196, 197; 196, 198; 197, identifier:segs_tips; 198, identifier:iseg; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:dseg; 202, binary_operator:+; 202, 203; 202, 208; 203, subscript; 203, 204; 203, 205; 204, identifier:Dseg; 205, subscript; 205, 206; 205, 207; 206, identifier:tips; 207, integer:0; 208, subscript; 208, 209; 208, 210; 209, identifier:Dseg; 210, subscript; 210, 211; 210, 212; 211, identifier:tips; 212, integer:1; 213, if_statement; 213, 214; 213, 225; 214, not_operator; 214, 215; 215, call; 215, 216; 215, 224; 216, attribute; 216, 217; 216, 223; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:np; 220, identifier:isfinite; 221, argument_list; 221, 222; 222, identifier:dseg; 223, identifier:any; 224, argument_list; 225, block; 225, 226; 226, continue_statement; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:third_tip; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:np; 233, identifier:argmax; 234, argument_list; 234, 235; 235, identifier:dseg; 236, if_statement; 236, 237; 236, 240; 237, comparison_operator:is; 237, 238; 237, 239; 238, identifier:third_maximizer; 239, None; 240, block; 240, 241; 240, 247; 240, 256; 241, expression_statement; 241, 242; 242, augmented_assignment:+=; 242, 243; 242, 244; 243, identifier:dseg; 244, subscript; 244, 245; 244, 246; 245, identifier:Dseg; 246, identifier:third_tip; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:fourth_tip; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:np; 253, identifier:argmax; 254, argument_list; 254, 255; 255, identifier:dseg; 256, if_statement; 256, 257; 256, 266; 256, 281; 257, boolean_operator:and; 257, 258; 257, 263; 258, comparison_operator:!=; 258, 259; 258, 260; 259, identifier:fourth_tip; 260, subscript; 260, 261; 260, 262; 261, identifier:tips; 262, integer:0; 263, comparison_operator:!=; 263, 264; 263, 265; 264, identifier:fourth_tip; 265, identifier:third_tip; 266, block; 266, 267; 266, 273; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 272; 269, subscript; 269, 270; 269, 271; 270, identifier:tips; 271, integer:1; 272, identifier:fourth_tip; 273, expression_statement; 273, 274; 274, augmented_assignment:-=; 274, 275; 274, 276; 275, identifier:dseg; 276, subscript; 276, 277; 276, 278; 277, identifier:Dseg; 278, subscript; 278, 279; 278, 280; 279, identifier:tips; 280, integer:1; 281, else_clause; 281, 282; 282, block; 282, 283; 283, expression_statement; 283, 284; 284, augmented_assignment:-=; 284, 285; 284, 286; 285, identifier:dseg; 286, subscript; 286, 287; 286, 288; 287, identifier:Dseg; 288, identifier:third_tip; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 292; 291, identifier:tips3; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:np; 295, identifier:append; 296, argument_list; 296, 297; 296, 298; 297, identifier:tips; 298, identifier:third_tip; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:score; 302, binary_operator:/; 302, 303; 302, 308; 303, subscript; 303, 304; 303, 305; 304, identifier:dseg; 305, subscript; 305, 306; 305, 307; 306, identifier:tips3; 307, integer:2; 308, subscript; 308, 309; 308, 310; 308, 313; 309, identifier:Dseg; 310, subscript; 310, 311; 310, 312; 311, identifier:tips3; 312, integer:0; 313, subscript; 313, 314; 313, 315; 314, identifier:tips3; 315, integer:1; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 319; 318, identifier:score; 319, conditional_expression:if; 319, 320; 319, 324; 319, 327; 320, call; 320, 321; 320, 322; 321, identifier:len; 322, argument_list; 322, 323; 323, identifier:seg; 324, attribute; 324, 325; 324, 326; 325, identifier:self; 326, identifier:choose_largest_segment; 327, identifier:score; 328, expression_statement; 328, 329; 329, call; 329, 330; 329, 333; 330, attribute; 330, 331; 330, 332; 331, identifier:logg; 332, identifier:m; 333, argument_list; 333, 334; 333, 335; 333, 336; 333, 337; 333, 338; 333, 339; 333, 343; 333, 354; 334, string:' group'; 335, identifier:iseg; 336, string:'score'; 337, identifier:score; 338, string:'n_points'; 339, call; 339, 340; 339, 341; 340, identifier:len; 341, argument_list; 341, 342; 342, identifier:seg; 343, conditional_expression:if; 343, 344; 343, 345; 343, 353; 344, string:'(too small)'; 345, comparison_operator:<; 345, 346; 345, 350; 346, call; 346, 347; 346, 348; 347, identifier:len; 348, argument_list; 348, 349; 349, identifier:seg; 350, attribute; 350, 351; 350, 352; 351, identifier:self; 352, identifier:min_group_size; 353, string:''; 354, keyword_argument; 354, 355; 354, 356; 355, identifier:v; 356, integer:4; 357, if_statement; 357, 358; 357, 366; 358, comparison_operator:<=; 358, 359; 358, 363; 359, call; 359, 360; 359, 361; 360, identifier:len; 361, argument_list; 361, 362; 362, identifier:seg; 363, attribute; 363, 364; 363, 365; 364, identifier:self; 365, identifier:min_group_size; 366, block; 366, 367; 367, expression_statement; 367, 368; 368, assignment; 368, 369; 368, 370; 369, identifier:score; 370, integer:0; 371, expression_statement; 371, 372; 372, assignment; 372, 373; 372, 377; 373, subscript; 373, 374; 373, 375; 373, 376; 374, identifier:scores_tips; 375, identifier:iseg; 376, integer:0; 377, identifier:score; 378, expression_statement; 378, 379; 379, assignment; 379, 380; 379, 386; 380, subscript; 380, 381; 380, 382; 380, 383; 381, identifier:scores_tips; 382, identifier:iseg; 383, slice; 383, 384; 383, 385; 384, integer:1; 385, colon; 386, identifier:tips3; 387, expression_statement; 387, 388; 388, assignment; 388, 389; 388, 390; 389, identifier:iseg; 390, call; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, identifier:np; 393, identifier:argmax; 394, argument_list; 394, 395; 395, subscript; 395, 396; 395, 397; 395, 399; 396, identifier:scores_tips; 397, slice; 397, 398; 398, colon; 399, integer:0; 400, if_statement; 400, 401; 400, 407; 401, comparison_operator:==; 401, 402; 401, 406; 402, subscript; 402, 403; 402, 404; 402, 405; 403, identifier:scores_tips; 404, identifier:iseg; 405, integer:0; 406, integer:0; 407, block; 407, 408; 408, return_statement; 408, 409; 409, expression_list; 409, 410; 409, 412; 410, unary_operator:-; 410, 411; 411, integer:1; 412, None; 413, expression_statement; 413, 414; 414, assignment; 414, 415; 414, 416; 415, identifier:tips3; 416, call; 416, 417; 416, 425; 417, attribute; 417, 418; 417, 424; 418, subscript; 418, 419; 418, 420; 418, 421; 419, identifier:scores_tips; 420, identifier:iseg; 421, slice; 421, 422; 421, 423; 422, integer:1; 423, colon; 424, identifier:astype; 425, argument_list; 425, 426; 426, identifier:int; 427, return_statement; 427, 428; 428, expression_list; 428, 429; 428, 430; 429, identifier:iseg; 430, identifier:tips3 | def select_segment(self, segs, segs_tips, segs_undecided) -> Tuple[int, int]:
scores_tips = np.zeros((len(segs), 4))
allindices = np.arange(self._adata.shape[0], dtype=int)
for iseg, seg in enumerate(segs):
if segs_tips[iseg][0] == -1: continue
if not isinstance(self.distances_dpt, OnFlySymMatrix):
Dseg = self.distances_dpt[np.ix_(seg, seg)]
else:
Dseg = self.distances_dpt.restrict(seg)
third_maximizer = None
if segs_undecided[iseg]:
for jseg in range(len(segs)):
if jseg != iseg:
for itip in range(2):
if (self.distances_dpt[segs_tips[jseg][1], segs_tips[iseg][itip]]
< 0.5 * self.distances_dpt[segs_tips[iseg][~itip], segs_tips[iseg][itip]]):
third_maximizer = itip
tips = [np.where(allindices[seg] == tip)[0][0]
for tip in segs_tips[iseg]]
dseg = Dseg[tips[0]] + Dseg[tips[1]]
if not np.isfinite(dseg).any():
continue
third_tip = np.argmax(dseg)
if third_maximizer is not None:
dseg += Dseg[third_tip]
fourth_tip = np.argmax(dseg)
if fourth_tip != tips[0] and fourth_tip != third_tip:
tips[1] = fourth_tip
dseg -= Dseg[tips[1]]
else:
dseg -= Dseg[third_tip]
tips3 = np.append(tips, third_tip)
score = dseg[tips3[2]] / Dseg[tips3[0], tips3[1]]
score = len(seg) if self.choose_largest_segment else score
logg.m(' group', iseg, 'score', score, 'n_points', len(seg),
'(too small)' if len(seg) < self.min_group_size else '', v=4)
if len(seg) <= self.min_group_size: score = 0
scores_tips[iseg, 0] = score
scores_tips[iseg, 1:] = tips3
iseg = np.argmax(scores_tips[:, 0])
if scores_tips[iseg, 0] == 0: return -1, None
tips3 = scores_tips[iseg, 1:].astype(int)
return iseg, tips3 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:unique_categories; 3, parameters; 3, 4; 4, identifier:categories; 5, block; 5, 6; 5, 15; 5, 32; 5, 54; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:categories; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:np; 12, identifier:unique; 13, argument_list; 13, 14; 14, identifier:categories; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:categories; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:np; 21, identifier:setdiff1d; 22, argument_list; 22, 23; 22, 24; 23, identifier:categories; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:np; 27, identifier:array; 28, argument_list; 28, 29; 29, attribute; 29, 30; 29, 31; 30, identifier:settings; 31, identifier:categories_to_ignore; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:categories; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:np; 38, identifier:array; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:natsorted; 42, argument_list; 42, 43; 42, 44; 43, identifier:categories; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:key; 46, lambda; 46, 47; 46, 49; 47, lambda_parameters; 47, 48; 48, identifier:v; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:v; 52, identifier:upper; 53, argument_list; 54, return_statement; 54, 55; 55, identifier:categories | def unique_categories(categories):
categories = np.unique(categories)
categories = np.setdiff1d(categories, np.array(settings.categories_to_ignore))
categories = np.array(natsorted(categories, key=lambda v: v.upper()))
return categories |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:find_one_and_delete; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:self; 5, identifier:filter; 6, default_parameter; 6, 7; 6, 8; 7, identifier:projection; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:session; 14, None; 15, dictionary_splat_pattern; 15, 16; 16, identifier:kwargs; 17, block; 17, 18; 17, 24; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, subscript; 20, 21; 20, 22; 21, identifier:kwargs; 22, string:'remove'; 23, True; 24, return_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:__find_and_modify; 29, argument_list; 29, 30; 29, 31; 29, 32; 29, 33; 29, 36; 30, identifier:filter; 31, identifier:projection; 32, identifier:sort; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:session; 35, identifier:session; 36, dictionary_splat; 36, 37; 37, identifier:kwargs | def find_one_and_delete(self, filter,
projection=None, sort=None, session=None, **kwargs):
kwargs['remove'] = True
return self.__find_and_modify(filter, projection, sort,
session=session, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort; 3, parameters; 3, 4; 4, identifier:lines; 5, block; 5, 6; 5, 13; 5, 23; 5, 53; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:lines; 9, call; 9, 10; 9, 11; 10, identifier:list; 11, argument_list; 11, 12; 12, identifier:lines; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:new_lines; 16, call; 16, 17; 16, 18; 17, identifier:parse_block; 18, argument_list; 18, 19; 18, 20; 19, identifier:lines; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:header; 22, True; 23, for_statement; 23, 24; 23, 25; 23, 35; 24, identifier:block; 25, call; 25, 26; 25, 27; 26, identifier:sorted; 27, argument_list; 27, 28; 27, 32; 28, call; 28, 29; 28, 30; 29, identifier:parse_blocks; 30, argument_list; 30, 31; 31, identifier:lines; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:key; 34, identifier:first_key; 35, block; 35, 36; 35, 46; 36, if_statement; 36, 37; 36, 38; 37, identifier:new_lines; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:new_lines; 43, identifier:append; 44, argument_list; 44, 45; 45, string:''; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:new_lines; 50, identifier:extend; 51, argument_list; 51, 52; 52, identifier:block; 53, return_statement; 53, 54; 54, identifier:new_lines | def sort(lines):
lines = list(lines)
new_lines = parse_block(lines, header=True)
for block in sorted(parse_blocks(lines), key=first_key):
if new_lines:
new_lines.append('')
new_lines.extend(block)
return new_lines |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:first_key; 3, parameters; 3, 4; 4, identifier:lines; 5, block; 5, 6; 6, for_statement; 6, 7; 6, 8; 6, 9; 6, 38; 7, identifier:line; 8, identifier:lines; 9, block; 9, 10; 9, 36; 10, if_statement; 10, 11; 10, 14; 10, 29; 11, attribute; 11, 12; 11, 13; 12, identifier:line; 13, identifier:startswith; 14, ERROR; 14, 15; 14, 16; 14, 17; 15, ERROR; 16, identifier:continue; 17, call; 17, 18; 17, 19; 18, identifier:any; 19, generator_expression; 19, 20; 19, 26; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:line; 23, identifier:startswith; 24, argument_list; 24, 25; 25, identifier:quote; 26, for_in_clause; 26, 27; 26, 28; 27, identifier:quote; 28, identifier:QUOTES; 29, block; 29, 30; 30, return_statement; 30, 31; 31, subscript; 31, 32; 31, 33; 32, identifier:line; 33, slice; 33, 34; 33, 35; 34, integer:1; 35, colon; 36, return_statement; 36, 37; 37, identifier:line; 38, else_clause; 38, 39; 39, block; 39, 40; 40, return_statement; 40, 41; 41, string:'' | def first_key(lines):
for line in lines:
if line.startswith('
continue
if any(line.startswith(quote) for quote in QUOTES):
return line[1:]
return line
else:
return '' |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:geoadd; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 11; 4, identifier:self; 5, identifier:key; 6, identifier:longitude; 7, identifier:latitude; 8, identifier:member; 9, list_splat_pattern; 9, 10; 10, identifier:args; 11, dictionary_splat_pattern; 11, 12; 12, identifier:kwargs; 13, block; 13, 14; 14, return_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:execute; 19, argument_list; 19, 20; 19, 21; 19, 22; 19, 23; 19, 24; 19, 25; 19, 27; 20, string:b'GEOADD'; 21, identifier:key; 22, identifier:longitude; 23, identifier:latitude; 24, identifier:member; 25, list_splat; 25, 26; 26, identifier:args; 27, dictionary_splat; 27, 28; 28, identifier:kwargs | def geoadd(self, key, longitude, latitude, member, *args, **kwargs):
return self.execute(
b'GEOADD', key, longitude, latitude, member, *args, **kwargs
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 31; 2, function_name:georadius; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 12; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 28; 4, identifier:self; 5, identifier:key; 6, identifier:longitude; 7, identifier:latitude; 8, identifier:radius; 9, default_parameter; 9, 10; 9, 11; 10, identifier:unit; 11, string:'m'; 12, keyword_separator; 13, default_parameter; 13, 14; 13, 15; 14, identifier:with_dist; 15, False; 16, default_parameter; 16, 17; 16, 18; 17, identifier:with_hash; 18, False; 19, default_parameter; 19, 20; 19, 21; 20, identifier:with_coord; 21, False; 22, default_parameter; 22, 23; 22, 24; 23, identifier:count; 24, None; 25, default_parameter; 25, 26; 25, 27; 26, identifier:sort; 27, None; 28, default_parameter; 28, 29; 28, 30; 29, identifier:encoding; 30, identifier:_NOTSET; 31, block; 31, 32; 31, 45; 31, 64; 31, 86; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:args; 35, call; 35, 36; 35, 37; 36, identifier:validate_georadius_options; 37, argument_list; 37, 38; 37, 39; 37, 40; 37, 41; 37, 42; 37, 43; 37, 44; 38, identifier:radius; 39, identifier:unit; 40, identifier:with_dist; 41, identifier:with_hash; 42, identifier:with_coord; 43, identifier:count; 44, identifier:sort; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:fut; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:execute; 52, argument_list; 52, 53; 52, 54; 52, 55; 52, 56; 52, 57; 52, 58; 52, 59; 52, 61; 53, string:b'GEORADIUS'; 54, identifier:key; 55, identifier:longitude; 56, identifier:latitude; 57, identifier:radius; 58, identifier:unit; 59, list_splat; 59, 60; 60, identifier:args; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:encoding; 63, identifier:encoding; 64, if_statement; 64, 65; 64, 70; 65, boolean_operator:or; 65, 66; 65, 69; 66, boolean_operator:or; 66, 67; 66, 68; 67, identifier:with_dist; 68, identifier:with_hash; 69, identifier:with_coord; 70, block; 70, 71; 71, return_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:wait_convert; 74, argument_list; 74, 75; 74, 76; 74, 77; 74, 80; 74, 83; 75, identifier:fut; 76, identifier:make_geomember; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:with_dist; 79, identifier:with_dist; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:with_hash; 82, identifier:with_hash; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:with_coord; 85, identifier:with_coord; 86, return_statement; 86, 87; 87, identifier:fut | def georadius(self, key, longitude, latitude, radius, unit='m', *,
with_dist=False, with_hash=False, with_coord=False,
count=None, sort=None, encoding=_NOTSET):
args = validate_georadius_options(
radius, unit, with_dist, with_hash, with_coord, count, sort
)
fut = self.execute(
b'GEORADIUS', key, longitude, latitude, radius,
unit, *args, encoding=encoding
)
if with_dist or with_hash or with_coord:
return wait_convert(fut, make_geomember,
with_dist=with_dist,
with_hash=with_hash,
with_coord=with_coord)
return fut |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 30; 2, function_name:georadiusbymember; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 11; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 4, identifier:self; 5, identifier:key; 6, identifier:member; 7, identifier:radius; 8, default_parameter; 8, 9; 8, 10; 9, identifier:unit; 10, string:'m'; 11, keyword_separator; 12, default_parameter; 12, 13; 12, 14; 13, identifier:with_dist; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:with_hash; 17, False; 18, default_parameter; 18, 19; 18, 20; 19, identifier:with_coord; 20, False; 21, default_parameter; 21, 22; 21, 23; 22, identifier:count; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:sort; 26, None; 27, default_parameter; 27, 28; 27, 29; 28, identifier:encoding; 29, identifier:_NOTSET; 30, block; 30, 31; 30, 44; 30, 62; 30, 84; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:args; 34, call; 34, 35; 34, 36; 35, identifier:validate_georadius_options; 36, argument_list; 36, 37; 36, 38; 36, 39; 36, 40; 36, 41; 36, 42; 36, 43; 37, identifier:radius; 38, identifier:unit; 39, identifier:with_dist; 40, identifier:with_hash; 41, identifier:with_coord; 42, identifier:count; 43, identifier:sort; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:fut; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:execute; 51, argument_list; 51, 52; 51, 53; 51, 54; 51, 55; 51, 56; 51, 57; 51, 59; 52, string:b'GEORADIUSBYMEMBER'; 53, identifier:key; 54, identifier:member; 55, identifier:radius; 56, identifier:unit; 57, list_splat; 57, 58; 58, identifier:args; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:encoding; 61, identifier:encoding; 62, if_statement; 62, 63; 62, 68; 63, boolean_operator:or; 63, 64; 63, 67; 64, boolean_operator:or; 64, 65; 64, 66; 65, identifier:with_dist; 66, identifier:with_hash; 67, identifier:with_coord; 68, block; 68, 69; 69, return_statement; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:wait_convert; 72, argument_list; 72, 73; 72, 74; 72, 75; 72, 78; 72, 81; 73, identifier:fut; 74, identifier:make_geomember; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:with_dist; 77, identifier:with_dist; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:with_hash; 80, identifier:with_hash; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:with_coord; 83, identifier:with_coord; 84, return_statement; 84, 85; 85, identifier:fut | def georadiusbymember(self, key, member, radius, unit='m', *,
with_dist=False, with_hash=False, with_coord=False,
count=None, sort=None, encoding=_NOTSET):
args = validate_georadius_options(
radius, unit, with_dist, with_hash, with_coord, count, sort
)
fut = self.execute(
b'GEORADIUSBYMEMBER', key, member, radius,
unit, *args, encoding=encoding)
if with_dist or with_hash or with_coord:
return wait_convert(fut, make_geomember,
with_dist=with_dist,
with_hash=with_hash,
with_coord=with_coord)
return fut |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 4, identifier:self; 5, identifier:key; 6, list_splat_pattern; 6, 7; 7, identifier:get_patterns; 8, default_parameter; 8, 9; 8, 10; 9, identifier:by; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:offset; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:count; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:asc; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:alpha; 22, False; 23, default_parameter; 23, 24; 23, 25; 24, identifier:store; 25, None; 26, block; 26, 27; 26, 31; 26, 42; 26, 58; 26, 75; 26, 91; 26, 99; 26, 110; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:args; 30, list:[]; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:by; 34, None; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, augmented_assignment:+=; 37, 38; 37, 39; 38, identifier:args; 39, list:[b'BY', by]; 39, 40; 39, 41; 40, string:b'BY'; 41, identifier:by; 42, if_statement; 42, 43; 42, 50; 43, boolean_operator:and; 43, 44; 43, 47; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:offset; 46, None; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:count; 49, None; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, augmented_assignment:+=; 52, 53; 52, 54; 53, identifier:args; 54, list:[b'LIMIT', offset, count]; 54, 55; 54, 56; 54, 57; 55, string:b'LIMIT'; 56, identifier:offset; 57, identifier:count; 58, if_statement; 58, 59; 58, 60; 59, identifier:get_patterns; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, augmented_assignment:+=; 62, 63; 62, 64; 63, identifier:args; 64, call; 64, 65; 64, 66; 65, identifier:sum; 66, argument_list; 66, 67; 66, 74; 67, generator_expression; 67, 68; 67, 71; 68, list:[b'GET', pattern]; 68, 69; 68, 70; 69, string:b'GET'; 70, identifier:pattern; 71, for_in_clause; 71, 72; 71, 73; 72, identifier:pattern; 73, identifier:get_patterns; 74, list:[]; 75, if_statement; 75, 76; 75, 79; 76, comparison_operator:is; 76, 77; 76, 78; 77, identifier:asc; 78, None; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, augmented_assignment:+=; 81, 82; 81, 83; 82, identifier:args; 83, list:[asc is True and b'ASC' or b'DESC']; 83, 84; 84, boolean_operator:or; 84, 85; 84, 90; 85, boolean_operator:and; 85, 86; 85, 89; 86, comparison_operator:is; 86, 87; 86, 88; 87, identifier:asc; 88, True; 89, string:b'ASC'; 90, string:b'DESC'; 91, if_statement; 91, 92; 91, 93; 92, identifier:alpha; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, augmented_assignment:+=; 95, 96; 95, 97; 96, identifier:args; 97, list:[b'ALPHA']; 97, 98; 98, string:b'ALPHA'; 99, if_statement; 99, 100; 99, 103; 100, comparison_operator:is; 100, 101; 100, 102; 101, identifier:store; 102, None; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, augmented_assignment:+=; 105, 106; 105, 107; 106, identifier:args; 107, list:[b'STORE', store]; 107, 108; 107, 109; 108, string:b'STORE'; 109, identifier:store; 110, return_statement; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:execute; 115, argument_list; 115, 116; 115, 117; 115, 118; 116, string:b'SORT'; 117, identifier:key; 118, list_splat; 118, 119; 119, identifier:args | def sort(self, key, *get_patterns,
by=None, offset=None, count=None,
asc=None, alpha=False, store=None):
args = []
if by is not None:
args += [b'BY', by]
if offset is not None and count is not None:
args += [b'LIMIT', offset, count]
if get_patterns:
args += sum(([b'GET', pattern] for pattern in get_patterns), [])
if asc is not None:
args += [asc is True and b'ASC' or b'DESC']
if alpha:
args += [b'ALPHA']
if store is not None:
args += [b'STORE', store]
return self.execute(b'SORT', key, *args) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:zadd; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 10; 4, identifier:self; 5, identifier:key; 6, identifier:score; 7, identifier:member; 8, list_splat_pattern; 8, 9; 9, identifier:pairs; 10, default_parameter; 10, 11; 10, 12; 11, identifier:exist; 12, None; 13, block; 13, 14; 13, 29; 13, 44; 13, 63; 13, 84; 13, 88; 13, 116; 13, 125; 13, 135; 14, if_statement; 14, 15; 14, 23; 15, not_operator; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:isinstance; 18, argument_list; 18, 19; 18, 20; 19, identifier:score; 20, tuple; 20, 21; 20, 22; 21, identifier:int; 22, identifier:float; 23, block; 23, 24; 24, raise_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:TypeError; 27, argument_list; 27, 28; 28, string:"score argument must be int or float"; 29, if_statement; 29, 30; 29, 38; 30, comparison_operator:!=; 30, 31; 30, 37; 31, binary_operator:%; 31, 32; 31, 36; 32, call; 32, 33; 32, 34; 33, identifier:len; 34, argument_list; 34, 35; 35, identifier:pairs; 36, integer:2; 37, integer:0; 38, block; 38, 39; 39, raise_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:TypeError; 42, argument_list; 42, 43; 43, string:"length of pairs must be even number"; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:scores; 47, generator_expression; 47, 48; 47, 49; 47, 57; 48, identifier:item; 49, for_in_clause; 49, 50; 49, 53; 50, pattern_list; 50, 51; 50, 52; 51, identifier:i; 52, identifier:item; 53, call; 53, 54; 53, 55; 54, identifier:enumerate; 55, argument_list; 55, 56; 56, identifier:pairs; 57, if_clause; 57, 58; 58, comparison_operator:==; 58, 59; 58, 62; 59, binary_operator:%; 59, 60; 59, 61; 60, identifier:i; 61, integer:2; 62, integer:0; 63, if_statement; 63, 64; 63, 78; 64, call; 64, 65; 64, 66; 65, identifier:any; 66, generator_expression; 66, 67; 66, 75; 67, not_operator; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:isinstance; 70, argument_list; 70, 71; 70, 72; 71, identifier:s; 72, tuple; 72, 73; 72, 74; 73, identifier:int; 74, identifier:float; 75, for_in_clause; 75, 76; 75, 77; 76, identifier:s; 77, identifier:scores; 78, block; 78, 79; 79, raise_statement; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:TypeError; 82, argument_list; 82, 83; 83, string:"all scores must be int or float"; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:args; 87, list:[]; 88, if_statement; 88, 89; 88, 94; 88, 102; 89, comparison_operator:is; 89, 90; 89, 91; 90, identifier:exist; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:ZSET_IF_EXIST; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:args; 99, identifier:append; 100, argument_list; 100, 101; 101, string:b'XX'; 102, elif_clause; 102, 103; 102, 108; 103, comparison_operator:is; 103, 104; 103, 105; 104, identifier:exist; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:ZSET_IF_NOT_EXIST; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:args; 113, identifier:append; 114, argument_list; 114, 115; 115, string:b'NX'; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:args; 120, identifier:extend; 121, argument_list; 121, 122; 122, list:[score, member]; 122, 123; 122, 124; 123, identifier:score; 124, identifier:member; 125, if_statement; 125, 126; 125, 127; 126, identifier:pairs; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:args; 132, identifier:extend; 133, argument_list; 133, 134; 134, identifier:pairs; 135, return_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:self; 139, identifier:execute; 140, argument_list; 140, 141; 140, 142; 140, 143; 141, string:b'ZADD'; 142, identifier:key; 143, list_splat; 143, 144; 144, identifier:args | def zadd(self, key, score, member, *pairs, exist=None):
if not isinstance(score, (int, float)):
raise TypeError("score argument must be int or float")
if len(pairs) % 2 != 0:
raise TypeError("length of pairs must be even number")
scores = (item for i, item in enumerate(pairs) if i % 2 == 0)
if any(not isinstance(s, (int, float)) for s in scores):
raise TypeError("all scores must be int or float")
args = []
if exist is self.ZSET_IF_EXIST:
args.append(b'XX')
elif exist is self.ZSET_IF_NOT_EXIST:
args.append(b'NX')
args.extend([score, member])
if pairs:
args.extend(pairs)
return self.execute(b'ZADD', key, *args) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:zcount; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 12; 3, 18; 3, 19; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:min; 8, call; 8, 9; 8, 10; 9, identifier:float; 10, argument_list; 10, 11; 11, string:'-inf'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:max; 14, call; 14, 15; 14, 16; 15, identifier:float; 16, argument_list; 16, 17; 17, string:'inf'; 18, keyword_separator; 19, default_parameter; 19, 20; 19, 21; 20, identifier:exclude; 21, None; 22, block; 22, 23; 22, 38; 22, 53; 22, 63; 23, if_statement; 23, 24; 23, 32; 24, not_operator; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 29; 28, identifier:min; 29, tuple; 29, 30; 29, 31; 30, identifier:int; 31, identifier:float; 32, block; 32, 33; 33, raise_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:TypeError; 36, argument_list; 36, 37; 37, string:"min argument must be int or float"; 38, if_statement; 38, 39; 38, 47; 39, not_operator; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 44; 43, identifier:max; 44, tuple; 44, 45; 44, 46; 45, identifier:int; 46, identifier:float; 47, block; 47, 48; 48, raise_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:TypeError; 51, argument_list; 51, 52; 52, string:"max argument must be int or float"; 53, if_statement; 53, 54; 53, 57; 54, comparison_operator:>; 54, 55; 54, 56; 55, identifier:min; 56, identifier:max; 57, block; 57, 58; 58, raise_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:ValueError; 61, argument_list; 61, 62; 62, string:"min could not be greater than max"; 63, return_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:execute; 68, argument_list; 68, 69; 68, 70; 68, 71; 69, string:b'ZCOUNT'; 70, identifier:key; 71, list_splat; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:_encode_min_max; 74, argument_list; 74, 75; 74, 76; 74, 77; 75, identifier:exclude; 76, identifier:min; 77, identifier:max | def zcount(self, key, min=float('-inf'), max=float('inf'),
*, exclude=None):
if not isinstance(min, (int, float)):
raise TypeError("min argument must be int or float")
if not isinstance(max, (int, float)):
raise TypeError("max argument must be int or float")
if min > max:
raise ValueError("min could not be greater than max")
return self.execute(b'ZCOUNT', key,
*_encode_min_max(exclude, min, max)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:zincrby; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:key; 6, identifier:increment; 7, identifier:member; 8, block; 8, 9; 8, 24; 8, 36; 9, if_statement; 9, 10; 9, 18; 10, not_operator; 10, 11; 11, call; 11, 12; 11, 13; 12, identifier:isinstance; 13, argument_list; 13, 14; 13, 15; 14, identifier:increment; 15, tuple; 15, 16; 15, 17; 16, identifier:int; 17, identifier:float; 18, block; 18, 19; 19, raise_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:TypeError; 22, argument_list; 22, 23; 23, string:"increment argument must be int or float"; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:fut; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:execute; 31, argument_list; 31, 32; 31, 33; 31, 34; 31, 35; 32, string:b'ZINCRBY'; 33, identifier:key; 34, identifier:increment; 35, identifier:member; 36, return_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:wait_convert; 39, argument_list; 39, 40; 39, 41; 40, identifier:fut; 41, identifier:int_or_float | def zincrby(self, key, increment, member):
if not isinstance(increment, (int, float)):
raise TypeError("increment argument must be int or float")
fut = self.execute(b'ZINCRBY', key, increment, member)
return wait_convert(fut, int_or_float) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:zrem; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:key; 6, identifier:member; 7, list_splat_pattern; 7, 8; 8, identifier:members; 9, block; 9, 10; 10, return_statement; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:execute; 15, argument_list; 15, 16; 15, 17; 15, 18; 15, 19; 16, string:b'ZREM'; 17, identifier:key; 18, identifier:member; 19, list_splat; 19, 20; 20, identifier:members | def zrem(self, key, member, *members):
return self.execute(b'ZREM', key, member, *members) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:zremrangebylex; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:min; 8, string:b'-'; 9, default_parameter; 9, 10; 9, 11; 10, identifier:max; 11, string:b'+'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:include_min; 14, True; 15, default_parameter; 15, 16; 15, 17; 16, identifier:include_max; 17, True; 18, block; 18, 19; 18, 32; 18, 45; 18, 61; 18, 77; 19, if_statement; 19, 20; 19, 26; 20, not_operator; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:isinstance; 23, argument_list; 23, 24; 23, 25; 24, identifier:min; 25, identifier:bytes; 26, block; 26, 27; 27, raise_statement; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:TypeError; 30, argument_list; 30, 31; 31, string:"min argument must be bytes"; 32, if_statement; 32, 33; 32, 39; 33, not_operator; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:isinstance; 36, argument_list; 36, 37; 36, 38; 37, identifier:max; 38, identifier:bytes; 39, block; 39, 40; 40, raise_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:TypeError; 43, argument_list; 43, 44; 44, string:"max argument must be bytes"; 45, if_statement; 45, 46; 45, 50; 46, not_operator; 46, 47; 47, comparison_operator:==; 47, 48; 47, 49; 48, identifier:min; 49, string:b'-'; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:min; 54, binary_operator:+; 54, 55; 54, 60; 55, parenthesized_expression; 55, 56; 56, conditional_expression:if; 56, 57; 56, 58; 56, 59; 57, string:b'['; 58, identifier:include_min; 59, string:b'('; 60, identifier:min; 61, if_statement; 61, 62; 61, 66; 62, not_operator; 62, 63; 63, comparison_operator:==; 63, 64; 63, 65; 64, identifier:max; 65, string:b'+'; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:max; 70, binary_operator:+; 70, 71; 70, 76; 71, parenthesized_expression; 71, 72; 72, conditional_expression:if; 72, 73; 72, 74; 72, 75; 73, string:b'['; 74, identifier:include_max; 75, string:b'('; 76, identifier:max; 77, return_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:execute; 82, argument_list; 82, 83; 82, 84; 82, 85; 82, 86; 83, string:b'ZREMRANGEBYLEX'; 84, identifier:key; 85, identifier:min; 86, identifier:max | def zremrangebylex(self, key, min=b'-', max=b'+',
include_min=True, include_max=True):
if not isinstance(min, bytes):
raise TypeError("min argument must be bytes")
if not isinstance(max, bytes):
raise TypeError("max argument must be bytes")
if not min == b'-':
min = (b'[' if include_min else b'(') + min
if not max == b'+':
max = (b'[' if include_max else b'(') + max
return self.execute(b'ZREMRANGEBYLEX', key, min, max) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:zremrangebyrank; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:key; 6, identifier:start; 7, identifier:stop; 8, block; 8, 9; 8, 22; 8, 35; 9, if_statement; 9, 10; 9, 16; 10, not_operator; 10, 11; 11, call; 11, 12; 11, 13; 12, identifier:isinstance; 13, argument_list; 13, 14; 13, 15; 14, identifier:start; 15, identifier:int; 16, block; 16, 17; 17, raise_statement; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:TypeError; 20, argument_list; 20, 21; 21, string:"start argument must be int"; 22, if_statement; 22, 23; 22, 29; 23, not_operator; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:isinstance; 26, argument_list; 26, 27; 26, 28; 27, identifier:stop; 28, identifier:int; 29, block; 29, 30; 30, raise_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:TypeError; 33, argument_list; 33, 34; 34, string:"stop argument must be int"; 35, return_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:execute; 40, argument_list; 40, 41; 40, 42; 40, 43; 40, 44; 41, string:b'ZREMRANGEBYRANK'; 42, identifier:key; 43, identifier:start; 44, identifier:stop | def zremrangebyrank(self, key, start, stop):
if not isinstance(start, int):
raise TypeError("start argument must be int")
if not isinstance(stop, int):
raise TypeError("stop argument must be int")
return self.execute(b'ZREMRANGEBYRANK', key, start, stop) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:zremrangebyscore; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 12; 3, 18; 3, 19; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:min; 8, call; 8, 9; 8, 10; 9, identifier:float; 10, argument_list; 10, 11; 11, string:'-inf'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:max; 14, call; 14, 15; 14, 16; 15, identifier:float; 16, argument_list; 16, 17; 17, string:'inf'; 18, keyword_separator; 19, default_parameter; 19, 20; 19, 21; 20, identifier:exclude; 21, None; 22, block; 22, 23; 22, 38; 22, 53; 22, 64; 23, if_statement; 23, 24; 23, 32; 24, not_operator; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 29; 28, identifier:min; 29, tuple; 29, 30; 29, 31; 30, identifier:int; 31, identifier:float; 32, block; 32, 33; 33, raise_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:TypeError; 36, argument_list; 36, 37; 37, string:"min argument must be int or float"; 38, if_statement; 38, 39; 38, 47; 39, not_operator; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 44; 43, identifier:max; 44, tuple; 44, 45; 44, 46; 45, identifier:int; 46, identifier:float; 47, block; 47, 48; 48, raise_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:TypeError; 51, argument_list; 51, 52; 52, string:"max argument must be int or float"; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, pattern_list; 55, 56; 55, 57; 56, identifier:min; 57, identifier:max; 58, call; 58, 59; 58, 60; 59, identifier:_encode_min_max; 60, argument_list; 60, 61; 60, 62; 60, 63; 61, identifier:exclude; 62, identifier:min; 63, identifier:max; 64, return_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:execute; 69, argument_list; 69, 70; 69, 71; 69, 72; 69, 73; 70, string:b'ZREMRANGEBYSCORE'; 71, identifier:key; 72, identifier:min; 73, identifier:max | def zremrangebyscore(self, key, min=float('-inf'), max=float('inf'),
*, exclude=None):
if not isinstance(min, (int, float)):
raise TypeError("min argument must be int or float")
if not isinstance(max, (int, float)):
raise TypeError("max argument must be int or float")
min, max = _encode_min_max(exclude, min, max)
return self.execute(b'ZREMRANGEBYSCORE', key, min, max) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:zrevrange; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 11; 4, identifier:self; 5, identifier:key; 6, identifier:start; 7, identifier:stop; 8, default_parameter; 8, 9; 8, 10; 9, identifier:withscores; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:encoding; 13, identifier:_NOTSET; 14, block; 14, 15; 14, 28; 14, 41; 14, 55; 14, 72; 14, 81; 15, if_statement; 15, 16; 15, 22; 16, not_operator; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 21; 20, identifier:start; 21, identifier:int; 22, block; 22, 23; 23, raise_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:TypeError; 26, argument_list; 26, 27; 27, string:"start argument must be int"; 28, if_statement; 28, 29; 28, 35; 29, not_operator; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:isinstance; 32, argument_list; 32, 33; 32, 34; 33, identifier:stop; 34, identifier:int; 35, block; 35, 36; 36, raise_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:TypeError; 39, argument_list; 39, 40; 40, string:"stop argument must be int"; 41, if_statement; 41, 42; 41, 43; 41, 49; 42, identifier:withscores; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:args; 47, list:[b'WITHSCORES']; 47, 48; 48, string:b'WITHSCORES'; 49, else_clause; 49, 50; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:args; 54, list:[]; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:fut; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:execute; 62, argument_list; 62, 63; 62, 64; 62, 65; 62, 66; 62, 67; 62, 69; 63, string:b'ZREVRANGE'; 64, identifier:key; 65, identifier:start; 66, identifier:stop; 67, list_splat; 67, 68; 68, identifier:args; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:encoding; 71, identifier:encoding; 72, if_statement; 72, 73; 72, 74; 73, identifier:withscores; 74, block; 74, 75; 75, return_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:wait_convert; 78, argument_list; 78, 79; 78, 80; 79, identifier:fut; 80, identifier:pairs_int_or_float; 81, return_statement; 81, 82; 82, identifier:fut | def zrevrange(self, key, start, stop, withscores=False, encoding=_NOTSET):
if not isinstance(start, int):
raise TypeError("start argument must be int")
if not isinstance(stop, int):
raise TypeError("stop argument must be int")
if withscores:
args = [b'WITHSCORES']
else:
args = []
fut = self.execute(b'ZREVRANGE', key, start, stop, *args,
encoding=encoding)
if withscores:
return wait_convert(fut, pairs_int_or_float)
return fut |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 34; 2, function_name:zrevrangebyscore; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 12; 3, 18; 3, 19; 3, 22; 3, 25; 3, 28; 3, 31; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:max; 8, call; 8, 9; 8, 10; 9, identifier:float; 10, argument_list; 10, 11; 11, string:'inf'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:min; 14, call; 14, 15; 14, 16; 15, identifier:float; 16, argument_list; 16, 17; 17, string:'-inf'; 18, keyword_separator; 19, default_parameter; 19, 20; 19, 21; 20, identifier:exclude; 21, None; 22, default_parameter; 22, 23; 22, 24; 23, identifier:withscores; 24, False; 25, default_parameter; 25, 26; 25, 27; 26, identifier:offset; 27, None; 28, default_parameter; 28, 29; 28, 30; 29, identifier:count; 30, None; 31, default_parameter; 31, 32; 31, 33; 32, identifier:encoding; 33, identifier:_NOTSET; 34, block; 34, 35; 34, 50; 34, 65; 34, 90; 34, 107; 34, 124; 34, 135; 34, 139; 34, 147; 34, 166; 34, 183; 34, 192; 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:min; 41, tuple; 41, 42; 41, 43; 42, identifier:int; 43, identifier:float; 44, block; 44, 45; 45, raise_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:TypeError; 48, argument_list; 48, 49; 49, string:"min argument must be int or float"; 50, if_statement; 50, 51; 50, 59; 51, not_operator; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:isinstance; 54, argument_list; 54, 55; 54, 56; 55, identifier:max; 56, tuple; 56, 57; 56, 58; 57, identifier:int; 58, identifier:float; 59, block; 59, 60; 60, raise_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:TypeError; 63, argument_list; 63, 64; 64, string:"max argument must be int or float"; 65, if_statement; 65, 66; 65, 84; 66, boolean_operator:or; 66, 67; 66, 75; 66, 76; 67, parenthesized_expression; 67, 68; 68, boolean_operator:and; 68, 69; 68, 72; 69, comparison_operator:is; 69, 70; 69, 71; 70, identifier:offset; 71, None; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:count; 74, None; 75, line_continuation:\; 76, parenthesized_expression; 76, 77; 77, boolean_operator:and; 77, 78; 77, 81; 78, comparison_operator:is; 78, 79; 78, 80; 79, identifier:count; 80, None; 81, comparison_operator:is; 81, 82; 81, 83; 82, identifier:offset; 83, None; 84, block; 84, 85; 85, raise_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:TypeError; 88, argument_list; 88, 89; 89, string:"offset and count must both be specified"; 90, if_statement; 90, 91; 90, 101; 91, boolean_operator:and; 91, 92; 91, 95; 92, comparison_operator:is; 92, 93; 92, 94; 93, identifier:offset; 94, None; 95, not_operator; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:isinstance; 98, argument_list; 98, 99; 98, 100; 99, identifier:offset; 100, identifier:int; 101, block; 101, 102; 102, raise_statement; 102, 103; 103, call; 103, 104; 103, 105; 104, identifier:TypeError; 105, argument_list; 105, 106; 106, string:"offset argument must be int"; 107, if_statement; 107, 108; 107, 118; 108, boolean_operator:and; 108, 109; 108, 112; 109, comparison_operator:is; 109, 110; 109, 111; 110, identifier:count; 111, None; 112, not_operator; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:isinstance; 115, argument_list; 115, 116; 115, 117; 116, identifier:count; 117, identifier:int; 118, block; 118, 119; 119, raise_statement; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:TypeError; 122, argument_list; 122, 123; 123, string:"count argument must be int"; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 129; 126, pattern_list; 126, 127; 126, 128; 127, identifier:min; 128, identifier:max; 129, call; 129, 130; 129, 131; 130, identifier:_encode_min_max; 131, argument_list; 131, 132; 131, 133; 131, 134; 132, identifier:exclude; 133, identifier:min; 134, identifier:max; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:args; 138, list:[]; 139, if_statement; 139, 140; 139, 141; 140, identifier:withscores; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:args; 145, list:[b'WITHSCORES']; 145, 146; 146, string:b'WITHSCORES'; 147, if_statement; 147, 148; 147, 155; 148, boolean_operator:and; 148, 149; 148, 152; 149, comparison_operator:is; 149, 150; 149, 151; 150, identifier:offset; 151, None; 152, comparison_operator:is; 152, 153; 152, 154; 153, identifier:count; 154, None; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:args; 160, identifier:extend; 161, argument_list; 161, 162; 162, list:[b'LIMIT', offset, count]; 162, 163; 162, 164; 162, 165; 163, string:b'LIMIT'; 164, identifier:offset; 165, identifier:count; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:fut; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:self; 172, identifier:execute; 173, argument_list; 173, 174; 173, 175; 173, 176; 173, 177; 173, 178; 173, 180; 174, string:b'ZREVRANGEBYSCORE'; 175, identifier:key; 176, identifier:max; 177, identifier:min; 178, list_splat; 178, 179; 179, identifier:args; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:encoding; 182, identifier:encoding; 183, if_statement; 183, 184; 183, 185; 184, identifier:withscores; 185, block; 185, 186; 186, return_statement; 186, 187; 187, call; 187, 188; 187, 189; 188, identifier:wait_convert; 189, argument_list; 189, 190; 189, 191; 190, identifier:fut; 191, identifier:pairs_int_or_float; 192, return_statement; 192, 193; 193, identifier:fut | def zrevrangebyscore(self, key, max=float('inf'), min=float('-inf'),
*, exclude=None, withscores=False,
offset=None, count=None, encoding=_NOTSET):
if not isinstance(min, (int, float)):
raise TypeError("min argument must be int or float")
if not isinstance(max, (int, float)):
raise TypeError("max argument must be int or float")
if (offset is not None and count is None) or \
(count is not None and offset is None):
raise TypeError("offset and count must both be specified")
if offset is not None and not isinstance(offset, int):
raise TypeError("offset argument must be int")
if count is not None and not isinstance(count, int):
raise TypeError("count argument must be int")
min, max = _encode_min_max(exclude, min, max)
args = []
if withscores:
args = [b'WITHSCORES']
if offset is not None and count is not None:
args.extend([b'LIMIT', offset, count])
fut = self.execute(b'ZREVRANGEBYSCORE', key, max, min, *args,
encoding=encoding)
if withscores:
return wait_convert(fut, pairs_int_or_float)
return fut |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:zscore; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:key; 6, identifier:member; 7, block; 7, 8; 7, 19; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:fut; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:execute; 15, argument_list; 15, 16; 15, 17; 15, 18; 16, string:b'ZSCORE'; 17, identifier:key; 18, identifier:member; 19, return_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:wait_convert; 22, argument_list; 22, 23; 22, 24; 23, identifier:fut; 24, identifier:optional_int_or_float | def zscore(self, key, member):
fut = self.execute(b'ZSCORE', key, member)
return wait_convert(fut, optional_int_or_float) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:zunionstore; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 9; 3, 12; 4, identifier:self; 5, identifier:destkey; 6, identifier:key; 7, list_splat_pattern; 7, 8; 8, identifier:keys; 9, default_parameter; 9, 10; 9, 11; 10, identifier:with_weights; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:aggregate; 14, None; 15, block; 15, 16; 15, 23; 15, 30; 15, 34; 15, 94; 15, 142; 15, 155; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:keys; 19, binary_operator:+; 19, 20; 19, 22; 20, tuple; 20, 21; 21, identifier:key; 22, identifier:keys; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:numkeys; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, identifier:keys; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:args; 33, list:[]; 34, if_statement; 34, 35; 34, 36; 34, 85; 35, identifier:with_weights; 36, block; 36, 37; 36, 53; 36, 58; 36, 78; 37, assert_statement; 37, 38; 37, 51; 38, call; 38, 39; 38, 40; 39, identifier:all; 40, generator_expression; 40, 41; 40, 48; 41, call; 41, 42; 41, 43; 42, identifier:isinstance; 43, argument_list; 43, 44; 43, 45; 44, identifier:val; 45, tuple; 45, 46; 45, 47; 46, identifier:list; 47, identifier:tuple; 48, for_in_clause; 48, 49; 48, 50; 49, identifier:val; 50, identifier:keys; 51, parenthesized_expression; 51, 52; 52, string:"All key arguments must be (key, weight) tuples"; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:weights; 56, list:['WEIGHTS']; 56, 57; 57, string:'WEIGHTS'; 58, for_statement; 58, 59; 58, 62; 58, 63; 59, pattern_list; 59, 60; 59, 61; 60, identifier:key; 61, identifier:weight; 62, identifier:keys; 63, block; 63, 64; 63, 71; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:args; 68, identifier:append; 69, argument_list; 69, 70; 70, identifier:key; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:weights; 75, identifier:append; 76, argument_list; 76, 77; 77, identifier:weight; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:args; 82, identifier:extend; 83, argument_list; 83, 84; 84, identifier:weights; 85, else_clause; 85, 86; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:args; 91, identifier:extend; 92, argument_list; 92, 93; 93, identifier:keys; 94, if_statement; 94, 95; 94, 100; 94, 110; 94, 126; 95, comparison_operator:is; 95, 96; 95, 97; 96, identifier:aggregate; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:ZSET_AGGREGATE_SUM; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:args; 105, identifier:extend; 106, argument_list; 106, 107; 107, tuple; 107, 108; 107, 109; 108, string:'AGGREGATE'; 109, string:'SUM'; 110, elif_clause; 110, 111; 110, 116; 111, comparison_operator:is; 111, 112; 111, 113; 112, identifier:aggregate; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:ZSET_AGGREGATE_MAX; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:args; 121, identifier:extend; 122, argument_list; 122, 123; 123, tuple; 123, 124; 123, 125; 124, string:'AGGREGATE'; 125, string:'MAX'; 126, elif_clause; 126, 127; 126, 132; 127, comparison_operator:is; 127, 128; 127, 129; 128, identifier:aggregate; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:ZSET_AGGREGATE_MIN; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:args; 137, identifier:extend; 138, argument_list; 138, 139; 139, tuple; 139, 140; 139, 141; 140, string:'AGGREGATE'; 141, string:'MIN'; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:fut; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:execute; 149, argument_list; 149, 150; 149, 151; 149, 152; 149, 153; 150, string:b'ZUNIONSTORE'; 151, identifier:destkey; 152, identifier:numkeys; 153, list_splat; 153, 154; 154, identifier:args; 155, return_statement; 155, 156; 156, identifier:fut | def zunionstore(self, destkey, key, *keys,
with_weights=False, aggregate=None):
keys = (key,) + keys
numkeys = len(keys)
args = []
if with_weights:
assert all(isinstance(val, (list, tuple)) for val in keys), (
"All key arguments must be (key, weight) tuples")
weights = ['WEIGHTS']
for key, weight in keys:
args.append(key)
weights.append(weight)
args.extend(weights)
else:
args.extend(keys)
if aggregate is self.ZSET_AGGREGATE_SUM:
args.extend(('AGGREGATE', 'SUM'))
elif aggregate is self.ZSET_AGGREGATE_MAX:
args.extend(('AGGREGATE', 'MAX'))
elif aggregate is self.ZSET_AGGREGATE_MIN:
args.extend(('AGGREGATE', 'MIN'))
fut = self.execute(b'ZUNIONSTORE', destkey, numkeys, *args)
return fut |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:zscan; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:cursor; 8, integer:0; 9, default_parameter; 9, 10; 9, 11; 10, identifier:match; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:count; 14, None; 15, block; 15, 16; 15, 20; 15, 31; 15, 42; 15, 55; 15, 74; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:args; 19, list:[]; 20, if_statement; 20, 21; 20, 24; 21, comparison_operator:is; 21, 22; 21, 23; 22, identifier:match; 23, None; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, augmented_assignment:+=; 26, 27; 26, 28; 27, identifier:args; 28, list:[b'MATCH', match]; 28, 29; 28, 30; 29, string:b'MATCH'; 30, identifier:match; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:count; 34, None; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, augmented_assignment:+=; 37, 38; 37, 39; 38, identifier:args; 39, list:[b'COUNT', count]; 39, 40; 39, 41; 40, string:b'COUNT'; 41, identifier:count; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:fut; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:execute; 49, argument_list; 49, 50; 49, 51; 49, 52; 49, 53; 50, string:b'ZSCAN'; 51, identifier:key; 52, identifier:cursor; 53, list_splat; 53, 54; 54, identifier:args; 55, function_definition; 55, 56; 55, 57; 55, 59; 56, function_name:_converter; 57, parameters; 57, 58; 58, identifier:obj; 59, block; 59, 60; 60, return_statement; 60, 61; 61, tuple; 61, 62; 61, 68; 62, call; 62, 63; 62, 64; 63, identifier:int; 64, argument_list; 64, 65; 65, subscript; 65, 66; 65, 67; 66, identifier:obj; 67, integer:0; 68, call; 68, 69; 68, 70; 69, identifier:pairs_int_or_float; 70, argument_list; 70, 71; 71, subscript; 71, 72; 71, 73; 72, identifier:obj; 73, integer:1; 74, return_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:wait_convert; 77, argument_list; 77, 78; 77, 79; 78, identifier:fut; 79, identifier:_converter | def zscan(self, key, cursor=0, match=None, count=None):
args = []
if match is not None:
args += [b'MATCH', match]
if count is not None:
args += [b'COUNT', count]
fut = self.execute(b'ZSCAN', key, cursor, *args)
def _converter(obj):
return (int(obj[0]), pairs_int_or_float(obj[1]))
return wait_convert(fut, _converter) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:zpopmin; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 10; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:count; 8, None; 9, keyword_separator; 10, default_parameter; 10, 11; 10, 12; 11, identifier:encoding; 12, identifier:_NOTSET; 13, block; 13, 14; 13, 31; 13, 35; 13, 48; 13, 63; 14, if_statement; 14, 15; 14, 25; 15, boolean_operator:and; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:count; 18, None; 19, not_operator; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:isinstance; 22, argument_list; 22, 23; 22, 24; 23, identifier:count; 24, identifier:int; 25, block; 25, 26; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:TypeError; 29, argument_list; 29, 30; 30, string:"count argument must be int"; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:args; 34, list:[]; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:is; 36, 37; 36, 38; 37, identifier:count; 38, None; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:args; 44, identifier:extend; 45, argument_list; 45, 46; 46, list:[count]; 46, 47; 47, identifier:count; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:fut; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:execute; 55, argument_list; 55, 56; 55, 57; 55, 58; 55, 60; 56, string:b'ZPOPMIN'; 57, identifier:key; 58, list_splat; 58, 59; 59, identifier:args; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:encoding; 62, identifier:encoding; 63, return_statement; 63, 64; 64, identifier:fut | def zpopmin(self, key, count=None, *, encoding=_NOTSET):
if count is not None and not isinstance(count, int):
raise TypeError("count argument must be int")
args = []
if count is not None:
args.extend([count])
fut = self.execute(b'ZPOPMIN', key, *args, encoding=encoding)
return fut |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:zpopmax; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 10; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:count; 8, None; 9, keyword_separator; 10, default_parameter; 10, 11; 10, 12; 11, identifier:encoding; 12, identifier:_NOTSET; 13, block; 13, 14; 13, 31; 13, 35; 13, 48; 13, 63; 14, if_statement; 14, 15; 14, 25; 15, boolean_operator:and; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:count; 18, None; 19, not_operator; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:isinstance; 22, argument_list; 22, 23; 22, 24; 23, identifier:count; 24, identifier:int; 25, block; 25, 26; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:TypeError; 29, argument_list; 29, 30; 30, string:"count argument must be int"; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:args; 34, list:[]; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:is; 36, 37; 36, 38; 37, identifier:count; 38, None; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:args; 44, identifier:extend; 45, argument_list; 45, 46; 46, list:[count]; 46, 47; 47, identifier:count; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:fut; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:execute; 55, argument_list; 55, 56; 55, 57; 55, 58; 55, 60; 56, string:b'ZPOPMAX'; 57, identifier:key; 58, list_splat; 58, 59; 59, identifier:args; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:encoding; 62, identifier:encoding; 63, return_statement; 63, 64; 64, identifier:fut | def zpopmax(self, key, count=None, *, encoding=_NOTSET):
if count is not None and not isinstance(count, int):
raise TypeError("count argument must be int")
args = []
if count is not None:
args.extend([count])
fut = self.execute(b'ZPOPMAX', key, *args, encoding=encoding)
return fut |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:uniq; 3, parameters; 3, 4; 4, identifier:container; 5, block; 5, 6; 5, 107; 6, try_statement; 6, 7; 6, 27; 7, block; 7, 8; 8, return_statement; 8, 9; 9, comparison_operator:==; 9, 10; 9, 23; 10, call; 10, 11; 10, 12; 11, identifier:len; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:set; 15, generator_expression; 15, 16; 15, 20; 16, call; 16, 17; 16, 18; 17, identifier:unbool; 18, argument_list; 18, 19; 19, identifier:i; 20, for_in_clause; 20, 21; 20, 22; 21, identifier:i; 22, identifier:container; 23, call; 23, 24; 23, 25; 24, identifier:len; 25, argument_list; 25, 26; 26, identifier:container; 27, except_clause; 27, 28; 27, 29; 28, identifier:TypeError; 29, block; 29, 30; 30, try_statement; 30, 31; 30, 73; 31, block; 31, 32; 31, 45; 31, 56; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:sort; 35, call; 35, 36; 35, 37; 36, identifier:sorted; 37, generator_expression; 37, 38; 37, 42; 38, call; 38, 39; 38, 40; 39, identifier:unbool; 40, argument_list; 40, 41; 41, identifier:i; 42, for_in_clause; 42, 43; 42, 44; 43, identifier:i; 44, identifier:container; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:sliced; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:itertools; 51, identifier:islice; 52, argument_list; 52, 53; 52, 54; 52, 55; 53, identifier:sort; 54, integer:1; 55, None; 56, for_statement; 56, 57; 56, 60; 56, 65; 57, pattern_list; 57, 58; 57, 59; 58, identifier:i; 59, identifier:j; 60, call; 60, 61; 60, 62; 61, identifier:zip; 62, argument_list; 62, 63; 62, 64; 63, identifier:sort; 64, identifier:sliced; 65, block; 65, 66; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:==; 67, 68; 67, 69; 68, identifier:i; 69, identifier:j; 70, block; 70, 71; 71, return_statement; 71, 72; 72, False; 73, except_clause; 73, 74; 73, 77; 74, tuple; 74, 75; 74, 76; 75, identifier:NotImplementedError; 76, identifier:TypeError; 77, block; 77, 78; 77, 82; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:seen; 81, list:[]; 82, for_statement; 82, 83; 82, 84; 82, 85; 83, identifier:e; 84, identifier:container; 85, block; 85, 86; 85, 93; 85, 100; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:e; 89, call; 89, 90; 89, 91; 90, identifier:unbool; 91, argument_list; 91, 92; 92, identifier:e; 93, if_statement; 93, 94; 93, 97; 94, comparison_operator:in; 94, 95; 94, 96; 95, identifier:e; 96, identifier:seen; 97, block; 97, 98; 98, return_statement; 98, 99; 99, False; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:seen; 104, identifier:append; 105, argument_list; 105, 106; 106, identifier:e; 107, return_statement; 107, 108; 108, True | def uniq(container):
try:
return len(set(unbool(i) for i in container)) == len(container)
except TypeError:
try:
sort = sorted(unbool(i) for i in container)
sliced = itertools.islice(sort, 1, None)
for i, j in zip(sort, sliced):
if i == j:
return False
except (NotImplementedError, TypeError):
seen = []
for e in container:
e = unbool(e)
if e in seen:
return False
seen.append(e)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:split_traversal; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:traversal; 5, identifier:edges; 6, default_parameter; 6, 7; 6, 8; 7, identifier:edges_hash; 8, None; 9, block; 9, 10; 9, 24; 9, 46; 9, 66; 9, 83; 9, 93; 9, 149; 9, 255; 9, 264; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:traversal; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:np; 16, identifier:asanyarray; 17, argument_list; 17, 18; 17, 19; 18, identifier:traversal; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:dtype; 21, attribute; 21, 22; 21, 23; 22, identifier:np; 23, identifier:int64; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:edges_hash; 27, None; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:edges_hash; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:grouping; 35, identifier:hashable_rows; 36, argument_list; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:np; 40, identifier:sort; 41, argument_list; 41, 42; 41, 43; 42, identifier:edges; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:axis; 45, integer:1; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:trav_edge; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:np; 52, identifier:column_stack; 53, argument_list; 53, 54; 54, tuple; 54, 55; 54, 61; 55, subscript; 55, 56; 55, 57; 56, identifier:traversal; 57, slice; 57, 58; 57, 59; 58, colon; 59, unary_operator:-; 59, 60; 60, integer:1; 61, subscript; 61, 62; 61, 63; 62, identifier:traversal; 63, slice; 63, 64; 63, 65; 64, integer:1; 65, colon; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:trav_hash; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:grouping; 72, identifier:hashable_rows; 73, argument_list; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:np; 77, identifier:sort; 78, argument_list; 78, 79; 78, 80; 79, identifier:trav_edge; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:axis; 82, integer:1; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:contained; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:np; 89, identifier:in1d; 90, argument_list; 90, 91; 90, 92; 91, identifier:trav_hash; 92, identifier:edges_hash; 93, if_statement; 93, 94; 93, 99; 93, 105; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:contained; 97, identifier:all; 98, argument_list; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:split; 103, list:[traversal]; 103, 104; 104, identifier:traversal; 105, else_clause; 105, 106; 106, block; 106, 107; 106, 122; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:blocks; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:grouping; 113, identifier:blocks; 114, argument_list; 114, 115; 114, 116; 114, 119; 115, identifier:contained; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:min_len; 118, integer:1; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:only_nonzero; 121, True; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:split; 125, list_comprehension; 125, 126; 125, 146; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:np; 129, identifier:append; 130, argument_list; 130, 131; 130, 138; 131, subscript; 131, 132; 131, 135; 131, 137; 132, subscript; 132, 133; 132, 134; 133, identifier:trav_edge; 134, identifier:b; 135, slice; 135, 136; 136, colon; 137, integer:0; 138, subscript; 138, 139; 138, 145; 139, subscript; 139, 140; 139, 141; 140, identifier:trav_edge; 141, subscript; 141, 142; 141, 143; 142, identifier:b; 143, unary_operator:-; 143, 144; 144, integer:1; 145, integer:1; 146, for_in_clause; 146, 147; 146, 148; 147, identifier:b; 148, identifier:blocks; 149, for_statement; 149, 150; 149, 153; 149, 157; 150, pattern_list; 150, 151; 150, 152; 151, identifier:i; 152, identifier:t; 153, call; 153, 154; 153, 155; 154, identifier:enumerate; 155, argument_list; 155, 156; 156, identifier:split; 157, block; 157, 158; 157, 176; 157, 185; 157, 201; 157, 211; 157, 229; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 163; 160, subscript; 160, 161; 160, 162; 161, identifier:split; 162, identifier:i; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:np; 166, identifier:asanyarray; 167, argument_list; 167, 168; 167, 171; 168, subscript; 168, 169; 168, 170; 169, identifier:split; 170, identifier:i; 171, keyword_argument; 171, 172; 171, 173; 172, identifier:dtype; 173, attribute; 173, 174; 173, 175; 174, identifier:np; 175, identifier:int64; 176, if_statement; 176, 177; 176, 183; 177, comparison_operator:<=; 177, 178; 177, 182; 178, call; 178, 179; 178, 180; 179, identifier:len; 180, argument_list; 180, 181; 181, identifier:t; 182, integer:2; 183, block; 183, 184; 184, continue_statement; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:edge; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:np; 191, identifier:sort; 192, argument_list; 192, 193; 193, list:[t[0], t[-1]]; 193, 194; 193, 197; 194, subscript; 194, 195; 194, 196; 195, identifier:t; 196, integer:0; 197, subscript; 197, 198; 197, 199; 198, identifier:t; 199, unary_operator:-; 199, 200; 200, integer:1; 201, if_statement; 201, 202; 201, 209; 202, comparison_operator:==; 202, 203; 202, 208; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:edge; 206, identifier:ptp; 207, argument_list; 208, integer:0; 209, block; 209, 210; 210, continue_statement; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:close; 214, subscript; 214, 215; 214, 228; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:grouping; 218, identifier:hashable_rows; 219, argument_list; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:edge; 223, identifier:reshape; 224, argument_list; 224, 225; 225, tuple; 225, 226; 225, 227; 226, integer:1; 227, integer:2; 228, integer:0; 229, if_statement; 229, 230; 229, 233; 230, comparison_operator:in; 230, 231; 230, 232; 231, identifier:close; 232, identifier:edges_hash; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 239; 236, subscript; 236, 237; 236, 238; 237, identifier:split; 238, identifier:i; 239, call; 239, 240; 239, 251; 240, attribute; 240, 241; 240, 250; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:np; 244, identifier:append; 245, argument_list; 245, 246; 245, 247; 246, identifier:t; 247, subscript; 247, 248; 247, 249; 248, identifier:t; 249, integer:0; 250, identifier:astype; 251, argument_list; 251, 252; 252, attribute; 252, 253; 252, 254; 253, identifier:np; 254, identifier:int64; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:result; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:np; 261, identifier:array; 262, argument_list; 262, 263; 263, identifier:split; 264, return_statement; 264, 265; 265, identifier:result | def split_traversal(traversal,
edges,
edges_hash=None):
traversal = np.asanyarray(traversal,
dtype=np.int64)
if edges_hash is None:
edges_hash = grouping.hashable_rows(
np.sort(edges, axis=1))
trav_edge = np.column_stack((traversal[:-1],
traversal[1:]))
trav_hash = grouping.hashable_rows(
np.sort(trav_edge, axis=1))
contained = np.in1d(trav_hash, edges_hash)
if contained.all():
split = [traversal]
else:
blocks = grouping.blocks(contained,
min_len=1,
only_nonzero=True)
split = [np.append(trav_edge[b][:, 0],
trav_edge[b[-1]][1])
for b in blocks]
for i, t in enumerate(split):
split[i] = np.asanyarray(split[i], dtype=np.int64)
if len(t) <= 2:
continue
edge = np.sort([t[0], t[-1]])
if edge.ptp() == 0:
continue
close = grouping.hashable_rows(edge.reshape((1, 2)))[0]
if close in edges_hash:
split[i] = np.append(t, t[0]).astype(np.int64)
result = np.array(split)
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:fill_traversals; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:traversals; 5, identifier:edges; 6, default_parameter; 6, 7; 6, 8; 7, identifier:edges_hash; 8, None; 9, block; 9, 10; 9, 24; 9, 33; 9, 47; 9, 61; 9, 65; 9, 87; 9, 116; 9, 161; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:edges; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:np; 16, identifier:asanyarray; 17, argument_list; 17, 18; 17, 19; 18, identifier:edges; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:dtype; 21, attribute; 21, 22; 21, 23; 22, identifier:np; 23, identifier:int64; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:edges; 28, identifier:sort; 29, argument_list; 29, 30; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:axis; 32, integer:1; 33, if_statement; 33, 34; 33, 40; 34, comparison_operator:==; 34, 35; 34, 39; 35, call; 35, 36; 35, 37; 36, identifier:len; 37, argument_list; 37, 38; 38, identifier:traversals; 39, integer:0; 40, block; 40, 41; 41, return_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:edges; 45, identifier:copy; 46, argument_list; 47, if_statement; 47, 48; 47, 51; 48, comparison_operator:is; 48, 49; 48, 50; 49, identifier:edges_hash; 50, None; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:edges_hash; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:grouping; 58, identifier:hashable_rows; 59, argument_list; 59, 60; 60, identifier:edges; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:splits; 64, list:[]; 65, for_statement; 65, 66; 65, 67; 65, 68; 66, identifier:nodes; 67, identifier:traversals; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:splits; 73, identifier:extend; 74, argument_list; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:split_traversal; 77, argument_list; 77, 78; 77, 81; 77, 84; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:traversal; 80, identifier:nodes; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:edges; 83, identifier:edges; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:edges_hash; 86, identifier:edges_hash; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:included; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:util; 93, identifier:vstack_empty; 94, argument_list; 94, 95; 95, list_comprehension; 95, 96; 95, 113; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:np; 99, identifier:column_stack; 100, argument_list; 100, 101; 101, tuple; 101, 102; 101, 108; 102, subscript; 102, 103; 102, 104; 103, identifier:i; 104, slice; 104, 105; 104, 106; 105, colon; 106, unary_operator:-; 106, 107; 107, integer:1; 108, subscript; 108, 109; 108, 110; 109, identifier:i; 110, slice; 110, 111; 110, 112; 111, integer:1; 112, colon; 113, for_in_clause; 113, 114; 113, 115; 114, identifier:i; 115, identifier:splits; 116, if_statement; 116, 117; 116, 123; 116, 151; 117, comparison_operator:>; 117, 118; 117, 122; 118, call; 118, 119; 118, 120; 119, identifier:len; 120, argument_list; 120, 121; 121, identifier:included; 122, integer:0; 123, block; 123, 124; 123, 133; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:included; 128, identifier:sort; 129, argument_list; 129, 130; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:axis; 132, integer:1; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:splits; 137, identifier:extend; 138, argument_list; 138, 139; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:grouping; 142, identifier:boolean_rows; 143, argument_list; 143, 144; 143, 145; 143, 146; 144, identifier:edges; 145, identifier:included; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:operation; 148, attribute; 148, 149; 148, 150; 149, identifier:np; 150, identifier:setdiff1d; 151, else_clause; 151, 152; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:splits; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:edges; 159, identifier:copy; 160, argument_list; 161, return_statement; 161, 162; 162, identifier:splits | def fill_traversals(traversals, edges, edges_hash=None):
edges = np.asanyarray(edges, dtype=np.int64)
edges.sort(axis=1)
if len(traversals) == 0:
return edges.copy()
if edges_hash is None:
edges_hash = grouping.hashable_rows(edges)
splits = []
for nodes in traversals:
splits.extend(split_traversal(
traversal=nodes,
edges=edges,
edges_hash=edges_hash))
included = util.vstack_empty([np.column_stack((i[:-1], i[1:]))
for i in splits])
if len(included) > 0:
included.sort(axis=1)
splits.extend(grouping.boolean_rows(
edges,
included,
operation=np.setdiff1d))
else:
splits = edges.copy()
return splits |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:hashable_rows; 3, parameters; 3, 4; 3, 5; 4, identifier:data; 5, default_parameter; 5, 6; 5, 7; 6, identifier:digits; 7, None; 8, block; 8, 9; 8, 24; 8, 34; 8, 46; 8, 154; 8, 177; 8, 197; 9, if_statement; 9, 10; 9, 16; 10, comparison_operator:==; 10, 11; 10, 15; 11, call; 11, 12; 11, 13; 12, identifier:len; 13, argument_list; 13, 14; 14, identifier:data; 15, integer:0; 16, block; 16, 17; 17, return_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:np; 21, identifier:array; 22, argument_list; 22, 23; 23, list:[]; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:as_int; 27, call; 27, 28; 27, 29; 28, identifier:float_to_int; 29, argument_list; 29, 30; 29, 31; 30, identifier:data; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:digits; 33, identifier:digits; 34, if_statement; 34, 35; 34, 43; 35, comparison_operator:==; 35, 36; 35, 42; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, attribute; 39, 40; 39, 41; 40, identifier:as_int; 41, identifier:shape; 42, integer:1; 43, block; 43, 44; 44, return_statement; 44, 45; 45, identifier:as_int; 46, if_statement; 46, 47; 46, 63; 47, boolean_operator:and; 47, 48; 47, 56; 48, comparison_operator:==; 48, 49; 48, 55; 49, call; 49, 50; 49, 51; 50, identifier:len; 51, argument_list; 51, 52; 52, attribute; 52, 53; 52, 54; 53, identifier:as_int; 54, identifier:shape; 55, integer:2; 56, comparison_operator:<=; 56, 57; 56, 62; 57, subscript; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:as_int; 60, identifier:shape; 61, integer:1; 62, integer:4; 63, block; 63, 64; 63, 82; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:precision; 67, call; 67, 68; 67, 69; 68, identifier:int; 69, argument_list; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:np; 73, identifier:floor; 74, argument_list; 74, 75; 75, binary_operator:/; 75, 76; 75, 77; 76, integer:64; 77, subscript; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:as_int; 80, identifier:shape; 81, integer:1; 82, if_statement; 82, 83; 82, 100; 83, comparison_operator:<; 83, 84; 83, 94; 84, call; 84, 85; 84, 93; 85, attribute; 85, 86; 85, 92; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:np; 89, identifier:abs; 90, argument_list; 90, 91; 91, identifier:as_int; 92, identifier:max; 93, argument_list; 94, binary_operator:**; 94, 95; 94, 96; 95, integer:2; 96, parenthesized_expression; 96, 97; 97, binary_operator:-; 97, 98; 97, 99; 98, identifier:precision; 99, integer:1; 100, block; 100, 101; 100, 118; 100, 152; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:hashable; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:np; 107, identifier:zeros; 108, argument_list; 108, 109; 108, 113; 109, call; 109, 110; 109, 111; 110, identifier:len; 111, argument_list; 111, 112; 112, identifier:as_int; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:dtype; 115, attribute; 115, 116; 115, 117; 116, identifier:np; 117, identifier:int64; 118, for_statement; 118, 119; 118, 122; 118, 135; 119, pattern_list; 119, 120; 119, 121; 120, identifier:offset; 121, identifier:column; 122, call; 122, 123; 122, 124; 123, identifier:enumerate; 124, argument_list; 124, 125; 125, attribute; 125, 126; 125, 134; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:as_int; 129, identifier:astype; 130, argument_list; 130, 131; 131, attribute; 131, 132; 131, 133; 132, identifier:np; 133, identifier:int64; 134, identifier:T; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:np; 140, identifier:bitwise_xor; 141, argument_list; 141, 142; 141, 143; 141, 149; 142, identifier:hashable; 143, binary_operator:<<; 143, 144; 143, 145; 144, identifier:column; 145, parenthesized_expression; 145, 146; 146, binary_operator:*; 146, 147; 146, 148; 147, identifier:offset; 148, identifier:precision; 149, keyword_argument; 149, 150; 149, 151; 150, identifier:out; 151, identifier:hashable; 152, return_statement; 152, 153; 153, identifier:hashable; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:dtype; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:np; 160, identifier:dtype; 161, argument_list; 161, 162; 162, tuple; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:np; 165, identifier:void; 166, binary_operator:*; 166, 167; 166, 172; 167, attribute; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:as_int; 170, identifier:dtype; 171, identifier:itemsize; 172, subscript; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:as_int; 175, identifier:shape; 176, integer:1; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:hashable; 180, call; 180, 181; 180, 194; 181, attribute; 181, 182; 181, 193; 182, call; 182, 183; 182, 191; 183, attribute; 183, 184; 183, 190; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:np; 187, identifier:ascontiguousarray; 188, argument_list; 188, 189; 189, identifier:as_int; 190, identifier:view; 191, argument_list; 191, 192; 192, identifier:dtype; 193, identifier:reshape; 194, argument_list; 194, 195; 195, unary_operator:-; 195, 196; 196, integer:1; 197, return_statement; 197, 198; 198, identifier:hashable | def hashable_rows(data, digits=None):
if len(data) == 0:
return np.array([])
as_int = float_to_int(data, digits=digits)
if len(as_int.shape) == 1:
return as_int
if len(as_int.shape) == 2 and as_int.shape[1] <= 4:
precision = int(np.floor(64 / as_int.shape[1]))
if np.abs(as_int).max() < 2**(precision - 1):
hashable = np.zeros(len(as_int), dtype=np.int64)
for offset, column in enumerate(as_int.astype(np.int64).T):
np.bitwise_xor(hashable,
column << (offset * precision),
out=hashable)
return hashable
dtype = np.dtype((np.void, as_int.dtype.itemsize * as_int.shape[1]))
hashable = np.ascontiguousarray(as_int).view(dtype).reshape(-1)
return hashable |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:interpolate_nans_1d; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:x; 5, identifier:y; 6, default_parameter; 6, 7; 6, 8; 7, identifier:kind; 8, string:'linear'; 9, block; 9, 10; 9, 19; 9, 25; 9, 31; 9, 40; 9, 117; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:x_sort_args; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:np; 16, identifier:argsort; 17, argument_list; 17, 18; 18, identifier:x; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:x; 22, subscript; 22, 23; 22, 24; 23, identifier:x; 24, identifier:x_sort_args; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:y; 28, subscript; 28, 29; 28, 30; 29, identifier:y; 30, identifier:x_sort_args; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:nans; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:np; 37, identifier:isnan; 38, argument_list; 38, 39; 39, identifier:y; 40, if_statement; 40, 41; 40, 44; 40, 66; 40, 102; 41, comparison_operator:==; 41, 42; 41, 43; 42, identifier:kind; 43, string:'linear'; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:y; 49, identifier:nans; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:np; 53, identifier:interp; 54, argument_list; 54, 55; 54, 58; 54, 62; 55, subscript; 55, 56; 55, 57; 56, identifier:x; 57, identifier:nans; 58, subscript; 58, 59; 58, 60; 59, identifier:x; 60, unary_operator:~; 60, 61; 61, identifier:nans; 62, subscript; 62, 63; 62, 64; 63, identifier:y; 64, unary_operator:~; 64, 65; 65, identifier:nans; 66, elif_clause; 66, 67; 66, 70; 67, comparison_operator:==; 67, 68; 67, 69; 68, identifier:kind; 69, string:'log'; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:y; 75, identifier:nans; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:np; 79, identifier:interp; 80, argument_list; 80, 81; 80, 89; 80, 98; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:np; 84, identifier:log; 85, argument_list; 85, 86; 86, subscript; 86, 87; 86, 88; 87, identifier:x; 88, identifier:nans; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:np; 92, identifier:log; 93, argument_list; 93, 94; 94, subscript; 94, 95; 94, 96; 95, identifier:x; 96, unary_operator:~; 96, 97; 97, identifier:nans; 98, subscript; 98, 99; 98, 100; 99, identifier:y; 100, unary_operator:~; 100, 101; 101, identifier:nans; 102, else_clause; 102, 103; 103, block; 103, 104; 104, raise_statement; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:ValueError; 107, argument_list; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, string:'Unknown option for kind: {0}'; 111, identifier:format; 112, argument_list; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:str; 115, argument_list; 115, 116; 116, identifier:kind; 117, return_statement; 117, 118; 118, subscript; 118, 119; 118, 120; 119, identifier:y; 120, identifier:x_sort_args | def interpolate_nans_1d(x, y, kind='linear'):
x_sort_args = np.argsort(x)
x = x[x_sort_args]
y = y[x_sort_args]
nans = np.isnan(y)
if kind == 'linear':
y[nans] = np.interp(x[nans], x[~nans], y[~nans])
elif kind == 'log':
y[nans] = np.interp(np.log(x[nans]), np.log(x[~nans]), y[~nans])
else:
raise ValueError('Unknown option for kind: {0}'.format(str(kind)))
return y[x_sort_args] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:interpolate_1d; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 8; 4, identifier:x; 5, identifier:xp; 6, list_splat_pattern; 6, 7; 7, identifier:args; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 13; 10, 25; 10, 35; 10, 50; 10, 56; 10, 68; 10, 77; 10, 87; 10, 93; 10, 103; 10, 109; 10, 118; 10, 127; 10, 136; 10, 152; 10, 161; 10, 196; 10, 235; 10, 253; 10, 263; 10, 275; 10, 294; 10, 298; 10, 397; 11, expression_statement; 11, 12; 12, identifier:r; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:fill_value; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:kwargs; 19, identifier:pop; 20, argument_list; 20, 21; 20, 22; 21, string:'fill_value'; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:nan; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:axis; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:kwargs; 31, identifier:pop; 32, argument_list; 32, 33; 32, 34; 33, string:'axis'; 34, integer:0; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:x; 38, call; 38, 39; 38, 47; 39, attribute; 39, 40; 39, 46; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:np; 43, identifier:asanyarray; 44, argument_list; 44, 45; 45, identifier:x; 46, identifier:reshape; 47, argument_list; 47, 48; 48, unary_operator:-; 48, 49; 49, integer:1; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:ndim; 53, attribute; 53, 54; 53, 55; 54, identifier:xp; 55, identifier:ndim; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:sort_args; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:np; 62, identifier:argsort; 63, argument_list; 63, 64; 63, 65; 64, identifier:xp; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:axis; 67, identifier:axis; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:sort_x; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:np; 74, identifier:argsort; 75, argument_list; 75, 76; 76, identifier:x; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:sorter; 80, call; 80, 81; 80, 82; 81, identifier:broadcast_indices; 82, argument_list; 82, 83; 82, 84; 82, 85; 82, 86; 83, identifier:xp; 84, identifier:sort_args; 85, identifier:ndim; 86, identifier:axis; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:xp; 90, subscript; 90, 91; 90, 92; 91, identifier:xp; 92, identifier:sorter; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:variables; 96, list_comprehension; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:arr; 99, identifier:sorter; 100, for_in_clause; 100, 101; 100, 102; 101, identifier:arr; 102, identifier:args; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:x_array; 106, subscript; 106, 107; 106, 108; 107, identifier:x; 108, identifier:sort_x; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:expand; 112, binary_operator:*; 112, 113; 112, 117; 113, list:[np.newaxis]; 113, 114; 114, attribute; 114, 115; 114, 116; 115, identifier:np; 116, identifier:newaxis; 117, identifier:ndim; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:expand; 122, identifier:axis; 123, call; 123, 124; 123, 125; 124, identifier:slice; 125, argument_list; 125, 126; 126, None; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:x_array; 130, subscript; 130, 131; 130, 132; 131, identifier:x_array; 132, call; 132, 133; 132, 134; 133, identifier:tuple; 134, argument_list; 134, 135; 135, identifier:expand; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:minv; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:np; 142, identifier:apply_along_axis; 143, argument_list; 143, 144; 143, 147; 143, 148; 143, 149; 144, attribute; 144, 145; 144, 146; 145, identifier:np; 146, identifier:searchsorted; 147, identifier:axis; 148, identifier:xp; 149, subscript; 149, 150; 149, 151; 150, identifier:x; 151, identifier:sort_x; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:minv2; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:np; 158, identifier:copy; 159, argument_list; 159, 160; 160, identifier:minv; 161, if_statement; 161, 162; 161, 190; 162, boolean_operator:and; 162, 163; 162, 187; 163, parenthesized_expression; 163, 164; 164, boolean_operator:or; 164, 165; 164, 178; 165, parenthesized_expression; 165, 166; 166, comparison_operator:==; 166, 167; 166, 173; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:np; 170, identifier:max; 171, argument_list; 171, 172; 172, identifier:minv; 173, subscript; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:xp; 176, identifier:shape; 177, identifier:axis; 178, parenthesized_expression; 178, 179; 179, comparison_operator:==; 179, 180; 179, 186; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:np; 183, identifier:min; 184, argument_list; 184, 185; 185, identifier:minv; 186, integer:0; 187, comparison_operator:is; 187, 188; 187, 189; 188, identifier:fill_value; 189, None; 190, block; 190, 191; 191, raise_statement; 191, 192; 192, call; 192, 193; 192, 194; 193, identifier:ValueError; 194, argument_list; 194, 195; 195, string:'Interpolation point out of data bounds encountered'; 196, if_statement; 196, 197; 196, 209; 197, comparison_operator:==; 197, 198; 197, 204; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:np; 201, identifier:max; 202, argument_list; 202, 203; 203, identifier:minv; 204, subscript; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:xp; 207, identifier:shape; 208, identifier:axis; 209, block; 209, 210; 209, 217; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:warnings; 214, identifier:warn; 215, argument_list; 215, 216; 216, string:'Interpolation point out of data bounds encountered'; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 228; 219, subscript; 219, 220; 219, 221; 220, identifier:minv2; 221, comparison_operator:==; 221, 222; 221, 223; 222, identifier:minv; 223, subscript; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:xp; 226, identifier:shape; 227, identifier:axis; 228, binary_operator:-; 228, 229; 228, 234; 229, subscript; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:xp; 232, identifier:shape; 233, identifier:axis; 234, integer:1; 235, if_statement; 235, 236; 235, 244; 236, comparison_operator:==; 236, 237; 236, 243; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:np; 240, identifier:min; 241, argument_list; 241, 242; 242, identifier:minv; 243, integer:0; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 252; 247, subscript; 247, 248; 247, 249; 248, identifier:minv2; 249, comparison_operator:==; 249, 250; 249, 251; 250, identifier:minv; 251, integer:0; 252, integer:1; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:above; 256, call; 256, 257; 256, 258; 257, identifier:broadcast_indices; 258, argument_list; 258, 259; 258, 260; 258, 261; 258, 262; 259, identifier:xp; 260, identifier:minv2; 261, identifier:ndim; 262, identifier:axis; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 266; 265, identifier:below; 266, call; 266, 267; 266, 268; 267, identifier:broadcast_indices; 268, argument_list; 268, 269; 268, 270; 268, 273; 268, 274; 269, identifier:xp; 270, binary_operator:-; 270, 271; 270, 272; 271, identifier:minv2; 272, integer:1; 273, identifier:ndim; 274, identifier:axis; 275, if_statement; 275, 276; 275, 286; 276, call; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:np; 279, identifier:any; 280, argument_list; 280, 281; 281, comparison_operator:<; 281, 282; 281, 283; 282, identifier:x_array; 283, subscript; 283, 284; 283, 285; 284, identifier:xp; 285, identifier:below; 286, block; 286, 287; 287, expression_statement; 287, 288; 288, call; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:warnings; 291, identifier:warn; 292, argument_list; 292, 293; 293, string:'Interpolation point out of data bounds encountered'; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:ret; 297, list:[]; 298, for_statement; 298, 299; 298, 300; 298, 301; 299, identifier:var; 300, identifier:variables; 301, block; 301, 302; 301, 334; 301, 346; 301, 356; 301, 390; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 305; 304, identifier:var_interp; 305, binary_operator:+; 305, 306; 305, 309; 306, subscript; 306, 307; 306, 308; 307, identifier:var; 308, identifier:below; 309, binary_operator:*; 309, 310; 309, 318; 310, parenthesized_expression; 310, 311; 311, binary_operator:-; 311, 312; 311, 315; 312, subscript; 312, 313; 312, 314; 313, identifier:var; 314, identifier:above; 315, subscript; 315, 316; 315, 317; 316, identifier:var; 317, identifier:below; 318, parenthesized_expression; 318, 319; 319, binary_operator:/; 319, 320; 319, 326; 320, parenthesized_expression; 320, 321; 321, binary_operator:-; 321, 322; 321, 323; 322, identifier:x_array; 323, subscript; 323, 324; 323, 325; 324, identifier:xp; 325, identifier:below; 326, parenthesized_expression; 326, 327; 327, binary_operator:-; 327, 328; 327, 331; 328, subscript; 328, 329; 328, 330; 329, identifier:xp; 330, identifier:above; 331, subscript; 331, 332; 331, 333; 332, identifier:xp; 333, identifier:below; 334, expression_statement; 334, 335; 335, assignment; 335, 336; 335, 345; 336, subscript; 336, 337; 336, 338; 337, identifier:var_interp; 338, comparison_operator:==; 338, 339; 338, 340; 339, identifier:minv; 340, subscript; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:xp; 343, identifier:shape; 344, identifier:axis; 345, identifier:fill_value; 346, expression_statement; 346, 347; 347, assignment; 347, 348; 347, 355; 348, subscript; 348, 349; 348, 350; 349, identifier:var_interp; 350, comparison_operator:<; 350, 351; 350, 352; 351, identifier:x_array; 352, subscript; 352, 353; 352, 354; 353, identifier:xp; 354, identifier:below; 355, identifier:fill_value; 356, if_statement; 356, 357; 356, 365; 357, comparison_operator:>; 357, 358; 357, 361; 358, subscript; 358, 359; 358, 360; 359, identifier:x; 360, integer:0; 361, subscript; 361, 362; 361, 363; 362, identifier:x; 363, unary_operator:-; 363, 364; 364, integer:1; 365, block; 365, 366; 366, expression_statement; 366, 367; 367, assignment; 367, 368; 367, 369; 368, identifier:var_interp; 369, call; 369, 370; 369, 373; 370, attribute; 370, 371; 370, 372; 371, identifier:np; 372, identifier:swapaxes; 373, argument_list; 373, 374; 373, 388; 373, 389; 374, subscript; 374, 375; 374, 383; 375, call; 375, 376; 375, 379; 376, attribute; 376, 377; 376, 378; 377, identifier:np; 378, identifier:swapaxes; 379, argument_list; 379, 380; 379, 381; 379, 382; 380, identifier:var_interp; 381, integer:0; 382, identifier:axis; 383, slice; 383, 384; 383, 385; 383, 386; 384, colon; 385, colon; 386, unary_operator:-; 386, 387; 387, integer:1; 388, integer:0; 389, identifier:axis; 390, expression_statement; 390, 391; 391, call; 391, 392; 391, 395; 392, attribute; 392, 393; 392, 394; 393, identifier:ret; 394, identifier:append; 395, argument_list; 395, 396; 396, identifier:var_interp; 397, if_statement; 397, 398; 397, 404; 397, 409; 398, comparison_operator:==; 398, 399; 398, 403; 399, call; 399, 400; 399, 401; 400, identifier:len; 401, argument_list; 401, 402; 402, identifier:ret; 403, integer:1; 404, block; 404, 405; 405, return_statement; 405, 406; 406, subscript; 406, 407; 406, 408; 407, identifier:ret; 408, integer:0; 409, else_clause; 409, 410; 410, block; 410, 411; 411, return_statement; 411, 412; 412, identifier:ret | def interpolate_1d(x, xp, *args, **kwargs):
r
fill_value = kwargs.pop('fill_value', np.nan)
axis = kwargs.pop('axis', 0)
x = np.asanyarray(x).reshape(-1)
ndim = xp.ndim
sort_args = np.argsort(xp, axis=axis)
sort_x = np.argsort(x)
sorter = broadcast_indices(xp, sort_args, ndim, axis)
xp = xp[sorter]
variables = [arr[sorter] for arr in args]
x_array = x[sort_x]
expand = [np.newaxis] * ndim
expand[axis] = slice(None)
x_array = x_array[tuple(expand)]
minv = np.apply_along_axis(np.searchsorted, axis, xp, x[sort_x])
minv2 = np.copy(minv)
if ((np.max(minv) == xp.shape[axis]) or (np.min(minv) == 0)) and fill_value is None:
raise ValueError('Interpolation point out of data bounds encountered')
if np.max(minv) == xp.shape[axis]:
warnings.warn('Interpolation point out of data bounds encountered')
minv2[minv == xp.shape[axis]] = xp.shape[axis] - 1
if np.min(minv) == 0:
minv2[minv == 0] = 1
above = broadcast_indices(xp, minv2, ndim, axis)
below = broadcast_indices(xp, minv2 - 1, ndim, axis)
if np.any(x_array < xp[below]):
warnings.warn('Interpolation point out of data bounds encountered')
ret = []
for var in variables:
var_interp = var[below] + (var[above] - var[below]) * ((x_array - xp[below])
/ (xp[above] - xp[below]))
var_interp[minv == xp.shape[axis]] = fill_value
var_interp[x_array < xp[below]] = fill_value
if x[0] > x[-1]:
var_interp = np.swapaxes(np.swapaxes(var_interp, 0, axis)[::-1], 0, axis)
ret.append(var_interp)
if len(ret) == 1:
return ret[0]
else:
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:log_interpolate_1d; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 8; 4, identifier:x; 5, identifier:xp; 6, list_splat_pattern; 6, 7; 7, identifier:args; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 13; 10, 25; 10, 35; 10, 44; 10, 53; 11, expression_statement; 11, 12; 12, identifier:r; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:fill_value; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:kwargs; 19, identifier:pop; 20, argument_list; 20, 21; 20, 22; 21, string:'fill_value'; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:nan; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:axis; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:kwargs; 31, identifier:pop; 32, argument_list; 32, 33; 32, 34; 33, string:'axis'; 34, integer:0; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:log_x; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:np; 41, identifier:log; 42, argument_list; 42, 43; 43, identifier:x; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:log_xp; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:np; 50, identifier:log; 51, argument_list; 51, 52; 52, identifier:xp; 53, return_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:interpolate_1d; 56, argument_list; 56, 57; 56, 58; 56, 59; 56, 61; 56, 64; 57, identifier:log_x; 58, identifier:log_xp; 59, list_splat; 59, 60; 60, identifier:args; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:axis; 63, identifier:axis; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:fill_value; 66, identifier:fill_value | def log_interpolate_1d(x, xp, *args, **kwargs):
r
fill_value = kwargs.pop('fill_value', np.nan)
axis = kwargs.pop('axis', 0)
log_x = np.log(x)
log_xp = np.log(xp)
return interpolate_1d(log_x, log_xp, *args, axis=axis, fill_value=fill_value) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_find_append_zero_crossings; 3, parameters; 3, 4; 3, 5; 4, identifier:x; 5, identifier:y; 6, block; 6, 7; 6, 9; 6, 39; 6, 50; 6, 61; 6, 70; 6, 76; 6, 82; 6, 97; 6, 103; 6, 109; 7, expression_statement; 7, 8; 8, identifier:r; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:crossings; 12, call; 12, 13; 12, 14; 13, identifier:find_intersections; 14, argument_list; 14, 15; 14, 20; 14, 25; 15, subscript; 15, 16; 15, 17; 16, identifier:x; 17, slice; 17, 18; 17, 19; 18, integer:1; 19, colon; 20, subscript; 20, 21; 20, 22; 21, identifier:y; 22, slice; 22, 23; 22, 24; 23, integer:1; 24, colon; 25, binary_operator:*; 25, 26; 25, 36; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:np; 29, identifier:zeros_like; 30, argument_list; 30, 31; 31, subscript; 31, 32; 31, 33; 32, identifier:y; 33, slice; 33, 34; 33, 35; 34, integer:1; 35, colon; 36, attribute; 36, 37; 36, 38; 37, identifier:y; 38, identifier:units; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:x; 42, call; 42, 43; 42, 44; 43, identifier:concatenate; 44, argument_list; 44, 45; 45, tuple; 45, 46; 45, 47; 46, identifier:x; 47, subscript; 47, 48; 47, 49; 48, identifier:crossings; 49, integer:0; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:y; 53, call; 53, 54; 53, 55; 54, identifier:concatenate; 55, argument_list; 55, 56; 56, tuple; 56, 57; 56, 58; 57, identifier:y; 58, subscript; 58, 59; 58, 60; 59, identifier:crossings; 60, integer:1; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:sort_idx; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:np; 67, identifier:argsort; 68, argument_list; 68, 69; 69, identifier:x; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:x; 73, subscript; 73, 74; 73, 75; 74, identifier:x; 75, identifier:sort_idx; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:y; 79, subscript; 79, 80; 79, 81; 80, identifier:y; 81, identifier:sort_idx; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:keep_idx; 85, comparison_operator:>; 85, 86; 85, 96; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:np; 89, identifier:ediff1d; 90, argument_list; 90, 91; 90, 92; 91, identifier:x; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:to_end; 94, list:[1]; 94, 95; 95, integer:1; 96, integer:0; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:x; 100, subscript; 100, 101; 100, 102; 101, identifier:x; 102, identifier:keep_idx; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:y; 106, subscript; 106, 107; 106, 108; 107, identifier:y; 108, identifier:keep_idx; 109, return_statement; 109, 110; 110, expression_list; 110, 111; 110, 112; 111, identifier:x; 112, identifier:y | def _find_append_zero_crossings(x, y):
r
crossings = find_intersections(x[1:], y[1:], np.zeros_like(y[1:]) * y.units)
x = concatenate((x, crossings[0]))
y = concatenate((y, crossings[1]))
sort_idx = np.argsort(x)
x = x[sort_idx]
y = y[sort_idx]
keep_idx = np.ediff1d(x, to_end=[1]) > 0
x = x[keep_idx]
y = y[keep_idx]
return x, y |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort_ordered_objects; 3, parameters; 3, 4; 3, 5; 4, identifier:items; 5, default_parameter; 5, 6; 5, 7; 6, identifier:getter; 7, lambda; 7, 8; 7, 10; 8, lambda_parameters; 8, 9; 9, identifier:x; 10, identifier:x; 11, block; 11, 12; 12, return_statement; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, argument_list; 15, 16; 15, 17; 16, identifier:items; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:key; 19, lambda; 19, 20; 19, 22; 20, lambda_parameters; 20, 21; 21, identifier:x; 22, call; 22, 23; 22, 24; 23, identifier:getattr; 24, argument_list; 24, 25; 24, 29; 24, 32; 25, call; 25, 26; 25, 27; 26, identifier:getter; 27, argument_list; 27, 28; 28, identifier:x; 29, attribute; 29, 30; 29, 31; 30, identifier:OrderedBase; 31, identifier:CREATION_COUNTER_FIELD; 32, unary_operator:-; 32, 33; 33, integer:1 | def sort_ordered_objects(items, getter=lambda x: x):
return sorted(items, key=lambda x: getattr(getter(x), OrderedBase.CREATION_COUNTER_FIELD, -1)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:remove_fewwords_paragraphs; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 23; 5, 29; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:all_nodes; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:parser; 14, identifier:getElementsByTags; 15, argument_list; 15, 16; 15, 21; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:get_top_node; 20, argument_list; 21, list:['*']; 21, 22; 22, string:'*'; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:all_nodes; 27, identifier:reverse; 28, argument_list; 29, for_statement; 29, 30; 29, 31; 29, 32; 30, identifier:el; 31, identifier:all_nodes; 32, block; 32, 33; 32, 44; 32, 55; 32, 75; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:tag; 36, call; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:parser; 41, identifier:getTag; 42, argument_list; 42, 43; 43, identifier:el; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:text; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:parser; 52, identifier:getText; 53, argument_list; 53, 54; 54, identifier:el; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:stop_words; 58, call; 58, 59; 58, 73; 59, attribute; 59, 60; 59, 72; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:stopwords_class; 64, argument_list; 64, 65; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:language; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:get_language; 71, argument_list; 72, identifier:get_stopword_count; 73, argument_list; 73, 74; 74, identifier:text; 75, if_statement; 75, 76; 75, 128; 75, 138; 76, boolean_operator:and; 76, 77; 76, 111; 76, 112; 77, boolean_operator:and; 77, 78; 77, 94; 77, 95; 78, boolean_operator:and; 78, 79; 78, 87; 79, parenthesized_expression; 79, 80; 80, boolean_operator:or; 80, 81; 80, 84; 81, comparison_operator:!=; 81, 82; 81, 83; 82, identifier:tag; 83, string:'br'; 84, comparison_operator:!=; 84, 85; 84, 86; 85, identifier:text; 86, string:'\\r'; 87, comparison_operator:<; 87, 88; 87, 93; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:stop_words; 91, identifier:get_stopword_count; 92, argument_list; 93, integer:3; 94, line_continuation:\; 95, comparison_operator:==; 95, 96; 95, 110; 96, call; 96, 97; 96, 98; 97, identifier:len; 98, argument_list; 98, 99; 99, call; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:parser; 104, identifier:getElementsByTag; 105, argument_list; 105, 106; 105, 107; 106, identifier:el; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:tag; 109, string:'object'; 110, integer:0; 111, line_continuation:\; 112, comparison_operator:==; 112, 113; 112, 127; 113, call; 113, 114; 113, 115; 114, identifier:len; 115, argument_list; 115, 116; 116, call; 116, 117; 116, 122; 117, attribute; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:parser; 121, identifier:getElementsByTag; 122, argument_list; 122, 123; 122, 124; 123, identifier:el; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:tag; 126, string:'embed'; 127, integer:0; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 136; 131, attribute; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:parser; 135, identifier:remove; 136, argument_list; 136, 137; 137, identifier:el; 138, else_clause; 138, 139; 139, block; 139, 140; 139, 151; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:trimmed; 143, call; 143, 144; 143, 149; 144, attribute; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:parser; 148, identifier:getText; 149, argument_list; 149, 150; 150, identifier:el; 151, if_statement; 151, 152; 151, 165; 152, boolean_operator:and; 152, 153; 152, 159; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:trimmed; 156, identifier:startswith; 157, argument_list; 157, 158; 158, string:"("; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:trimmed; 162, identifier:endswith; 163, argument_list; 163, 164; 164, string:")"; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:self; 171, identifier:parser; 172, identifier:remove; 173, argument_list; 173, 174; 174, identifier:el | def remove_fewwords_paragraphs(self):
all_nodes = self.parser.getElementsByTags(self.get_top_node(), ['*'])
all_nodes.reverse()
for el in all_nodes:
tag = self.parser.getTag(el)
text = self.parser.getText(el)
stop_words = self.stopwords_class(language=self.get_language()).get_stopword_count(text)
if (tag != 'br' or text != '\\r') and stop_words.get_stopword_count() < 3 \
and len(self.parser.getElementsByTag(el, tag='object')) == 0 \
and len(self.parser.getElementsByTag(el, tag='embed')) == 0:
self.parser.remove(el)
else:
trimmed = self.parser.getText(el)
if trimmed.startswith("(") and trimmed.endswith(")"):
self.parser.remove(el) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:compare_baselines; 3, parameters; 3, 4; 3, 5; 4, identifier:old_baseline_filename; 5, identifier:new_baseline_filename; 6, block; 6, 7; 6, 14; 6, 21; 6, 28; 6, 33; 6, 38; 6, 46; 6, 53; 6, 57; 6, 64; 7, if_statement; 7, 8; 7, 11; 8, comparison_operator:==; 8, 9; 8, 10; 9, identifier:old_baseline_filename; 10, identifier:new_baseline_filename; 11, block; 11, 12; 12, raise_statement; 12, 13; 13, identifier:RedundantComparisonError; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:old_baseline; 17, call; 17, 18; 17, 19; 18, identifier:_get_baseline_from_file; 19, argument_list; 19, 20; 20, identifier:old_baseline_filename; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:new_baseline; 24, call; 24, 25; 24, 26; 25, identifier:_get_baseline_from_file; 26, argument_list; 26, 27; 27, identifier:new_baseline_filename; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:_remove_nonexistent_files_from_baseline; 31, argument_list; 31, 32; 32, identifier:old_baseline; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:_remove_nonexistent_files_from_baseline; 36, argument_list; 36, 37; 37, identifier:new_baseline; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:secrets_to_compare; 41, call; 41, 42; 41, 43; 42, identifier:_get_secrets_to_compare; 43, argument_list; 43, 44; 43, 45; 44, identifier:old_baseline; 45, identifier:new_baseline; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:total_reviews; 49, call; 49, 50; 49, 51; 50, identifier:len; 51, argument_list; 51, 52; 52, identifier:secrets_to_compare; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:current_index; 56, integer:0; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:secret_iterator; 60, call; 60, 61; 60, 62; 61, identifier:BidirectionalIterator; 62, argument_list; 62, 63; 63, identifier:secrets_to_compare; 64, for_statement; 64, 65; 64, 69; 64, 70; 65, pattern_list; 65, 66; 65, 67; 65, 68; 66, identifier:filename; 67, identifier:secret; 68, identifier:is_removed; 69, identifier:secret_iterator; 70, block; 70, 71; 70, 75; 70, 79; 70, 83; 70, 154; 70, 199; 70, 210; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:_clear_screen; 74, argument_list; 75, expression_statement; 75, 76; 76, augmented_assignment:+=; 76, 77; 76, 78; 77, identifier:current_index; 78, integer:1; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:header; 82, string:'{} {}'; 83, if_statement; 83, 84; 83, 85; 83, 119; 84, identifier:is_removed; 85, block; 85, 86; 85, 92; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:plugins_used; 89, subscript; 89, 90; 89, 91; 90, identifier:old_baseline; 91, string:'plugins_used'; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:header; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:header; 98, identifier:format; 99, argument_list; 99, 100; 99, 107; 100, call; 100, 101; 100, 102; 101, identifier:colorize; 102, argument_list; 102, 103; 102, 104; 103, string:'Status:'; 104, attribute; 104, 105; 104, 106; 105, identifier:AnsiColor; 106, identifier:BOLD; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, string:'>> {} <<'; 110, identifier:format; 111, argument_list; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:colorize; 114, argument_list; 114, 115; 114, 116; 115, string:'REMOVED'; 116, attribute; 116, 117; 116, 118; 117, identifier:AnsiColor; 118, identifier:RED; 119, else_clause; 119, 120; 120, block; 120, 121; 120, 127; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:plugins_used; 124, subscript; 124, 125; 124, 126; 125, identifier:new_baseline; 126, string:'plugins_used'; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:header; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:header; 133, identifier:format; 134, argument_list; 134, 135; 134, 142; 135, call; 135, 136; 135, 137; 136, identifier:colorize; 137, argument_list; 137, 138; 137, 139; 138, string:'Status:'; 139, attribute; 139, 140; 139, 141; 140, identifier:AnsiColor; 141, identifier:BOLD; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, string:'>> {} <<'; 145, identifier:format; 146, argument_list; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:colorize; 149, argument_list; 149, 150; 149, 151; 150, string:'ADDED'; 151, attribute; 151, 152; 151, 153; 152, identifier:AnsiColor; 153, identifier:LIGHT_GREEN; 154, try_statement; 154, 155; 154, 187; 155, block; 155, 156; 155, 171; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:_print_context; 159, argument_list; 159, 160; 159, 161; 159, 162; 159, 163; 159, 164; 159, 165; 159, 168; 160, identifier:filename; 161, identifier:secret; 162, identifier:current_index; 163, identifier:total_reviews; 164, identifier:plugins_used; 165, keyword_argument; 165, 166; 165, 167; 166, identifier:additional_header_lines; 167, identifier:header; 168, keyword_argument; 168, 169; 168, 170; 169, identifier:force; 170, identifier:is_removed; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:decision; 174, call; 174, 175; 174, 176; 175, identifier:_get_user_decision; 176, argument_list; 176, 177; 176, 184; 177, keyword_argument; 177, 178; 177, 179; 178, identifier:can_step_back; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:secret_iterator; 182, identifier:can_step_back; 183, argument_list; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:prompt_secret_decision; 186, False; 187, except_clause; 187, 188; 187, 189; 188, identifier:SecretNotFoundOnSpecifiedLineError; 189, block; 189, 190; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:decision; 193, call; 193, 194; 193, 195; 194, identifier:_get_user_decision; 195, argument_list; 195, 196; 196, keyword_argument; 196, 197; 196, 198; 197, identifier:prompt_secret_decision; 198, False; 199, if_statement; 199, 200; 199, 203; 200, comparison_operator:==; 200, 201; 200, 202; 201, identifier:decision; 202, string:'q'; 203, block; 203, 204; 203, 209; 204, expression_statement; 204, 205; 205, call; 205, 206; 205, 207; 206, identifier:print; 207, argument_list; 207, 208; 208, string:'Quitting...'; 209, break_statement; 210, if_statement; 210, 211; 210, 214; 211, comparison_operator:==; 211, 212; 211, 213; 212, identifier:decision; 213, string:'b'; 214, block; 214, 215; 214, 219; 215, expression_statement; 215, 216; 216, augmented_assignment:-=; 216, 217; 216, 218; 217, identifier:current_index; 218, integer:2; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:secret_iterator; 223, identifier:step_back_on_next_iteration; 224, argument_list | def compare_baselines(old_baseline_filename, new_baseline_filename):
if old_baseline_filename == new_baseline_filename:
raise RedundantComparisonError
old_baseline = _get_baseline_from_file(old_baseline_filename)
new_baseline = _get_baseline_from_file(new_baseline_filename)
_remove_nonexistent_files_from_baseline(old_baseline)
_remove_nonexistent_files_from_baseline(new_baseline)
secrets_to_compare = _get_secrets_to_compare(old_baseline, new_baseline)
total_reviews = len(secrets_to_compare)
current_index = 0
secret_iterator = BidirectionalIterator(secrets_to_compare)
for filename, secret, is_removed in secret_iterator:
_clear_screen()
current_index += 1
header = '{} {}'
if is_removed:
plugins_used = old_baseline['plugins_used']
header = header.format(
colorize('Status:', AnsiColor.BOLD),
'>> {} <<'.format(
colorize('REMOVED', AnsiColor.RED),
),
)
else:
plugins_used = new_baseline['plugins_used']
header = header.format(
colorize('Status:', AnsiColor.BOLD),
'>> {} <<'.format(
colorize('ADDED', AnsiColor.LIGHT_GREEN),
),
)
try:
_print_context(
filename,
secret,
current_index,
total_reviews,
plugins_used,
additional_header_lines=header,
force=is_removed,
)
decision = _get_user_decision(
can_step_back=secret_iterator.can_step_back(),
prompt_secret_decision=False,
)
except SecretNotFoundOnSpecifiedLineError:
decision = _get_user_decision(prompt_secret_decision=False)
if decision == 'q':
print('Quitting...')
break
if decision == 'b':
current_index -= 2
secret_iterator.step_back_on_next_iteration() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_GetEventIdentifiers; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:event; 6, block; 6, 7; 6, 11; 6, 22; 6, 29; 6, 151; 6, 189; 6, 199; 6, 208; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:attributes; 10, list:[]; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:attribute_string; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, string:'data_type: {0:s}'; 17, identifier:format; 18, argument_list; 18, 19; 19, attribute; 19, 20; 19, 21; 20, identifier:event; 21, identifier:data_type; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:attributes; 26, identifier:append; 27, argument_list; 27, 28; 28, identifier:attribute_string; 29, for_statement; 29, 30; 29, 33; 29, 41; 30, pattern_list; 30, 31; 30, 32; 31, identifier:attribute_name; 32, identifier:attribute_value; 33, call; 33, 34; 33, 35; 34, identifier:sorted; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:event; 39, identifier:GetAttributes; 40, argument_list; 41, block; 41, 42; 41, 50; 41, 55; 41, 117; 41, 144; 42, if_statement; 42, 43; 42, 48; 43, comparison_operator:in; 43, 44; 43, 45; 44, identifier:attribute_name; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_IDENTIFIER_EXCLUDED_ATTRIBUTES; 48, block; 48, 49; 49, continue_statement; 50, if_statement; 50, 51; 50, 53; 51, not_operator; 51, 52; 52, identifier:attribute_value; 53, block; 53, 54; 54, continue_statement; 55, if_statement; 55, 56; 55, 59; 55, 66; 55, 84; 55, 101; 56, comparison_operator:==; 56, 57; 56, 58; 57, identifier:attribute_name; 58, string:'pathspec'; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:attribute_value; 63, attribute; 63, 64; 63, 65; 64, identifier:attribute_value; 65, identifier:comparable; 66, elif_clause; 66, 67; 66, 72; 67, call; 67, 68; 67, 69; 68, identifier:isinstance; 69, argument_list; 69, 70; 69, 71; 70, identifier:attribute_value; 71, identifier:dict; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:attribute_value; 76, call; 76, 77; 76, 78; 77, identifier:sorted; 78, argument_list; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:attribute_value; 82, identifier:items; 83, argument_list; 84, elif_clause; 84, 85; 84, 90; 85, call; 85, 86; 85, 87; 86, identifier:isinstance; 87, argument_list; 87, 88; 87, 89; 88, identifier:attribute_value; 89, identifier:set; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:attribute_value; 94, call; 94, 95; 94, 96; 95, identifier:sorted; 96, argument_list; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:list; 99, argument_list; 99, 100; 100, identifier:attribute_value; 101, elif_clause; 101, 102; 101, 109; 102, call; 102, 103; 102, 104; 103, identifier:isinstance; 104, argument_list; 104, 105; 104, 106; 105, identifier:attribute_value; 106, attribute; 106, 107; 106, 108; 107, identifier:py2to3; 108, identifier:BYTES_TYPE; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:attribute_value; 113, call; 113, 114; 113, 115; 114, identifier:repr; 115, argument_list; 115, 116; 116, identifier:attribute_value; 117, try_statement; 117, 118; 117, 129; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:attribute_string; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, string:'{0:s}: {1!s}'; 125, identifier:format; 126, argument_list; 126, 127; 126, 128; 127, identifier:attribute_name; 128, identifier:attribute_value; 129, except_clause; 129, 130; 129, 131; 130, identifier:UnicodeDecodeError; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:logger; 136, identifier:error; 137, argument_list; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, string:'Failed to decode attribute {0:s}'; 141, identifier:format; 142, argument_list; 142, 143; 143, identifier:attribute_name; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:attributes; 148, identifier:append; 149, argument_list; 149, 150; 150, identifier:attribute_string; 151, if_statement; 151, 152; 151, 173; 151, 183; 152, comparison_operator:in; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:event; 155, identifier:timestamp_desc; 156, tuple; 156, 157; 156, 158; 156, 159; 156, 160; 156, 161; 156, 164; 156, 167; 156, 170; 157, string:'atime'; 158, string:'ctime'; 159, string:'crtime'; 160, string:'mtime'; 161, attribute; 161, 162; 161, 163; 162, identifier:definitions; 163, identifier:TIME_DESCRIPTION_LAST_ACCESS; 164, attribute; 164, 165; 164, 166; 165, identifier:definitions; 166, identifier:TIME_DESCRIPTION_CHANGE; 167, attribute; 167, 168; 167, 169; 168, identifier:definitions; 169, identifier:TIME_DESCRIPTION_CREATION; 170, attribute; 170, 171; 170, 172; 171, identifier:definitions; 172, identifier:TIME_DESCRIPTION_MODIFICATION; 173, block; 173, 174; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:macb_group_identifier; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, string:', '; 180, identifier:join; 181, argument_list; 181, 182; 182, identifier:attributes; 183, else_clause; 183, 184; 184, block; 184, 185; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:macb_group_identifier; 188, None; 189, expression_statement; 189, 190; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:attributes; 193, identifier:insert; 194, argument_list; 194, 195; 194, 196; 195, integer:0; 196, attribute; 196, 197; 196, 198; 197, identifier:event; 198, identifier:timestamp_desc; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:content_identifier; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, string:', '; 205, identifier:join; 206, argument_list; 206, 207; 207, identifier:attributes; 208, return_statement; 208, 209; 209, expression_list; 209, 210; 209, 211; 210, identifier:macb_group_identifier; 211, identifier:content_identifier | def _GetEventIdentifiers(self, event):
attributes = []
attribute_string = 'data_type: {0:s}'.format(event.data_type)
attributes.append(attribute_string)
for attribute_name, attribute_value in sorted(event.GetAttributes()):
if attribute_name in self._IDENTIFIER_EXCLUDED_ATTRIBUTES:
continue
if not attribute_value:
continue
if attribute_name == 'pathspec':
attribute_value = attribute_value.comparable
elif isinstance(attribute_value, dict):
attribute_value = sorted(attribute_value.items())
elif isinstance(attribute_value, set):
attribute_value = sorted(list(attribute_value))
elif isinstance(attribute_value, py2to3.BYTES_TYPE):
attribute_value = repr(attribute_value)
try:
attribute_string = '{0:s}: {1!s}'.format(
attribute_name, attribute_value)
except UnicodeDecodeError:
logger.error('Failed to decode attribute {0:s}'.format(
attribute_name))
attributes.append(attribute_string)
if event.timestamp_desc in (
'atime', 'ctime', 'crtime', 'mtime',
definitions.TIME_DESCRIPTION_LAST_ACCESS,
definitions.TIME_DESCRIPTION_CHANGE,
definitions.TIME_DESCRIPTION_CREATION,
definitions.TIME_DESCRIPTION_MODIFICATION):
macb_group_identifier = ', '.join(attributes)
else:
macb_group_identifier = None
attributes.insert(0, event.timestamp_desc)
content_identifier = ', '.join(attributes)
return macb_group_identifier, content_identifier |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:PopEvents; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:event; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:PopEvent; 13, argument_list; 14, while_statement; 14, 15; 14, 16; 15, identifier:event; 16, block; 16, 17; 16, 20; 17, expression_statement; 17, 18; 18, yield; 18, 19; 19, identifier:event; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:event; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:PopEvent; 27, argument_list | def PopEvents(self):
event = self.PopEvent()
while event:
yield event
event = self.PopEvent() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_CheckStatusAnalysisProcess; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:pid; 6, block; 6, 7; 6, 14; 6, 264; 6, 273; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:_RaiseIfNotRegistered; 12, argument_list; 12, 13; 13, identifier:pid; 14, if_statement; 14, 15; 14, 20; 14, 38; 15, comparison_operator:in; 15, 16; 15, 17; 16, identifier:pid; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_completed_analysis_processes; 20, block; 20, 21; 20, 27; 20, 34; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:status_indicator; 24, attribute; 24, 25; 24, 26; 25, identifier:definitions; 26, identifier:STATUS_INDICATOR_COMPLETED; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:process_status; 30, dictionary; 30, 31; 31, pair; 31, 32; 31, 33; 32, string:'processing_status'; 33, identifier:status_indicator; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:used_memory; 37, integer:0; 38, else_clause; 38, 39; 39, block; 39, 40; 39, 48; 39, 57; 39, 72; 39, 80; 39, 90; 39, 129; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:process; 43, subscript; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:_processes_per_pid; 47, identifier:pid; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:process_status; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:_QueryProcessStatus; 55, argument_list; 55, 56; 56, identifier:process; 57, if_statement; 57, 58; 57, 61; 57, 66; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:process_status; 60, None; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:process_is_alive; 65, False; 66, else_clause; 66, 67; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:process_is_alive; 71, True; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:process_information; 75, subscript; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:_process_information_per_pid; 79, identifier:pid; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:used_memory; 83, boolean_operator:or; 83, 84; 83, 89; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:process_information; 87, identifier:GetUsedMemory; 88, argument_list; 89, integer:0; 90, if_statement; 90, 91; 90, 100; 91, boolean_operator:and; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:_worker_memory_limit; 95, comparison_operator:>; 95, 96; 95, 97; 96, identifier:used_memory; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:_worker_memory_limit; 100, block; 100, 101; 100, 122; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:logger; 105, identifier:warning; 106, argument_list; 106, 107; 107, call; 107, 108; 107, 114; 108, attribute; 108, 109; 108, 113; 109, parenthesized_expression; 109, 110; 110, concatenated_string; 110, 111; 110, 112; 111, string:'Process: {0:s} (PID: {1:d}) killed because it exceeded the '; 112, string:'memory limit: {2:d}.'; 113, identifier:format; 114, argument_list; 114, 115; 114, 118; 114, 119; 115, attribute; 115, 116; 115, 117; 116, identifier:process; 117, identifier:name; 118, identifier:pid; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:_worker_memory_limit; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:_KillProcess; 127, argument_list; 127, 128; 128, identifier:pid; 129, if_statement; 129, 130; 129, 135; 129, 170; 130, call; 130, 131; 130, 132; 131, identifier:isinstance; 132, argument_list; 132, 133; 132, 134; 133, identifier:process_status; 134, identifier:dict; 135, block; 135, 136; 135, 144; 135, 154; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 143; 138, subscript; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:_rpc_errors_per_pid; 142, identifier:pid; 143, integer:0; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:status_indicator; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:process_status; 150, identifier:get; 151, argument_list; 151, 152; 151, 153; 152, string:'processing_status'; 153, None; 154, if_statement; 154, 155; 154, 160; 155, comparison_operator:==; 155, 156; 155, 157; 156, identifier:status_indicator; 157, attribute; 157, 158; 157, 159; 158, identifier:definitions; 159, identifier:STATUS_INDICATOR_COMPLETED; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 168; 163, attribute; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:_completed_analysis_processes; 167, identifier:add; 168, argument_list; 168, 169; 169, identifier:pid; 170, else_clause; 170, 171; 171, block; 171, 172; 171, 186; 171, 194; 171, 205; 171, 257; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:rpc_errors; 175, binary_operator:+; 175, 176; 175, 185; 176, call; 176, 177; 176, 182; 177, attribute; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:self; 180, identifier:_rpc_errors_per_pid; 181, identifier:get; 182, argument_list; 182, 183; 182, 184; 183, identifier:pid; 184, integer:0; 185, integer:1; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 193; 188, subscript; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:_rpc_errors_per_pid; 192, identifier:pid; 193, identifier:rpc_errors; 194, if_statement; 194, 195; 194, 200; 195, comparison_operator:>; 195, 196; 195, 197; 196, identifier:rpc_errors; 197, attribute; 197, 198; 197, 199; 198, identifier:self; 199, identifier:_MAXIMUM_RPC_ERRORS; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:process_is_alive; 204, False; 205, if_statement; 205, 206; 205, 207; 205, 245; 206, identifier:process_is_alive; 207, block; 207, 208; 207, 216; 207, 235; 207, 239; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:rpc_port; 211, attribute; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:process; 214, identifier:rpc_port; 215, identifier:value; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:logger; 220, identifier:warning; 221, argument_list; 221, 222; 222, call; 222, 223; 222, 229; 223, attribute; 223, 224; 223, 228; 224, parenthesized_expression; 224, 225; 225, concatenated_string; 225, 226; 225, 227; 226, string:'Unable to retrieve process: {0:s} (PID: {1:d}) status via '; 227, string:'RPC socket: http://localhost:{2:d}'; 228, identifier:format; 229, argument_list; 229, 230; 229, 233; 229, 234; 230, attribute; 230, 231; 230, 232; 231, identifier:process; 232, identifier:name; 233, identifier:pid; 234, identifier:rpc_port; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:processing_status_string; 238, string:'RPC error'; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:status_indicator; 242, attribute; 242, 243; 242, 244; 243, identifier:definitions; 244, identifier:STATUS_INDICATOR_RUNNING; 245, else_clause; 245, 246; 246, block; 246, 247; 246, 251; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:processing_status_string; 250, string:'killed'; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:status_indicator; 254, attribute; 254, 255; 254, 256; 255, identifier:definitions; 256, identifier:STATUS_INDICATOR_KILLED; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:process_status; 260, dictionary; 260, 261; 261, pair; 261, 262; 261, 263; 262, string:'processing_status'; 263, identifier:processing_status_string; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:self; 268, identifier:_UpdateProcessingStatus; 269, argument_list; 269, 270; 269, 271; 269, 272; 270, identifier:pid; 271, identifier:process_status; 272, identifier:used_memory; 273, if_statement; 273, 274; 273, 279; 274, comparison_operator:in; 274, 275; 274, 276; 275, identifier:status_indicator; 276, attribute; 276, 277; 276, 278; 277, identifier:definitions; 278, identifier:ERROR_STATUS_INDICATORS; 279, block; 279, 280; 279, 299; 280, expression_statement; 280, 281; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:logger; 284, identifier:error; 285, argument_list; 285, 286; 286, call; 286, 287; 286, 293; 287, attribute; 287, 288; 287, 292; 288, parenthesized_expression; 288, 289; 289, concatenated_string; 289, 290; 289, 291; 290, string:'Process {0:s} (PID: {1:d}) is not functioning correctly. '; 291, string:'Status code: {2!s}.'; 292, identifier:format; 293, argument_list; 293, 294; 293, 297; 293, 298; 294, attribute; 294, 295; 294, 296; 295, identifier:process; 296, identifier:name; 297, identifier:pid; 298, identifier:status_indicator; 299, expression_statement; 299, 300; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:self; 303, identifier:_TerminateProcessByPid; 304, argument_list; 304, 305; 305, identifier:pid | def _CheckStatusAnalysisProcess(self, pid):
self._RaiseIfNotRegistered(pid)
if pid in self._completed_analysis_processes:
status_indicator = definitions.STATUS_INDICATOR_COMPLETED
process_status = {
'processing_status': status_indicator}
used_memory = 0
else:
process = self._processes_per_pid[pid]
process_status = self._QueryProcessStatus(process)
if process_status is None:
process_is_alive = False
else:
process_is_alive = True
process_information = self._process_information_per_pid[pid]
used_memory = process_information.GetUsedMemory() or 0
if self._worker_memory_limit and used_memory > self._worker_memory_limit:
logger.warning((
'Process: {0:s} (PID: {1:d}) killed because it exceeded the '
'memory limit: {2:d}.').format(
process.name, pid, self._worker_memory_limit))
self._KillProcess(pid)
if isinstance(process_status, dict):
self._rpc_errors_per_pid[pid] = 0
status_indicator = process_status.get('processing_status', None)
if status_indicator == definitions.STATUS_INDICATOR_COMPLETED:
self._completed_analysis_processes.add(pid)
else:
rpc_errors = self._rpc_errors_per_pid.get(pid, 0) + 1
self._rpc_errors_per_pid[pid] = rpc_errors
if rpc_errors > self._MAXIMUM_RPC_ERRORS:
process_is_alive = False
if process_is_alive:
rpc_port = process.rpc_port.value
logger.warning((
'Unable to retrieve process: {0:s} (PID: {1:d}) status via '
'RPC socket: http://localhost:{2:d}').format(
process.name, pid, rpc_port))
processing_status_string = 'RPC error'
status_indicator = definitions.STATUS_INDICATOR_RUNNING
else:
processing_status_string = 'killed'
status_indicator = definitions.STATUS_INDICATOR_KILLED
process_status = {
'processing_status': processing_status_string}
self._UpdateProcessingStatus(pid, process_status, used_memory)
if status_indicator in definitions.ERROR_STATUS_INDICATORS:
logger.error((
'Process {0:s} (PID: {1:d}) is not functioning correctly. '
'Status code: {2!s}.').format(
process.name, pid, status_indicator))
self._TerminateProcessByPid(pid) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:_ExportEvent; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:output_module; 6, identifier:event; 7, default_parameter; 7, 8; 7, 9; 8, identifier:deduplicate_events; 9, True; 10, block; 10, 11; 10, 38; 11, if_statement; 11, 12; 11, 19; 12, comparison_operator:!=; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:event; 15, identifier:timestamp; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:_export_event_timestamp; 19, block; 19, 20; 19, 30; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_FlushExportBuffer; 25, argument_list; 25, 26; 25, 27; 26, identifier:output_module; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:deduplicate_events; 29, identifier:deduplicate_events; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_export_event_timestamp; 35, attribute; 35, 36; 35, 37; 36, identifier:event; 37, identifier:timestamp; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_export_event_heap; 44, identifier:PushEvent; 45, argument_list; 45, 46; 46, identifier:event | def _ExportEvent(self, output_module, event, deduplicate_events=True):
if event.timestamp != self._export_event_timestamp:
self._FlushExportBuffer(
output_module, deduplicate_events=deduplicate_events)
self._export_event_timestamp = event.timestamp
self._export_event_heap.PushEvent(event) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_FlushExportBuffer; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:output_module; 6, default_parameter; 6, 7; 6, 8; 7, identifier:deduplicate_events; 8, True; 9, block; 9, 10; 9, 14; 9, 18; 9, 22; 9, 32; 9, 129; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:last_macb_group_identifier; 13, None; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:last_content_identifier; 17, None; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:macb_group; 21, list:[]; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:generator; 25, call; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_export_event_heap; 30, identifier:PopEvents; 31, argument_list; 32, for_statement; 32, 33; 32, 37; 32, 38; 33, pattern_list; 33, 34; 33, 35; 33, 36; 34, identifier:macb_group_identifier; 35, identifier:content_identifier; 36, identifier:event; 37, identifier:generator; 38, block; 38, 39; 38, 55; 38, 121; 38, 125; 39, if_statement; 39, 40; 39, 45; 40, boolean_operator:and; 40, 41; 40, 42; 41, identifier:deduplicate_events; 42, comparison_operator:==; 42, 43; 42, 44; 43, identifier:last_content_identifier; 44, identifier:content_identifier; 45, block; 45, 46; 45, 54; 46, expression_statement; 46, 47; 47, augmented_assignment:+=; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:_events_status; 52, identifier:number_of_duplicate_events; 53, integer:1; 54, continue_statement; 55, if_statement; 55, 56; 55, 59; 55, 81; 56, comparison_operator:is; 56, 57; 56, 58; 57, identifier:macb_group_identifier; 58, None; 59, block; 59, 60; 59, 74; 60, if_statement; 60, 61; 60, 62; 61, identifier:macb_group; 62, block; 62, 63; 62, 70; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:output_module; 67, identifier:WriteEventMACBGroup; 68, argument_list; 68, 69; 69, identifier:macb_group; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:macb_group; 73, list:[]; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:output_module; 78, identifier:WriteEvent; 79, argument_list; 79, 80; 80, identifier:event; 81, else_clause; 81, 82; 82, block; 82, 83; 82, 113; 83, if_statement; 83, 84; 83, 91; 83, 99; 84, parenthesized_expression; 84, 85; 85, boolean_operator:or; 85, 86; 85, 89; 86, comparison_operator:==; 86, 87; 86, 88; 87, identifier:last_macb_group_identifier; 88, identifier:macb_group_identifier; 89, not_operator; 89, 90; 90, identifier:macb_group; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:macb_group; 96, identifier:append; 97, argument_list; 97, 98; 98, identifier:event; 99, else_clause; 99, 100; 100, block; 100, 101; 100, 108; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:output_module; 105, identifier:WriteEventMACBGroup; 106, argument_list; 106, 107; 107, identifier:macb_group; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:macb_group; 111, list:[event]; 111, 112; 112, identifier:event; 113, expression_statement; 113, 114; 114, augmented_assignment:+=; 114, 115; 114, 120; 115, attribute; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:_events_status; 119, identifier:number_of_macb_grouped_events; 120, integer:1; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:last_macb_group_identifier; 124, identifier:macb_group_identifier; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:last_content_identifier; 128, identifier:content_identifier; 129, if_statement; 129, 130; 129, 131; 130, identifier:macb_group; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:output_module; 136, identifier:WriteEventMACBGroup; 137, argument_list; 137, 138; 138, identifier:macb_group | def _FlushExportBuffer(self, output_module, deduplicate_events=True):
last_macb_group_identifier = None
last_content_identifier = None
macb_group = []
generator = self._export_event_heap.PopEvents()
for macb_group_identifier, content_identifier, event in generator:
if deduplicate_events and last_content_identifier == content_identifier:
self._events_status.number_of_duplicate_events += 1
continue
if macb_group_identifier is None:
if macb_group:
output_module.WriteEventMACBGroup(macb_group)
macb_group = []
output_module.WriteEvent(event)
else:
if (last_macb_group_identifier == macb_group_identifier or
not macb_group):
macb_group.append(event)
else:
output_module.WriteEventMACBGroup(macb_group)
macb_group = [event]
self._events_status.number_of_macb_grouped_events += 1
last_macb_group_identifier = macb_group_identifier
last_content_identifier = content_identifier
if macb_group:
output_module.WriteEventMACBGroup(macb_group) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_MergeEventTag; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:storage_writer; 6, identifier:attribute_container; 7, block; 7, 8; 7, 16; 7, 24; 7, 29; 7, 41; 7, 62; 8, if_statement; 8, 9; 8, 14; 9, comparison_operator:!=; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:attribute_container; 12, identifier:CONTAINER_TYPE; 13, string:'event_tag'; 14, block; 14, 15; 15, return_statement; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:event_identifier; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:attribute_container; 22, identifier:GetEventIdentifier; 23, argument_list; 24, if_statement; 24, 25; 24, 27; 25, not_operator; 25, 26; 26, identifier:event_identifier; 27, block; 27, 28; 28, return_statement; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:stored_event_tag; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_event_tag_index; 37, identifier:GetEventTagByIdentifier; 38, argument_list; 38, 39; 38, 40; 39, identifier:storage_writer; 40, identifier:event_identifier; 41, if_statement; 41, 42; 41, 43; 42, identifier:stored_event_tag; 43, block; 43, 44; 43, 53; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:attribute_container; 48, identifier:AddComment; 49, argument_list; 49, 50; 50, attribute; 50, 51; 50, 52; 51, identifier:stored_event_tag; 52, identifier:comment; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:attribute_container; 57, identifier:AddLabels; 58, argument_list; 58, 59; 59, attribute; 59, 60; 59, 61; 60, identifier:stored_event_tag; 61, identifier:labels; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:_event_tag_index; 68, identifier:SetEventTag; 69, argument_list; 69, 70; 70, identifier:attribute_container | def _MergeEventTag(self, storage_writer, attribute_container):
if attribute_container.CONTAINER_TYPE != 'event_tag':
return
event_identifier = attribute_container.GetEventIdentifier()
if not event_identifier:
return
stored_event_tag = self._event_tag_index.GetEventTagByIdentifier(
storage_writer, event_identifier)
if stored_event_tag:
attribute_container.AddComment(stored_event_tag.comment)
attribute_container.AddLabels(stored_event_tag.labels)
self._event_tag_index.SetEventTag(attribute_container) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_StartAnalysisProcesses; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:storage_writer; 6, identifier:analysis_plugins; 7, block; 7, 8; 7, 15; 7, 63; 8, expression_statement; 8, 9; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:logger; 12, identifier:info; 13, argument_list; 13, 14; 14, string:'Starting analysis plugins.'; 15, for_statement; 15, 16; 15, 17; 15, 22; 16, identifier:analysis_plugin; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:analysis_plugins; 20, identifier:values; 21, argument_list; 22, block; 22, 23; 22, 33; 22, 45; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 32; 25, subscript; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_analysis_plugins; 29, attribute; 29, 30; 29, 31; 30, identifier:analysis_plugin; 31, identifier:NAME; 32, identifier:analysis_plugin; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:process; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:_StartWorkerProcess; 40, argument_list; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:analysis_plugin; 43, identifier:NAME; 44, identifier:storage_writer; 45, if_statement; 45, 46; 45, 48; 46, not_operator; 46, 47; 47, identifier:process; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:logger; 53, identifier:error; 54, argument_list; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, string:'Unable to create analysis process: {0:s}'; 58, identifier:format; 59, argument_list; 59, 60; 60, attribute; 60, 61; 60, 62; 61, identifier:analysis_plugin; 62, identifier:NAME; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:logger; 67, identifier:info; 68, argument_list; 68, 69; 69, string:'Analysis plugins running' | def _StartAnalysisProcesses(self, storage_writer, analysis_plugins):
logger.info('Starting analysis plugins.')
for analysis_plugin in analysis_plugins.values():
self._analysis_plugins[analysis_plugin.NAME] = analysis_plugin
process = self._StartWorkerProcess(analysis_plugin.NAME, storage_writer)
if not process:
logger.error('Unable to create analysis process: {0:s}'.format(
analysis_plugin.NAME))
logger.info('Analysis plugins running') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_StopAnalysisProcesses; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:abort; 7, False; 8, block; 8, 9; 8, 16; 8, 22; 8, 31; 8, 60; 8, 84; 8, 95; 8, 114; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:logger; 13, identifier:debug; 14, argument_list; 14, 15; 15, string:'Stopping analysis processes.'; 16, expression_statement; 16, 17; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_StopMonitoringProcesses; 21, argument_list; 22, if_statement; 22, 23; 22, 24; 23, identifier:abort; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_AbortTerminate; 30, argument_list; 31, if_statement; 31, 32; 31, 36; 32, not_operator; 32, 33; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:_use_zeromq; 36, block; 36, 37; 36, 44; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:logger; 41, identifier:debug; 42, argument_list; 42, 43; 43, string:'Emptying queues.'; 44, for_statement; 44, 45; 44, 46; 44, 53; 45, identifier:event_queue; 46, call; 46, 47; 46, 52; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:_event_queues; 51, identifier:values; 52, argument_list; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:event_queue; 58, identifier:Empty; 59, argument_list; 60, for_statement; 60, 61; 60, 62; 60, 69; 61, identifier:event_queue; 62, call; 62, 63; 62, 68; 63, attribute; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_event_queues; 67, identifier:values; 68, argument_list; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:event_queue; 74, identifier:PushItem; 75, argument_list; 75, 76; 75, 81; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:plaso_queue; 79, identifier:QueueAbort; 80, argument_list; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:block; 83, False; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:_AbortJoin; 89, argument_list; 89, 90; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:timeout; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:_PROCESS_JOIN_TIMEOUT; 95, for_statement; 95, 96; 95, 97; 95, 104; 96, identifier:event_queue; 97, call; 97, 98; 97, 103; 98, attribute; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:_event_queues; 102, identifier:values; 103, argument_list; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:event_queue; 109, identifier:Close; 110, argument_list; 110, 111; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:abort; 113, identifier:abort; 114, if_statement; 114, 115; 114, 116; 114, 123; 115, identifier:abort; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:_AbortKill; 122, argument_list; 123, else_clause; 123, 124; 124, block; 124, 125; 124, 131; 124, 142; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:_AbortTerminate; 130, argument_list; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:_AbortJoin; 136, argument_list; 136, 137; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:timeout; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:_PROCESS_JOIN_TIMEOUT; 142, for_statement; 142, 143; 142, 144; 142, 151; 143, identifier:event_queue; 144, call; 144, 145; 144, 150; 145, attribute; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:_event_queues; 149, identifier:values; 150, argument_list; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:event_queue; 156, identifier:Close; 157, argument_list; 157, 158; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:abort; 160, True | def _StopAnalysisProcesses(self, abort=False):
logger.debug('Stopping analysis processes.')
self._StopMonitoringProcesses()
if abort:
self._AbortTerminate()
if not self._use_zeromq:
logger.debug('Emptying queues.')
for event_queue in self._event_queues.values():
event_queue.Empty()
for event_queue in self._event_queues.values():
event_queue.PushItem(plaso_queue.QueueAbort(), block=False)
self._AbortJoin(timeout=self._PROCESS_JOIN_TIMEOUT)
for event_queue in self._event_queues.values():
event_queue.Close(abort=abort)
if abort:
self._AbortKill()
else:
self._AbortTerminate()
self._AbortJoin(timeout=self._PROCESS_JOIN_TIMEOUT)
for event_queue in self._event_queues.values():
event_queue.Close(abort=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_UpdateForemanProcessStatus; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 18; 5, 29; 5, 78; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:used_memory; 9, boolean_operator:or; 9, 10; 9, 17; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_process_information; 15, identifier:GetUsedMemory; 16, argument_list; 17, integer:0; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:display_name; 21, call; 21, 22; 21, 23; 22, identifier:getattr; 23, argument_list; 23, 24; 23, 27; 23, 28; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_merge_task; 27, string:'identifier'; 28, string:''; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 36; 31, attribute; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_processing_status; 35, identifier:UpdateForemanStatus; 36, argument_list; 36, 37; 36, 40; 36, 43; 36, 46; 36, 47; 36, 48; 36, 51; 36, 54; 36, 57; 36, 60; 36, 63; 36, 66; 36, 69; 36, 72; 36, 75; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:_name; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:_status; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_pid; 46, identifier:used_memory; 47, identifier:display_name; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:_number_of_consumed_sources; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:_number_of_produced_sources; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:_number_of_consumed_events; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_number_of_produced_events; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_number_of_consumed_event_tags; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:_number_of_produced_event_tags; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:_number_of_consumed_warnings; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:_number_of_produced_warnings; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:_number_of_consumed_reports; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:_number_of_produced_reports; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 85; 80, attribute; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:_processing_status; 84, identifier:UpdateEventsStatus; 85, argument_list; 85, 86; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:_events_status | def _UpdateForemanProcessStatus(self):
used_memory = self._process_information.GetUsedMemory() or 0
display_name = getattr(self._merge_task, 'identifier', '')
self._processing_status.UpdateForemanStatus(
self._name, self._status, self._pid, used_memory, display_name,
self._number_of_consumed_sources, self._number_of_produced_sources,
self._number_of_consumed_events, self._number_of_produced_events,
self._number_of_consumed_event_tags,
self._number_of_produced_event_tags,
self._number_of_consumed_warnings, self._number_of_produced_warnings,
self._number_of_consumed_reports, self._number_of_produced_reports)
self._processing_status.UpdateEventsStatus(self._events_status) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:workers_status; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, return_statement; 6, 7; 7, list_comprehension; 7, 8; 7, 13; 8, subscript; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:_workers_status; 12, identifier:identifier; 13, for_in_clause; 13, 14; 13, 15; 14, identifier:identifier; 15, call; 15, 16; 15, 17; 16, identifier:sorted; 17, argument_list; 17, 18; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_workers_status; 23, identifier:keys; 24, argument_list | def workers_status(self):
return [self._workers_status[identifier]
for identifier in sorted(self._workers_status.keys())] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:ProcessStorage; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 15; 5, 26; 5, 37; 5, 48; 5, 68; 5, 81; 5, 100; 5, 111; 5, 117; 5, 125; 5, 133; 5, 143; 5, 153; 5, 163; 5, 167; 5, 264; 5, 335; 5, 341; 5, 350; 5, 413; 5, 426; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:_CheckStorageFile; 11, argument_list; 11, 12; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_storage_file_path; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_status_view; 21, identifier:SetMode; 22, argument_list; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:_status_view_mode; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_status_view; 32, identifier:SetStorageFileInformation; 33, argument_list; 33, 34; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_storage_file_path; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:status_update_callback; 40, parenthesized_expression; 40, 41; 41, call; 41, 42; 41, 47; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_status_view; 46, identifier:GetAnalysisStatusUpdateCallback; 47, argument_list; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:session; 51, call; 51, 52; 51, 57; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:engine; 55, identifier:BaseEngine; 56, identifier:CreateSession; 57, argument_list; 57, 58; 57, 63; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:command_line_arguments; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_command_line_arguments; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:preferred_encoding; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:preferred_encoding; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:storage_reader; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:storage_factory; 75, identifier:StorageFactory; 76, identifier:CreateStorageReaderForFile; 77, argument_list; 77, 78; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_storage_file_path; 81, if_statement; 81, 82; 81, 84; 82, not_operator; 82, 83; 83, identifier:storage_reader; 84, block; 84, 85; 84, 99; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:logger; 89, identifier:error; 90, argument_list; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, string:'Format of storage file: {0:s} not supported'; 94, identifier:format; 95, argument_list; 95, 96; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:_storage_file_path; 99, return_statement; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:_number_of_analysis_reports; 105, parenthesized_expression; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:storage_reader; 109, identifier:GetNumberOfAnalysisReports; 110, argument_list; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:storage_reader; 115, identifier:Close; 116, argument_list; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:configuration; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:configurations; 123, identifier:ProcessingConfiguration; 124, argument_list; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:configuration; 129, identifier:data_location; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:_data_location; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:configuration; 138, identifier:profiling; 139, identifier:directory; 140, attribute; 140, 141; 140, 142; 141, identifier:self; 142, identifier:_profiling_directory; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 150; 145, attribute; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:configuration; 148, identifier:profiling; 149, identifier:sample_rate; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:_profiling_sample_rate; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 160; 155, attribute; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:configuration; 158, identifier:profiling; 159, identifier:profilers; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:_profilers; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:analysis_counter; 166, None; 167, if_statement; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:_analysis_plugins; 171, block; 171, 172; 171, 187; 171, 200; 171, 235; 171, 243; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:storage_writer; 175, parenthesized_expression; 175, 176; 176, call; 176, 177; 176, 182; 177, attribute; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:storage_factory; 180, identifier:StorageFactory; 181, identifier:CreateStorageWriterForFile; 182, argument_list; 182, 183; 182, 184; 183, identifier:session; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:_storage_file_path; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:analysis_engine; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:psort; 193, identifier:PsortMultiProcessEngine; 194, argument_list; 194, 195; 195, keyword_argument; 195, 196; 195, 197; 196, identifier:use_zeromq; 197, attribute; 197, 198; 197, 199; 198, identifier:self; 199, identifier:_use_zeromq; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:analysis_engine; 204, identifier:AnalyzeEvents; 205, argument_list; 205, 206; 205, 209; 205, 210; 205, 213; 205, 216; 205, 217; 205, 222; 205, 227; 205, 230; 206, attribute; 206, 207; 206, 208; 207, identifier:self; 208, identifier:_knowledge_base; 209, identifier:storage_writer; 210, attribute; 210, 211; 210, 212; 211, identifier:self; 212, identifier:_data_location; 213, attribute; 213, 214; 213, 215; 214, identifier:self; 215, identifier:_analysis_plugins; 216, identifier:configuration; 217, keyword_argument; 217, 218; 217, 219; 218, identifier:event_filter; 219, attribute; 219, 220; 219, 221; 220, identifier:self; 221, identifier:_event_filter; 222, keyword_argument; 222, 223; 222, 224; 223, identifier:event_filter_expression; 224, attribute; 224, 225; 224, 226; 225, identifier:self; 226, identifier:_event_filter_expression; 227, keyword_argument; 227, 228; 227, 229; 228, identifier:status_update_callback; 229, identifier:status_update_callback; 230, keyword_argument; 230, 231; 230, 232; 231, identifier:worker_memory_limit; 232, attribute; 232, 233; 232, 234; 233, identifier:self; 234, identifier:_worker_memory_limit; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:analysis_counter; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:collections; 241, identifier:Counter; 242, argument_list; 243, for_statement; 243, 244; 243, 247; 243, 257; 244, pattern_list; 244, 245; 244, 246; 245, identifier:item; 246, identifier:value; 247, call; 247, 248; 247, 249; 248, identifier:iter; 249, argument_list; 249, 250; 250, call; 250, 251; 250, 256; 251, attribute; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:session; 254, identifier:analysis_reports_counter; 255, identifier:items; 256, argument_list; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 263; 260, subscript; 260, 261; 260, 262; 261, identifier:analysis_counter; 262, identifier:item; 263, identifier:value; 264, if_statement; 264, 265; 264, 270; 265, comparison_operator:!=; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:self; 268, identifier:_output_format; 269, string:'null'; 270, block; 270, 271; 270, 285; 270, 298; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:storage_reader; 274, parenthesized_expression; 274, 275; 275, call; 275, 276; 275, 281; 276, attribute; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:storage_factory; 279, identifier:StorageFactory; 280, identifier:CreateStorageReaderForFile; 281, argument_list; 281, 282; 282, attribute; 282, 283; 282, 284; 283, identifier:self; 284, identifier:_storage_file_path; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:analysis_engine; 288, call; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:psort; 291, identifier:PsortMultiProcessEngine; 292, argument_list; 292, 293; 293, keyword_argument; 293, 294; 293, 295; 294, identifier:use_zeromq; 295, attribute; 295, 296; 295, 297; 296, identifier:self; 297, identifier:_use_zeromq; 298, expression_statement; 298, 299; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:analysis_engine; 302, identifier:ExportEvents; 303, argument_list; 303, 304; 303, 307; 303, 308; 303, 311; 303, 312; 303, 317; 303, 322; 303, 325; 303, 330; 304, attribute; 304, 305; 304, 306; 305, identifier:self; 306, identifier:_knowledge_base; 307, identifier:storage_reader; 308, attribute; 308, 309; 308, 310; 309, identifier:self; 310, identifier:_output_module; 311, identifier:configuration; 312, keyword_argument; 312, 313; 312, 314; 313, identifier:deduplicate_events; 314, attribute; 314, 315; 314, 316; 315, identifier:self; 316, identifier:_deduplicate_events; 317, keyword_argument; 317, 318; 317, 319; 318, identifier:event_filter; 319, attribute; 319, 320; 319, 321; 320, identifier:self; 321, identifier:_event_filter; 322, keyword_argument; 322, 323; 322, 324; 323, identifier:status_update_callback; 324, identifier:status_update_callback; 325, keyword_argument; 325, 326; 325, 327; 326, identifier:time_slice; 327, attribute; 327, 328; 327, 329; 328, identifier:self; 329, identifier:_time_slice; 330, keyword_argument; 330, 331; 330, 332; 331, identifier:use_time_slicer; 332, attribute; 332, 333; 332, 334; 333, identifier:self; 334, identifier:_use_time_slicer; 335, if_statement; 335, 336; 335, 339; 336, attribute; 336, 337; 336, 338; 337, identifier:self; 338, identifier:_quiet_mode; 339, block; 339, 340; 340, return_statement; 341, expression_statement; 341, 342; 342, call; 342, 343; 342, 348; 343, attribute; 343, 344; 343, 347; 344, attribute; 344, 345; 344, 346; 345, identifier:self; 346, identifier:_output_writer; 347, identifier:Write; 348, argument_list; 348, 349; 349, string:'Processing completed.\n'; 350, if_statement; 350, 351; 350, 352; 351, identifier:analysis_counter; 352, block; 352, 353; 352, 369; 352, 393; 352, 404; 353, expression_statement; 353, 354; 354, assignment; 354, 355; 354, 356; 355, identifier:table_view; 356, call; 356, 357; 356, 362; 357, attribute; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, identifier:views; 360, identifier:ViewsFactory; 361, identifier:GetTableView; 362, argument_list; 362, 363; 362, 366; 363, attribute; 363, 364; 363, 365; 364, identifier:self; 365, identifier:_views_format_type; 366, keyword_argument; 366, 367; 366, 368; 367, identifier:title; 368, string:'Analysis reports generated'; 369, for_statement; 369, 370; 369, 373; 369, 378; 370, pattern_list; 370, 371; 370, 372; 371, identifier:element; 372, identifier:count; 373, call; 373, 374; 373, 377; 374, attribute; 374, 375; 374, 376; 375, identifier:analysis_counter; 376, identifier:most_common; 377, argument_list; 378, block; 378, 379; 379, if_statement; 379, 380; 379, 383; 380, comparison_operator:!=; 380, 381; 380, 382; 381, identifier:element; 382, string:'total'; 383, block; 383, 384; 384, expression_statement; 384, 385; 385, call; 385, 386; 385, 389; 386, attribute; 386, 387; 386, 388; 387, identifier:table_view; 388, identifier:AddRow; 389, argument_list; 389, 390; 390, list:[element, count]; 390, 391; 390, 392; 391, identifier:element; 392, identifier:count; 393, expression_statement; 393, 394; 394, call; 394, 395; 394, 398; 395, attribute; 395, 396; 395, 397; 396, identifier:table_view; 397, identifier:AddRow; 398, argument_list; 398, 399; 399, list:['Total', analysis_counter['total']]; 399, 400; 399, 401; 400, string:'Total'; 401, subscript; 401, 402; 401, 403; 402, identifier:analysis_counter; 403, string:'total'; 404, expression_statement; 404, 405; 405, call; 405, 406; 405, 409; 406, attribute; 406, 407; 406, 408; 407, identifier:table_view; 408, identifier:Write; 409, argument_list; 409, 410; 410, attribute; 410, 411; 410, 412; 411, identifier:self; 412, identifier:_output_writer; 413, expression_statement; 413, 414; 414, assignment; 414, 415; 414, 416; 415, identifier:storage_reader; 416, call; 416, 417; 416, 422; 417, attribute; 417, 418; 417, 421; 418, attribute; 418, 419; 418, 420; 419, identifier:storage_factory; 420, identifier:StorageFactory; 421, identifier:CreateStorageReaderForFile; 422, argument_list; 422, 423; 423, attribute; 423, 424; 423, 425; 424, identifier:self; 425, identifier:_storage_file_path; 426, expression_statement; 426, 427; 427, call; 427, 428; 427, 431; 428, attribute; 428, 429; 428, 430; 429, identifier:self; 430, identifier:_PrintAnalysisReportsDetails; 431, argument_list; 431, 432; 432, identifier:storage_reader | def ProcessStorage(self):
self._CheckStorageFile(self._storage_file_path)
self._status_view.SetMode(self._status_view_mode)
self._status_view.SetStorageFileInformation(self._storage_file_path)
status_update_callback = (
self._status_view.GetAnalysisStatusUpdateCallback())
session = engine.BaseEngine.CreateSession(
command_line_arguments=self._command_line_arguments,
preferred_encoding=self.preferred_encoding)
storage_reader = storage_factory.StorageFactory.CreateStorageReaderForFile(
self._storage_file_path)
if not storage_reader:
logger.error('Format of storage file: {0:s} not supported'.format(
self._storage_file_path))
return
self._number_of_analysis_reports = (
storage_reader.GetNumberOfAnalysisReports())
storage_reader.Close()
configuration = configurations.ProcessingConfiguration()
configuration.data_location = self._data_location
configuration.profiling.directory = self._profiling_directory
configuration.profiling.sample_rate = self._profiling_sample_rate
configuration.profiling.profilers = self._profilers
analysis_counter = None
if self._analysis_plugins:
storage_writer = (
storage_factory.StorageFactory.CreateStorageWriterForFile(
session, self._storage_file_path))
analysis_engine = psort.PsortMultiProcessEngine(
use_zeromq=self._use_zeromq)
analysis_engine.AnalyzeEvents(
self._knowledge_base, storage_writer, self._data_location,
self._analysis_plugins, configuration,
event_filter=self._event_filter,
event_filter_expression=self._event_filter_expression,
status_update_callback=status_update_callback,
worker_memory_limit=self._worker_memory_limit)
analysis_counter = collections.Counter()
for item, value in iter(session.analysis_reports_counter.items()):
analysis_counter[item] = value
if self._output_format != 'null':
storage_reader = (
storage_factory.StorageFactory.CreateStorageReaderForFile(
self._storage_file_path))
analysis_engine = psort.PsortMultiProcessEngine(
use_zeromq=self._use_zeromq)
analysis_engine.ExportEvents(
self._knowledge_base, storage_reader, self._output_module,
configuration, deduplicate_events=self._deduplicate_events,
event_filter=self._event_filter,
status_update_callback=status_update_callback,
time_slice=self._time_slice, use_time_slicer=self._use_time_slicer)
if self._quiet_mode:
return
self._output_writer.Write('Processing completed.\n')
if analysis_counter:
table_view = views.ViewsFactory.GetTableView(
self._views_format_type, title='Analysis reports generated')
for element, count in analysis_counter.most_common():
if element != 'total':
table_view.AddRow([element, count])
table_view.AddRow(['Total', analysis_counter['total']])
table_view.Write(self._output_writer)
storage_reader = storage_factory.StorageFactory.CreateStorageReaderForFile(
self._storage_file_path)
self._PrintAnalysisReportsDetails(storage_reader) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:sort_state; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:best_hyp_indices; 7, type; 7, 8; 8, attribute; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:mx; 11, identifier:nd; 12, identifier:NDArray; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:states; 19, list_comprehension; 19, 20; 19, 29; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:mx; 24, identifier:nd; 25, identifier:take; 26, argument_list; 26, 27; 26, 28; 27, identifier:ds; 28, identifier:best_hyp_indices; 29, for_in_clause; 29, 30; 29, 31; 30, identifier:ds; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:states | def sort_state(self, best_hyp_indices: mx.nd.NDArray):
self.states = [mx.nd.take(ds, best_hyp_indices) for ds in self.states] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 1, 27; 2, function_name:rerank; 3, parameters; 3, 4; 3, 5; 3, 15; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:hypotheses; 7, type; 7, 8; 8, generic_type; 8, 9; 8, 10; 9, identifier:Dict; 10, type_parameter; 10, 11; 10, 13; 11, type; 11, 12; 12, identifier:str; 13, type; 13, 14; 14, identifier:Any; 15, typed_parameter; 15, 16; 15, 17; 16, identifier:reference; 17, type; 17, 18; 18, identifier:str; 19, type; 19, 20; 20, generic_type; 20, 21; 20, 22; 21, identifier:Dict; 22, type_parameter; 22, 23; 22, 25; 23, type; 23, 24; 24, identifier:str; 25, type; 25, 26; 26, identifier:Any; 27, block; 27, 28; 27, 44; 27, 65; 27, 75; 27, 92; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:scores; 31, list_comprehension; 31, 32; 31, 39; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:scoring_function; 36, argument_list; 36, 37; 36, 38; 37, identifier:hypothesis; 38, identifier:reference; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:hypothesis; 41, subscript; 41, 42; 41, 43; 42, identifier:hypotheses; 43, string:'translations'; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:ranking; 47, call; 47, 48; 47, 49; 48, identifier:list; 49, argument_list; 49, 50; 50, subscript; 50, 51; 50, 60; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:np; 54, identifier:argsort; 55, argument_list; 55, 56; 55, 57; 56, identifier:scores; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:kind; 59, string:'mergesort'; 60, slice; 60, 61; 60, 62; 60, 63; 61, colon; 62, colon; 63, unary_operator:-; 63, 64; 64, integer:1; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:reranked_hypotheses; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:_sort_by_ranking; 72, argument_list; 72, 73; 72, 74; 73, identifier:hypotheses; 74, identifier:ranking; 75, if_statement; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:return_score; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 85; 82, subscript; 82, 83; 82, 84; 83, identifier:reranked_hypotheses; 84, string:'scores'; 85, list_comprehension; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:scores; 88, identifier:i; 89, for_in_clause; 89, 90; 89, 91; 90, identifier:i; 91, identifier:ranking; 92, return_statement; 92, 93; 93, identifier:reranked_hypotheses | def rerank(self, hypotheses: Dict[str, Any], reference: str) -> Dict[str, Any]:
scores = [self.scoring_function(hypothesis, reference) for hypothesis in hypotheses['translations']]
ranking = list(np.argsort(scores, kind='mergesort')[::-1])
reranked_hypotheses = self._sort_by_ranking(hypotheses, ranking)
if self.return_score:
reranked_hypotheses['scores'] = [scores[i] for i in ranking]
return reranked_hypotheses |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:load; 3, parameters; 3, 4; 3, 5; 3, 9; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:path; 7, type; 7, 8; 8, identifier:str; 9, typed_default_parameter; 9, 10; 9, 11; 9, 17; 10, identifier:k; 11, type; 11, 12; 12, generic_type; 12, 13; 12, 14; 13, identifier:Optional; 14, type_parameter; 14, 15; 15, type; 15, 16; 16, identifier:int; 17, None; 18, block; 18, 19; 18, 27; 18, 48; 18, 56; 18, 91; 18, 114; 18, 142; 18, 152; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:load_time_start; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:time; 25, identifier:time; 26, argument_list; 27, with_statement; 27, 28; 27, 38; 28, with_clause; 28, 29; 29, with_item; 29, 30; 30, as_pattern; 30, 31; 30, 36; 31, call; 31, 32; 31, 33; 32, identifier:open; 33, argument_list; 33, 34; 33, 35; 34, identifier:path; 35, string:'rb'; 36, as_pattern_target; 36, 37; 37, identifier:inp; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:_lex; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:np; 45, identifier:load; 46, argument_list; 46, 47; 47, identifier:inp; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:loaded_k; 51, subscript; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:_lex; 54, identifier:shape; 55, integer:1; 56, if_statement; 56, 57; 56, 60; 56, 85; 57, comparison_operator:is; 57, 58; 57, 59; 58, identifier:k; 59, None; 60, block; 60, 61; 60, 69; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:top_k; 64, call; 64, 65; 64, 66; 65, identifier:min; 66, argument_list; 66, 67; 66, 68; 67, identifier:k; 68, identifier:loaded_k; 69, if_statement; 69, 70; 69, 73; 70, comparison_operator:>; 70, 71; 70, 72; 71, identifier:k; 72, identifier:loaded_k; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:logger; 78, identifier:warning; 79, argument_list; 79, 80; 79, 83; 79, 84; 80, concatenated_string; 80, 81; 80, 82; 81, string:"Can not load top-%d translations from lexicon that "; 82, string:"contains at most %d entries per source."; 83, identifier:k; 84, identifier:loaded_k; 85, else_clause; 85, 86; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:top_k; 90, identifier:loaded_k; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:lex; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:np; 99, identifier:zeros; 100, argument_list; 100, 101; 100, 109; 101, tuple; 101, 102; 101, 108; 102, call; 102, 103; 102, 104; 103, identifier:len; 104, argument_list; 104, 105; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:vocab_source; 108, identifier:top_k; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:dtype; 111, attribute; 111, 112; 111, 113; 112, identifier:_lex; 113, identifier:dtype; 114, for_statement; 114, 115; 114, 118; 114, 122; 115, pattern_list; 115, 116; 115, 117; 116, identifier:src_id; 117, identifier:trg_ids; 118, call; 118, 119; 118, 120; 119, identifier:enumerate; 120, argument_list; 120, 121; 121, identifier:_lex; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 132; 125, subscript; 125, 126; 125, 129; 125, 130; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:lex; 129, identifier:src_id; 130, slice; 130, 131; 131, colon; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:np; 135, identifier:sort; 136, argument_list; 136, 137; 137, subscript; 137, 138; 137, 139; 138, identifier:trg_ids; 139, slice; 139, 140; 139, 141; 140, colon; 141, identifier:top_k; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:load_time; 145, binary_operator:-; 145, 146; 145, 151; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:time; 149, identifier:time; 150, argument_list; 151, identifier:load_time_start; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:logger; 156, identifier:info; 157, argument_list; 157, 158; 157, 159; 157, 160; 157, 161; 158, string:"Loaded top-%d lexicon from \"%s\" in %.4fs."; 159, identifier:top_k; 160, identifier:path; 161, identifier:load_time | def load(self, path: str, k: Optional[int] = None):
load_time_start = time.time()
with open(path, 'rb') as inp:
_lex = np.load(inp)
loaded_k = _lex.shape[1]
if k is not None:
top_k = min(k, loaded_k)
if k > loaded_k:
logger.warning("Can not load top-%d translations from lexicon that "
"contains at most %d entries per source.", k, loaded_k)
else:
top_k = loaded_k
self.lex = np.zeros((len(self.vocab_source), top_k), dtype=_lex.dtype)
for src_id, trg_ids in enumerate(_lex):
self.lex[src_id, :] = np.sort(trg_ids[:top_k])
load_time = time.time() - load_time_start
logger.info("Loaded top-%d lexicon from \"%s\" in %.4fs.", top_k, path, load_time) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 1, 15; 2, function_name:get_trg_ids; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:src_ids; 7, type; 7, 8; 8, attribute; 8, 9; 8, 10; 9, identifier:np; 10, identifier:ndarray; 11, type; 11, 12; 12, attribute; 12, 13; 12, 14; 13, identifier:np; 14, identifier:ndarray; 15, block; 15, 16; 15, 29; 15, 57; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:unique_src_ids; 19, call; 19, 20; 19, 27; 20, attribute; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:lib; 25, identifier:arraysetops; 26, identifier:unique; 27, argument_list; 27, 28; 28, identifier:src_ids; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:trg_ids; 32, call; 32, 33; 32, 40; 33, attribute; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:np; 37, identifier:lib; 38, identifier:arraysetops; 39, identifier:union1d; 40, argument_list; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:always_allow; 44, call; 44, 45; 44, 54; 45, attribute; 45, 46; 45, 53; 46, subscript; 46, 47; 46, 50; 46, 51; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:lex; 50, identifier:unique_src_ids; 51, slice; 51, 52; 52, colon; 53, identifier:reshape; 54, argument_list; 54, 55; 55, unary_operator:-; 55, 56; 56, integer:1; 57, return_statement; 57, 58; 58, identifier:trg_ids | def get_trg_ids(self, src_ids: np.ndarray) -> np.ndarray:
unique_src_ids = np.lib.arraysetops.unique(src_ids)
trg_ids = np.lib.arraysetops.union1d(self.always_allow, self.lex[unique_src_ids, :].reshape(-1))
return trg_ids |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:choice; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:obj; 6, block; 6, 7; 6, 24; 6, 41; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:tree_id; 10, call; 10, 11; 10, 12; 11, identifier:getattr; 12, argument_list; 12, 13; 12, 14; 12, 23; 13, identifier:obj; 14, attribute; 14, 15; 14, 22; 15, attribute; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:queryset; 20, identifier:model; 21, identifier:_mptt_meta; 22, identifier:tree_id_attr; 23, integer:0; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:left; 27, call; 27, 28; 27, 29; 28, identifier:getattr; 29, argument_list; 29, 30; 29, 31; 29, 40; 30, identifier:obj; 31, attribute; 31, 32; 31, 39; 32, attribute; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:queryset; 37, identifier:model; 38, identifier:_mptt_meta; 39, identifier:left_attr; 40, integer:0; 41, return_statement; 41, 42; 42, binary_operator:+; 42, 43; 42, 53; 43, call; 43, 44; 43, 51; 44, attribute; 44, 45; 44, 50; 45, call; 45, 46; 45, 47; 46, identifier:super; 47, argument_list; 47, 48; 47, 49; 48, identifier:MPTTModelChoiceIterator; 49, identifier:self; 50, identifier:choice; 51, argument_list; 51, 52; 52, identifier:obj; 53, tuple; 53, 54; 54, tuple; 54, 55; 54, 56; 55, identifier:tree_id; 56, identifier:left | def choice(self, obj):
tree_id = getattr(obj, self.queryset.model._mptt_meta.tree_id_attr, 0)
left = getattr(obj, self.queryset.model._mptt_meta.left_attr, 0)
return super(MPTTModelChoiceIterator,
self).choice(obj) + ((tree_id, left),) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_best_dataset_key; 3, parameters; 3, 4; 3, 5; 4, identifier:key; 5, identifier:choices; 6, block; 6, 7; 6, 61; 6, 110; 6, 165; 6, 212; 6, 259; 7, if_statement; 7, 8; 7, 15; 8, boolean_operator:and; 8, 9; 8, 14; 9, comparison_operator:is; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:key; 12, identifier:wavelength; 13, None; 14, identifier:choices; 15, block; 15, 16; 15, 41; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:nearest_wl; 19, call; 19, 20; 19, 21; 20, identifier:min; 21, argument_list; 21, 22; 22, list_comprehension; 22, 23; 22, 32; 22, 35; 23, call; 23, 24; 23, 25; 24, identifier:_wl_dist; 25, argument_list; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:key; 28, identifier:wavelength; 29, attribute; 29, 30; 29, 31; 30, identifier:x; 31, identifier:wavelength; 32, for_in_clause; 32, 33; 32, 34; 33, identifier:x; 34, identifier:choices; 35, if_clause; 35, 36; 36, comparison_operator:is; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:x; 39, identifier:wavelength; 40, None; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:choices; 44, list_comprehension; 44, 45; 44, 46; 44, 49; 45, identifier:c; 46, for_in_clause; 46, 47; 46, 48; 47, identifier:c; 48, identifier:choices; 49, if_clause; 49, 50; 50, comparison_operator:==; 50, 51; 50, 60; 51, call; 51, 52; 51, 53; 52, identifier:_wl_dist; 53, argument_list; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:key; 56, identifier:wavelength; 57, attribute; 57, 58; 57, 59; 58, identifier:c; 59, identifier:wavelength; 60, identifier:nearest_wl; 61, if_statement; 61, 62; 61, 69; 62, boolean_operator:and; 62, 63; 62, 68; 63, comparison_operator:is; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:key; 66, identifier:modifiers; 67, None; 68, identifier:choices; 69, block; 69, 70; 69, 89; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:num_modifiers; 73, call; 73, 74; 73, 75; 74, identifier:min; 75, generator_expression; 75, 76; 75, 86; 76, call; 76, 77; 76, 78; 77, identifier:len; 78, argument_list; 78, 79; 79, boolean_operator:or; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:x; 82, identifier:modifiers; 83, call; 83, 84; 83, 85; 84, identifier:tuple; 85, argument_list; 86, for_in_clause; 86, 87; 86, 88; 87, identifier:x; 88, identifier:choices; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:choices; 92, list_comprehension; 92, 93; 92, 94; 92, 97; 93, identifier:c; 94, for_in_clause; 94, 95; 94, 96; 95, identifier:c; 96, identifier:choices; 97, if_clause; 97, 98; 98, comparison_operator:==; 98, 99; 98, 109; 99, call; 99, 100; 99, 101; 100, identifier:len; 101, argument_list; 101, 102; 102, boolean_operator:or; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:c; 105, identifier:modifiers; 106, call; 106, 107; 106, 108; 107, identifier:tuple; 108, argument_list; 109, identifier:num_modifiers; 110, if_statement; 110, 111; 110, 118; 111, boolean_operator:and; 111, 112; 111, 117; 112, comparison_operator:is; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:key; 115, identifier:calibration; 116, None; 117, identifier:choices; 118, block; 118, 119; 118, 133; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:best_cal; 122, list_comprehension; 122, 123; 122, 126; 122, 129; 123, attribute; 123, 124; 123, 125; 124, identifier:x; 125, identifier:calibration; 126, for_in_clause; 126, 127; 126, 128; 127, identifier:x; 128, identifier:choices; 129, if_clause; 129, 130; 130, attribute; 130, 131; 130, 132; 131, identifier:x; 132, identifier:calibration; 133, if_statement; 133, 134; 133, 135; 134, identifier:best_cal; 135, block; 135, 136; 135, 151; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:best_cal; 139, call; 139, 140; 139, 141; 140, identifier:min; 141, argument_list; 141, 142; 141, 143; 142, identifier:best_cal; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:key; 145, lambda; 145, 146; 145, 148; 146, lambda_parameters; 146, 147; 147, identifier:x; 148, subscript; 148, 149; 148, 150; 149, identifier:CALIBRATION_ORDER; 150, identifier:x; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:choices; 154, list_comprehension; 154, 155; 154, 156; 154, 159; 155, identifier:c; 156, for_in_clause; 156, 157; 156, 158; 157, identifier:c; 158, identifier:choices; 159, if_clause; 159, 160; 160, comparison_operator:==; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:c; 163, identifier:calibration; 164, identifier:best_cal; 165, if_statement; 165, 166; 165, 173; 166, boolean_operator:and; 166, 167; 166, 172; 167, comparison_operator:is; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:key; 170, identifier:resolution; 171, None; 172, identifier:choices; 173, block; 173, 174; 173, 188; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:low_res; 177, list_comprehension; 177, 178; 177, 181; 177, 184; 178, attribute; 178, 179; 178, 180; 179, identifier:x; 180, identifier:resolution; 181, for_in_clause; 181, 182; 181, 183; 182, identifier:x; 183, identifier:choices; 184, if_clause; 184, 185; 185, attribute; 185, 186; 185, 187; 186, identifier:x; 187, identifier:resolution; 188, if_statement; 188, 189; 188, 190; 189, identifier:low_res; 190, block; 190, 191; 190, 198; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:low_res; 194, call; 194, 195; 194, 196; 195, identifier:min; 196, argument_list; 196, 197; 197, identifier:low_res; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:choices; 201, list_comprehension; 201, 202; 201, 203; 201, 206; 202, identifier:c; 203, for_in_clause; 203, 204; 203, 205; 204, identifier:c; 205, identifier:choices; 206, if_clause; 206, 207; 207, comparison_operator:==; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:c; 210, identifier:resolution; 211, identifier:low_res; 212, if_statement; 212, 213; 212, 220; 213, boolean_operator:and; 213, 214; 213, 219; 214, comparison_operator:is; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:key; 217, identifier:level; 218, None; 219, identifier:choices; 220, block; 220, 221; 220, 235; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:low_level; 224, list_comprehension; 224, 225; 224, 228; 224, 231; 225, attribute; 225, 226; 225, 227; 226, identifier:x; 227, identifier:level; 228, for_in_clause; 228, 229; 228, 230; 229, identifier:x; 230, identifier:choices; 231, if_clause; 231, 232; 232, attribute; 232, 233; 232, 234; 233, identifier:x; 234, identifier:level; 235, if_statement; 235, 236; 235, 237; 236, identifier:low_level; 237, block; 237, 238; 237, 245; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:low_level; 241, call; 241, 242; 241, 243; 242, identifier:max; 243, argument_list; 243, 244; 244, identifier:low_level; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:choices; 248, list_comprehension; 248, 249; 248, 250; 248, 253; 249, identifier:c; 250, for_in_clause; 250, 251; 250, 252; 251, identifier:c; 252, identifier:choices; 253, if_clause; 253, 254; 254, comparison_operator:==; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:c; 257, identifier:level; 258, identifier:low_level; 259, return_statement; 259, 260; 260, identifier:choices | def get_best_dataset_key(key, choices):
if key.wavelength is not None and choices:
nearest_wl = min([_wl_dist(key.wavelength, x.wavelength)
for x in choices if x.wavelength is not None])
choices = [c for c in choices
if _wl_dist(key.wavelength, c.wavelength) == nearest_wl]
if key.modifiers is None and choices:
num_modifiers = min(len(x.modifiers or tuple()) for x in choices)
choices = [c for c in choices if len(
c.modifiers or tuple()) == num_modifiers]
if key.calibration is None and choices:
best_cal = [x.calibration for x in choices if x.calibration]
if best_cal:
best_cal = min(best_cal, key=lambda x: CALIBRATION_ORDER[x])
choices = [c for c in choices if c.calibration == best_cal]
if key.resolution is None and choices:
low_res = [x.resolution for x in choices if x.resolution]
if low_res:
low_res = min(low_res)
choices = [c for c in choices if c.resolution == low_res]
if key.level is None and choices:
low_level = [x.level for x in choices if x.level]
if low_level:
low_level = max(low_level)
choices = [c for c in choices if c.level == low_level]
return choices |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 27; 2, function_name:get_key; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 4, identifier:key; 5, identifier:key_container; 6, default_parameter; 6, 7; 6, 8; 7, identifier:num_results; 8, integer:1; 9, default_parameter; 9, 10; 9, 11; 10, identifier:best; 11, True; 12, default_parameter; 12, 13; 12, 14; 13, identifier:resolution; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:calibration; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:polarization; 20, None; 21, default_parameter; 21, 22; 21, 23; 22, identifier:level; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:modifiers; 26, None; 27, block; 27, 28; 27, 98; 27, 106; 27, 146; 27, 186; 27, 226; 27, 266; 27, 291; 27, 302; 28, if_statement; 28, 29; 28, 36; 28, 49; 28, 72; 29, call; 29, 30; 29, 31; 30, identifier:isinstance; 31, argument_list; 31, 32; 31, 33; 32, identifier:key; 33, attribute; 33, 34; 33, 35; 34, identifier:numbers; 35, identifier:Number; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:key; 40, call; 40, 41; 40, 42; 41, identifier:DatasetID; 42, argument_list; 42, 43; 42, 46; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:wavelength; 45, identifier:key; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:modifiers; 48, None; 49, elif_clause; 49, 50; 49, 59; 50, call; 50, 51; 50, 52; 51, identifier:isinstance; 52, argument_list; 52, 53; 52, 54; 53, identifier:key; 54, tuple; 54, 55; 54, 56; 55, identifier:str; 56, attribute; 56, 57; 56, 58; 57, identifier:six; 58, identifier:text_type; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:key; 63, call; 63, 64; 63, 65; 64, identifier:DatasetID; 65, argument_list; 65, 66; 65, 69; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:name; 68, identifier:key; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:modifiers; 71, None; 72, elif_clause; 72, 73; 72, 79; 73, not_operator; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:isinstance; 76, argument_list; 76, 77; 76, 78; 77, identifier:key; 78, identifier:DatasetID; 79, block; 79, 80; 80, raise_statement; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:ValueError; 83, argument_list; 83, 84; 84, call; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, concatenated_string; 86, 87; 86, 88; 87, string:"Expected 'DatasetID', str, or number dict key, "; 88, string:"not {}"; 89, identifier:format; 90, argument_list; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:str; 93, argument_list; 93, 94; 94, call; 94, 95; 94, 96; 95, identifier:type; 96, argument_list; 96, 97; 97, identifier:key; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:res; 101, call; 101, 102; 101, 103; 102, identifier:filter_keys_by_dataset_id; 103, argument_list; 103, 104; 103, 105; 104, identifier:key; 105, identifier:key_container; 106, if_statement; 106, 107; 106, 110; 107, comparison_operator:is; 107, 108; 107, 109; 108, identifier:resolution; 109, None; 110, block; 110, 111; 110, 126; 111, if_statement; 111, 112; 111, 120; 112, not_operator; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:isinstance; 115, argument_list; 115, 116; 115, 117; 116, identifier:resolution; 117, tuple; 117, 118; 117, 119; 118, identifier:list; 119, identifier:tuple; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:resolution; 124, tuple; 124, 125; 125, identifier:resolution; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:res; 129, list_comprehension; 129, 130; 129, 131; 129, 134; 130, identifier:k; 131, for_in_clause; 131, 132; 131, 133; 132, identifier:k; 133, identifier:res; 134, if_clause; 134, 135; 135, boolean_operator:and; 135, 136; 135, 141; 136, comparison_operator:is; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:k; 139, identifier:resolution; 140, None; 141, comparison_operator:in; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:k; 144, identifier:resolution; 145, identifier:resolution; 146, if_statement; 146, 147; 146, 150; 147, comparison_operator:is; 147, 148; 147, 149; 148, identifier:polarization; 149, None; 150, block; 150, 151; 150, 166; 151, if_statement; 151, 152; 151, 160; 152, not_operator; 152, 153; 153, call; 153, 154; 153, 155; 154, identifier:isinstance; 155, argument_list; 155, 156; 155, 157; 156, identifier:polarization; 157, tuple; 157, 158; 157, 159; 158, identifier:list; 159, identifier:tuple; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:polarization; 164, tuple; 164, 165; 165, identifier:polarization; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:res; 169, list_comprehension; 169, 170; 169, 171; 169, 174; 170, identifier:k; 171, for_in_clause; 171, 172; 171, 173; 172, identifier:k; 173, identifier:res; 174, if_clause; 174, 175; 175, boolean_operator:and; 175, 176; 175, 181; 176, comparison_operator:is; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:k; 179, identifier:polarization; 180, None; 181, comparison_operator:in; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:k; 184, identifier:polarization; 185, identifier:polarization; 186, if_statement; 186, 187; 186, 190; 187, comparison_operator:is; 187, 188; 187, 189; 188, identifier:calibration; 189, None; 190, block; 190, 191; 190, 206; 191, if_statement; 191, 192; 191, 200; 192, not_operator; 192, 193; 193, call; 193, 194; 193, 195; 194, identifier:isinstance; 195, argument_list; 195, 196; 195, 197; 196, identifier:calibration; 197, tuple; 197, 198; 197, 199; 198, identifier:list; 199, identifier:tuple; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:calibration; 204, tuple; 204, 205; 205, identifier:calibration; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:res; 209, list_comprehension; 209, 210; 209, 211; 209, 214; 210, identifier:k; 211, for_in_clause; 211, 212; 211, 213; 212, identifier:k; 213, identifier:res; 214, if_clause; 214, 215; 215, boolean_operator:and; 215, 216; 215, 221; 216, comparison_operator:is; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:k; 219, identifier:calibration; 220, None; 221, comparison_operator:in; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:k; 224, identifier:calibration; 225, identifier:calibration; 226, if_statement; 226, 227; 226, 230; 227, comparison_operator:is; 227, 228; 227, 229; 228, identifier:level; 229, None; 230, block; 230, 231; 230, 246; 231, if_statement; 231, 232; 231, 240; 232, not_operator; 232, 233; 233, call; 233, 234; 233, 235; 234, identifier:isinstance; 235, argument_list; 235, 236; 235, 237; 236, identifier:level; 237, tuple; 237, 238; 237, 239; 238, identifier:list; 239, identifier:tuple; 240, block; 240, 241; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:level; 244, tuple; 244, 245; 245, identifier:level; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:res; 249, list_comprehension; 249, 250; 249, 251; 249, 254; 250, identifier:k; 251, for_in_clause; 251, 252; 251, 253; 252, identifier:k; 253, identifier:res; 254, if_clause; 254, 255; 255, boolean_operator:and; 255, 256; 255, 261; 256, comparison_operator:is; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:k; 259, identifier:level; 260, None; 261, comparison_operator:in; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:k; 264, identifier:level; 265, identifier:level; 266, if_statement; 266, 267; 266, 270; 267, comparison_operator:is; 267, 268; 267, 269; 268, identifier:modifiers; 269, None; 270, block; 270, 271; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:res; 274, list_comprehension; 274, 275; 274, 276; 274, 279; 275, identifier:k; 276, for_in_clause; 276, 277; 276, 278; 277, identifier:k; 278, identifier:res; 279, if_clause; 279, 280; 280, boolean_operator:and; 280, 281; 280, 286; 281, comparison_operator:is; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:k; 284, identifier:modifiers; 285, None; 286, comparison_operator:==; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:k; 289, identifier:modifiers; 290, identifier:modifiers; 291, if_statement; 291, 292; 291, 293; 292, identifier:best; 293, block; 293, 294; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:res; 297, call; 297, 298; 297, 299; 298, identifier:get_best_dataset_key; 299, argument_list; 299, 300; 299, 301; 300, identifier:key; 301, identifier:res; 302, if_statement; 302, 303; 302, 309; 302, 323; 302, 348; 302, 357; 302, 364; 303, boolean_operator:and; 303, 304; 303, 307; 304, comparison_operator:==; 304, 305; 304, 306; 305, identifier:num_results; 306, integer:1; 307, not_operator; 307, 308; 308, identifier:res; 309, block; 309, 310; 310, raise_statement; 310, 311; 311, call; 311, 312; 311, 313; 312, identifier:KeyError; 313, argument_list; 313, 314; 314, call; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, string:"No dataset matching '{}' found"; 317, identifier:format; 318, argument_list; 318, 319; 319, call; 319, 320; 319, 321; 320, identifier:str; 321, argument_list; 321, 322; 322, identifier:key; 323, elif_clause; 323, 324; 323, 334; 324, boolean_operator:and; 324, 325; 324, 328; 325, comparison_operator:==; 325, 326; 325, 327; 326, identifier:num_results; 327, integer:1; 328, comparison_operator:!=; 328, 329; 328, 333; 329, call; 329, 330; 329, 331; 330, identifier:len; 331, argument_list; 331, 332; 332, identifier:res; 333, integer:1; 334, block; 334, 335; 335, raise_statement; 335, 336; 336, call; 336, 337; 336, 338; 337, identifier:TooManyResults; 338, argument_list; 338, 339; 339, call; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, string:"No unique dataset matching {}"; 342, identifier:format; 343, argument_list; 343, 344; 344, call; 344, 345; 344, 346; 345, identifier:str; 346, argument_list; 346, 347; 347, identifier:key; 348, elif_clause; 348, 349; 348, 352; 349, comparison_operator:==; 349, 350; 349, 351; 350, identifier:num_results; 351, integer:1; 352, block; 352, 353; 353, return_statement; 353, 354; 354, subscript; 354, 355; 354, 356; 355, identifier:res; 356, integer:0; 357, elif_clause; 357, 358; 357, 361; 358, comparison_operator:==; 358, 359; 358, 360; 359, identifier:num_results; 360, integer:0; 361, block; 361, 362; 362, return_statement; 362, 363; 363, identifier:res; 364, else_clause; 364, 365; 365, block; 365, 366; 366, return_statement; 366, 367; 367, subscript; 367, 368; 367, 369; 368, identifier:res; 369, slice; 369, 370; 369, 371; 370, colon; 371, identifier:num_results | def get_key(key, key_container, num_results=1, best=True,
resolution=None, calibration=None, polarization=None,
level=None, modifiers=None):
if isinstance(key, numbers.Number):
key = DatasetID(wavelength=key, modifiers=None)
elif isinstance(key, (str, six.text_type)):
key = DatasetID(name=key, modifiers=None)
elif not isinstance(key, DatasetID):
raise ValueError("Expected 'DatasetID', str, or number dict key, "
"not {}".format(str(type(key))))
res = filter_keys_by_dataset_id(key, key_container)
if resolution is not None:
if not isinstance(resolution, (list, tuple)):
resolution = (resolution, )
res = [k for k in res
if k.resolution is not None and k.resolution in resolution]
if polarization is not None:
if not isinstance(polarization, (list, tuple)):
polarization = (polarization, )
res = [k for k in res
if k.polarization is not None and k.polarization in
polarization]
if calibration is not None:
if not isinstance(calibration, (list, tuple)):
calibration = (calibration, )
res = [k for k in res
if k.calibration is not None and k.calibration in calibration]
if level is not None:
if not isinstance(level, (list, tuple)):
level = (level, )
res = [k for k in res
if k.level is not None and k.level in level]
if modifiers is not None:
res = [k for k in res
if k.modifiers is not None and k.modifiers == modifiers]
if best:
res = get_best_dataset_key(key, res)
if num_results == 1 and not res:
raise KeyError("No dataset matching '{}' found".format(str(key)))
elif num_results == 1 and len(res) != 1:
raise TooManyResults("No unique dataset matching {}".format(str(key)))
elif num_results == 1:
return res[0]
elif num_results == 0:
return res
else:
return res[:num_results] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:group_files; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:files_to_sort; 5, default_parameter; 5, 6; 5, 7; 6, identifier:reader; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:time_threshold; 10, integer:10; 11, default_parameter; 11, 12; 11, 13; 12, identifier:group_keys; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:ppp_config_dir; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:reader_kwargs; 19, None; 20, block; 20, 21; 20, 46; 20, 52; 20, 65; 20, 71; 20, 115; 20, 133; 20, 137; 20, 183; 20, 187; 20, 196; 20, 200; 20, 318; 20, 325; 21, if_statement; 21, 22; 21, 25; 21, 31; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:reader; 24, None; 25, block; 25, 26; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:ValueError; 29, argument_list; 29, 30; 30, string:"'reader' keyword argument is required."; 31, elif_clause; 31, 32; 31, 40; 32, not_operator; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:isinstance; 35, argument_list; 35, 36; 35, 37; 36, identifier:reader; 37, tuple; 37, 38; 37, 39; 38, identifier:list; 39, identifier:tuple; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:reader; 44, list:[reader]; 44, 45; 45, identifier:reader; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:reader; 49, subscript; 49, 50; 49, 51; 50, identifier:reader; 51, integer:0; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:reader_configs; 55, subscript; 55, 56; 55, 64; 56, call; 56, 57; 56, 58; 57, identifier:list; 58, argument_list; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:configs_for_reader; 61, argument_list; 61, 62; 61, 63; 62, identifier:reader; 63, identifier:ppp_config_dir; 64, integer:0; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:reader_kwargs; 68, boolean_operator:or; 68, 69; 68, 70; 69, identifier:reader_kwargs; 70, dictionary; 71, try_statement; 71, 72; 71, 82; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:reader_instance; 76, call; 76, 77; 76, 78; 77, identifier:load_reader; 78, argument_list; 78, 79; 78, 80; 79, identifier:reader_configs; 80, dictionary_splat; 80, 81; 81, identifier:reader_kwargs; 82, except_clause; 82, 83; 82, 92; 83, as_pattern; 83, 84; 83, 90; 84, tuple; 84, 85; 84, 86; 84, 87; 85, identifier:KeyError; 86, identifier:IOError; 87, attribute; 87, 88; 87, 89; 88, identifier:yaml; 89, identifier:YAMLError; 90, as_pattern_target; 90, 91; 91, identifier:err; 92, block; 92, 93; 92, 104; 92, 114; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:LOG; 97, identifier:info; 98, argument_list; 98, 99; 98, 100; 99, string:'Cannot use %s'; 100, call; 100, 101; 100, 102; 101, identifier:str; 102, argument_list; 102, 103; 103, identifier:reader_configs; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:LOG; 108, identifier:debug; 109, argument_list; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:str; 112, argument_list; 112, 113; 113, identifier:err; 114, raise_statement; 115, if_statement; 115, 116; 115, 119; 116, comparison_operator:is; 116, 117; 116, 118; 117, identifier:group_keys; 118, None; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:group_keys; 123, call; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:reader_instance; 127, identifier:info; 128, identifier:get; 129, argument_list; 129, 130; 129, 131; 130, string:'group_keys'; 131, tuple; 131, 132; 132, string:'start_time'; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:file_keys; 136, list:[]; 137, for_statement; 137, 138; 137, 141; 137, 146; 138, pattern_list; 138, 139; 138, 140; 139, identifier:filetype; 140, identifier:filetype_info; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:reader_instance; 144, identifier:sorted_filetype_items; 145, argument_list; 146, block; 146, 147; 147, for_statement; 147, 148; 147, 151; 147, 158; 148, pattern_list; 148, 149; 148, 150; 149, identifier:f; 150, identifier:file_info; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:reader_instance; 154, identifier:filename_items_for_filetype; 155, argument_list; 155, 156; 155, 157; 156, identifier:files_to_sort; 157, identifier:filetype_info; 158, block; 158, 159; 158, 174; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:group_key; 162, call; 162, 163; 162, 164; 163, identifier:tuple; 164, generator_expression; 164, 165; 164, 171; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:file_info; 168, identifier:get; 169, argument_list; 169, 170; 170, identifier:k; 171, for_in_clause; 171, 172; 171, 173; 172, identifier:k; 173, identifier:group_keys; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:file_keys; 178, identifier:append; 179, argument_list; 179, 180; 180, tuple; 180, 181; 180, 182; 181, identifier:group_key; 182, identifier:f; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:prev_key; 186, None; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:threshold; 190, call; 190, 191; 190, 192; 191, identifier:timedelta; 192, argument_list; 192, 193; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:seconds; 195, identifier:time_threshold; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:file_groups; 199, dictionary; 200, for_statement; 200, 201; 200, 204; 200, 208; 201, pattern_list; 201, 202; 201, 203; 202, identifier:gk; 203, identifier:f; 204, call; 204, 205; 204, 206; 205, identifier:sorted; 206, argument_list; 206, 207; 207, identifier:file_keys; 208, block; 208, 209; 208, 256; 208, 288; 209, if_statement; 209, 210; 209, 213; 209, 222; 209, 244; 210, comparison_operator:is; 210, 211; 210, 212; 211, identifier:prev_key; 212, None; 213, block; 213, 214; 213, 218; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:is_new_group; 217, True; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:prev_key; 221, identifier:gk; 222, elif_clause; 222, 223; 222, 230; 223, call; 223, 224; 223, 225; 224, identifier:isinstance; 225, argument_list; 225, 226; 225, 229; 226, subscript; 226, 227; 226, 228; 227, identifier:gk; 228, integer:0; 229, identifier:datetime; 230, block; 230, 231; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:is_new_group; 234, comparison_operator:>; 234, 235; 234, 243; 235, parenthesized_expression; 235, 236; 236, binary_operator:-; 236, 237; 236, 240; 237, subscript; 237, 238; 237, 239; 238, identifier:gk; 239, integer:0; 240, subscript; 240, 241; 240, 242; 241, identifier:prev_key; 242, integer:0; 243, identifier:threshold; 244, else_clause; 244, 245; 245, block; 245, 246; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:is_new_group; 249, comparison_operator:!=; 249, 250; 249, 253; 250, subscript; 250, 251; 250, 252; 251, identifier:gk; 252, integer:0; 253, subscript; 253, 254; 253, 255; 254, identifier:prev_key; 255, integer:0; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 258, identifier:vals_not_equal; 259, generator_expression; 259, 260; 259, 263; 259, 280; 260, comparison_operator:!=; 260, 261; 260, 262; 261, identifier:this_val; 262, identifier:prev_val; 263, for_in_clause; 263, 264; 263, 267; 264, pattern_list; 264, 265; 264, 266; 265, identifier:this_val; 266, identifier:prev_val; 267, call; 267, 268; 267, 269; 268, identifier:zip; 269, argument_list; 269, 270; 269, 275; 270, subscript; 270, 271; 270, 272; 271, identifier:gk; 272, slice; 272, 273; 272, 274; 273, integer:1; 274, colon; 275, subscript; 275, 276; 275, 277; 276, identifier:prev_key; 277, slice; 277, 278; 277, 279; 278, integer:1; 279, colon; 280, if_clause; 280, 281; 281, boolean_operator:and; 281, 282; 281, 285; 282, comparison_operator:is; 282, 283; 282, 284; 283, identifier:this_val; 284, None; 285, comparison_operator:is; 285, 286; 285, 287; 286, identifier:prev_val; 287, None; 288, if_statement; 288, 289; 288, 295; 288, 307; 289, boolean_operator:or; 289, 290; 289, 291; 290, identifier:is_new_group; 291, call; 291, 292; 291, 293; 292, identifier:any; 293, argument_list; 293, 294; 294, identifier:vals_not_equal; 295, block; 295, 296; 295, 303; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 301; 298, subscript; 298, 299; 298, 300; 299, identifier:file_groups; 300, identifier:gk; 301, list:[f]; 301, 302; 302, identifier:f; 303, expression_statement; 303, 304; 304, assignment; 304, 305; 304, 306; 305, identifier:prev_key; 306, identifier:gk; 307, else_clause; 307, 308; 308, block; 308, 309; 309, expression_statement; 309, 310; 310, call; 310, 311; 310, 316; 311, attribute; 311, 312; 311, 315; 312, subscript; 312, 313; 312, 314; 313, identifier:file_groups; 314, identifier:prev_key; 315, identifier:append; 316, argument_list; 316, 317; 317, identifier:f; 318, expression_statement; 318, 319; 319, assignment; 319, 320; 319, 321; 320, identifier:sorted_group_keys; 321, call; 321, 322; 321, 323; 322, identifier:sorted; 323, argument_list; 323, 324; 324, identifier:file_groups; 325, return_statement; 325, 326; 326, list_comprehension; 326, 327; 326, 333; 327, dictionary; 327, 328; 328, pair; 328, 329; 328, 330; 329, identifier:reader; 330, subscript; 330, 331; 330, 332; 331, identifier:file_groups; 332, identifier:group_key; 333, for_in_clause; 333, 334; 333, 335; 334, identifier:group_key; 335, identifier:sorted_group_keys | def group_files(files_to_sort, reader=None, time_threshold=10,
group_keys=None, ppp_config_dir=None, reader_kwargs=None):
if reader is None:
raise ValueError("'reader' keyword argument is required.")
elif not isinstance(reader, (list, tuple)):
reader = [reader]
reader = reader[0]
reader_configs = list(configs_for_reader(reader, ppp_config_dir))[0]
reader_kwargs = reader_kwargs or {}
try:
reader_instance = load_reader(reader_configs, **reader_kwargs)
except (KeyError, IOError, yaml.YAMLError) as err:
LOG.info('Cannot use %s', str(reader_configs))
LOG.debug(str(err))
raise
if group_keys is None:
group_keys = reader_instance.info.get('group_keys', ('start_time',))
file_keys = []
for filetype, filetype_info in reader_instance.sorted_filetype_items():
for f, file_info in reader_instance.filename_items_for_filetype(files_to_sort, filetype_info):
group_key = tuple(file_info.get(k) for k in group_keys)
file_keys.append((group_key, f))
prev_key = None
threshold = timedelta(seconds=time_threshold)
file_groups = {}
for gk, f in sorted(file_keys):
if prev_key is None:
is_new_group = True
prev_key = gk
elif isinstance(gk[0], datetime):
is_new_group = (gk[0] - prev_key[0]) > threshold
else:
is_new_group = gk[0] != prev_key[0]
vals_not_equal = (this_val != prev_val for this_val, prev_val in zip(gk[1:], prev_key[1:])
if this_val is not None and prev_val is not None)
if is_new_group or any(vals_not_equal):
file_groups[gk] = [f]
prev_key = gk
else:
file_groups[prev_key].append(f)
sorted_group_keys = sorted(file_groups)
return [{reader: file_groups[group_key]} for group_key in sorted_group_keys] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sorted_filetype_items; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 25; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:processed_types; 9, list:[]; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:file_type_items; 13, call; 13, 14; 13, 15; 14, identifier:deque; 15, argument_list; 15, 16; 16, call; 16, 17; 16, 24; 17, attribute; 17, 18; 17, 23; 18, subscript; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:config; 22, string:'file_types'; 23, identifier:items; 24, argument_list; 25, while_statement; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, identifier:file_type_items; 30, block; 30, 31; 30, 41; 30, 50; 30, 80; 30, 87; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 36; 33, pattern_list; 33, 34; 33, 35; 34, identifier:filetype; 35, identifier:filetype_info; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:file_type_items; 39, identifier:popleft; 40, argument_list; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:requirements; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:filetype_info; 47, identifier:get; 48, argument_list; 48, 49; 49, string:'requires'; 50, if_statement; 50, 51; 50, 54; 51, comparison_operator:is; 51, 52; 51, 53; 52, identifier:requirements; 53, None; 54, block; 54, 55; 54, 67; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:missing; 58, list_comprehension; 58, 59; 58, 60; 58, 63; 59, identifier:req; 60, for_in_clause; 60, 61; 60, 62; 61, identifier:req; 62, identifier:requirements; 63, if_clause; 63, 64; 64, comparison_operator:not; 64, 65; 64, 66; 65, identifier:req; 66, identifier:processed_types; 67, if_statement; 67, 68; 67, 69; 68, identifier:missing; 69, block; 69, 70; 69, 79; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:file_type_items; 74, identifier:append; 75, argument_list; 75, 76; 76, tuple; 76, 77; 76, 78; 77, identifier:filetype; 78, identifier:filetype_info; 79, continue_statement; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:processed_types; 84, identifier:append; 85, argument_list; 85, 86; 86, identifier:filetype; 87, expression_statement; 87, 88; 88, yield; 88, 89; 89, expression_list; 89, 90; 89, 91; 90, identifier:filetype; 91, identifier:filetype_info | def sorted_filetype_items(self):
processed_types = []
file_type_items = deque(self.config['file_types'].items())
while len(file_type_items):
filetype, filetype_info = file_type_items.popleft()
requirements = filetype_info.get('requires')
if requirements is not None:
missing = [req for req in requirements
if req not in processed_types]
if missing:
file_type_items.append((filetype, filetype_info))
continue
processed_types.append(filetype)
yield filetype, filetype_info |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:combine_hashes; 3, parameters; 3, 4; 4, identifier:hashes; 5, block; 5, 6; 5, 12; 5, 33; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:hasher; 9, call; 9, 10; 9, 11; 10, identifier:sha1; 11, argument_list; 12, for_statement; 12, 13; 12, 14; 12, 18; 13, identifier:h; 14, call; 14, 15; 14, 16; 15, identifier:sorted; 16, argument_list; 16, 17; 17, identifier:hashes; 18, block; 18, 19; 18, 26; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:h; 22, call; 22, 23; 22, 24; 23, identifier:ensure_binary; 24, argument_list; 24, 25; 25, identifier:h; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:hasher; 30, identifier:update; 31, argument_list; 31, 32; 32, identifier:h; 33, return_statement; 33, 34; 34, conditional_expression:if; 34, 35; 34, 40; 34, 41; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:hasher; 38, identifier:hexdigest; 39, argument_list; 40, identifier:PY3; 41, call; 41, 42; 41, 49; 42, attribute; 42, 43; 42, 48; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:hasher; 46, identifier:hexdigest; 47, argument_list; 48, identifier:decode; 49, argument_list; 49, 50; 50, string:'utf-8' | def combine_hashes(hashes):
hasher = sha1()
for h in sorted(hashes):
h = ensure_binary(h)
hasher.update(h)
return hasher.hexdigest() if PY3 else hasher.hexdigest().decode('utf-8') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 31; 2, function_name:register_jvm_tool; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 28; 4, identifier:cls; 5, identifier:register; 6, identifier:key; 7, default_parameter; 7, 8; 7, 9; 8, identifier:classpath_spec; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:main; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:custom_rules; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:fingerprint; 18, True; 19, default_parameter; 19, 20; 19, 21; 20, identifier:classpath; 21, None; 22, default_parameter; 22, 23; 22, 24; 23, identifier:help; 24, None; 25, default_parameter; 25, 26; 25, 27; 26, identifier:removal_version; 27, None; 28, default_parameter; 28, 29; 28, 30; 29, identifier:removal_hint; 30, None; 31, block; 31, 32; 31, 59; 31, 67; 31, 108; 31, 123; 32, function_definition; 32, 33; 32, 34; 32, 35; 33, function_name:formulate_help; 34, parameters; 35, block; 35, 36; 36, if_statement; 36, 37; 36, 38; 36, 50; 37, identifier:classpath; 38, block; 38, 39; 39, return_statement; 39, 40; 40, parenthesized_expression; 40, 41; 41, call; 41, 42; 41, 47; 42, attribute; 42, 43; 42, 46; 43, concatenated_string; 43, 44; 43, 45; 44, string:'Target address spec for overriding the classpath of the {} jvm tool which is, '; 45, string:'by default: {}'; 46, identifier:format; 47, argument_list; 47, 48; 47, 49; 48, identifier:key; 49, identifier:classpath; 50, else_clause; 50, 51; 51, block; 51, 52; 52, return_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, string:'Target address spec for specifying the classpath of the {} jvm tool.'; 56, identifier:format; 57, argument_list; 57, 58; 58, identifier:key; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:help; 62, boolean_operator:or; 62, 63; 62, 64; 63, identifier:help; 64, call; 64, 65; 64, 66; 65, identifier:formulate_help; 66, argument_list; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:register; 70, argument_list; 70, 71; 70, 77; 70, 80; 70, 83; 70, 96; 70, 99; 70, 102; 70, 105; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, string:'--{}'; 74, identifier:format; 75, argument_list; 75, 76; 76, identifier:key; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:advanced; 79, True; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:type; 82, identifier:target_option; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:default; 85, conditional_expression:if; 85, 86; 85, 92; 85, 95; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, string:'//:{}'; 89, identifier:format; 90, argument_list; 90, 91; 91, identifier:key; 92, comparison_operator:is; 92, 93; 92, 94; 93, identifier:classpath_spec; 94, None; 95, identifier:classpath_spec; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:help; 98, identifier:help; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:fingerprint; 101, identifier:fingerprint; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:removal_version; 104, identifier:removal_version; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:removal_hint; 107, identifier:removal_hint; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:jvm_tool; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:cls; 114, identifier:JvmTool; 115, argument_list; 115, 116; 115, 119; 115, 120; 115, 121; 115, 122; 116, attribute; 116, 117; 116, 118; 117, identifier:register; 118, identifier:scope; 119, identifier:key; 120, identifier:classpath; 121, identifier:main; 122, identifier:custom_rules; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:JvmToolMixin; 128, identifier:_jvm_tools; 129, identifier:append; 130, argument_list; 130, 131; 131, identifier:jvm_tool | def register_jvm_tool(cls,
register,
key,
classpath_spec=None,
main=None,
custom_rules=None,
fingerprint=True,
classpath=None,
help=None,
removal_version=None,
removal_hint=None):
def formulate_help():
if classpath:
return ('Target address spec for overriding the classpath of the {} jvm tool which is, '
'by default: {}'.format(key, classpath))
else:
return 'Target address spec for specifying the classpath of the {} jvm tool.'.format(key)
help = help or formulate_help()
register('--{}'.format(key),
advanced=True,
type=target_option,
default='//:{}'.format(key) if classpath_spec is None else classpath_spec,
help=help,
fingerprint=fingerprint,
removal_version=removal_version,
removal_hint=removal_hint)
jvm_tool = cls.JvmTool(register.scope, key, classpath, main, custom_rules)
JvmToolMixin._jvm_tools.append(jvm_tool) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_available_urls; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:urls; 6, block; 6, 7; 6, 22; 6, 40; 6, 69; 6, 84; 6, 102; 6, 116; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:baseurl_to_urls; 10, dictionary_comprehension; 10, 11; 10, 19; 11, pair; 11, 12; 11, 18; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:_baseurl; 16, argument_list; 16, 17; 17, identifier:url; 18, identifier:url; 19, for_in_clause; 19, 20; 19, 21; 20, identifier:url; 21, identifier:urls; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:pingtimes; 25, call; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_pinger; 30, identifier:pings; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:list; 34, argument_list; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:baseurl_to_urls; 38, identifier:keys; 39, argument_list; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 47; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_log; 46, identifier:debug; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, string:'Artifact cache server ping times: {}'; 51, identifier:format; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, string:', '; 56, identifier:join; 57, argument_list; 57, 58; 58, list_comprehension; 58, 59; 58, 66; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, string:'{}: {:.6f} secs'; 62, identifier:format; 63, argument_list; 63, 64; 64, list_splat; 64, 65; 65, identifier:p; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:p; 68, identifier:pingtimes; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:sorted_pingtimes; 72, call; 72, 73; 72, 74; 73, identifier:sorted; 74, argument_list; 74, 75; 74, 76; 75, identifier:pingtimes; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:key; 78, lambda; 78, 79; 78, 81; 79, lambda_parameters; 79, 80; 80, identifier:x; 81, subscript; 81, 82; 81, 83; 82, identifier:x; 83, integer:1; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:available_urls; 87, list_comprehension; 87, 88; 87, 91; 87, 96; 88, subscript; 88, 89; 88, 90; 89, identifier:baseurl_to_urls; 90, identifier:baseurl; 91, for_in_clause; 91, 92; 91, 95; 92, pattern_list; 92, 93; 92, 94; 93, identifier:baseurl; 94, identifier:pingtime; 95, identifier:sorted_pingtimes; 96, if_clause; 96, 97; 97, comparison_operator:<; 97, 98; 97, 99; 98, identifier:pingtime; 99, attribute; 99, 100; 99, 101; 100, identifier:Pinger; 101, identifier:UNREACHABLE; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:_log; 108, identifier:debug; 109, argument_list; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, string:'Available cache servers: {0}'; 113, identifier:format; 114, argument_list; 114, 115; 115, identifier:available_urls; 116, return_statement; 116, 117; 117, identifier:available_urls | def get_available_urls(self, urls):
baseurl_to_urls = {self._baseurl(url): url for url in urls}
pingtimes = self._pinger.pings(list(baseurl_to_urls.keys()))
self._log.debug('Artifact cache server ping times: {}'
.format(', '.join(['{}: {:.6f} secs'.format(*p) for p in pingtimes])))
sorted_pingtimes = sorted(pingtimes, key=lambda x: x[1])
available_urls = [baseurl_to_urls[baseurl] for baseurl, pingtime in sorted_pingtimes
if pingtime < Pinger.UNREACHABLE]
self._log.debug('Available cache servers: {0}'.format(available_urls))
return available_urls |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:iterate; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:scopes; 6, block; 6, 7; 6, 24; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:scope_infos; 10, list_comprehension; 10, 11; 10, 16; 11, subscript; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_scope_to_info; 15, identifier:s; 16, for_in_clause; 16, 17; 16, 18; 17, identifier:s; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:_expand_tasks; 22, argument_list; 22, 23; 23, identifier:scopes; 24, if_statement; 24, 25; 24, 26; 25, identifier:scope_infos; 26, block; 26, 27; 27, for_statement; 27, 28; 27, 29; 27, 35; 28, identifier:scope_info; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_expand_subsystems; 33, argument_list; 33, 34; 34, identifier:scope_infos; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, yield; 37, 38; 38, identifier:scope_info | def iterate(self, scopes):
scope_infos = [self._scope_to_info[s] for s in self._expand_tasks(scopes)]
if scope_infos:
for scope_info in self._expand_subsystems(scope_infos):
yield scope_info |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_expand_tasks; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:scopes; 6, block; 6, 7; 6, 14; 6, 67; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:expanded_scopes; 10, call; 10, 11; 10, 12; 11, identifier:set; 12, argument_list; 12, 13; 13, identifier:scopes; 14, for_statement; 14, 15; 14, 18; 14, 25; 15, pattern_list; 15, 16; 15, 17; 16, identifier:scope; 17, identifier:info; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_scope_to_info; 23, identifier:items; 24, argument_list; 25, block; 25, 26; 26, if_statement; 26, 27; 26, 34; 27, comparison_operator:==; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:info; 30, identifier:category; 31, attribute; 31, 32; 31, 33; 32, identifier:ScopeInfo; 33, identifier:TASK; 34, block; 34, 35; 34, 42; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:outer; 38, call; 38, 39; 38, 40; 39, identifier:enclosing_scope; 40, argument_list; 40, 41; 41, identifier:scope; 42, while_statement; 42, 43; 42, 46; 43, comparison_operator:!=; 43, 44; 43, 45; 44, identifier:outer; 45, identifier:GLOBAL_SCOPE; 46, block; 46, 47; 46, 60; 47, if_statement; 47, 48; 47, 51; 48, comparison_operator:in; 48, 49; 48, 50; 49, identifier:outer; 50, identifier:expanded_scopes; 51, block; 51, 52; 51, 59; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:expanded_scopes; 56, identifier:add; 57, argument_list; 57, 58; 58, identifier:scope; 59, break_statement; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:outer; 63, call; 63, 64; 63, 65; 64, identifier:enclosing_scope; 65, argument_list; 65, 66; 66, identifier:outer; 67, return_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:sorted; 70, argument_list; 70, 71; 71, identifier:expanded_scopes | def _expand_tasks(self, scopes):
expanded_scopes = set(scopes)
for scope, info in self._scope_to_info.items():
if info.category == ScopeInfo.TASK:
outer = enclosing_scope(scope)
while outer != GLOBAL_SCOPE:
if outer in expanded_scopes:
expanded_scopes.add(scope)
break
outer = enclosing_scope(outer)
return sorted(expanded_scopes) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_all; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, return_statement; 6, 7; 7, list_comprehension; 7, 8; 7, 28; 8, dictionary; 8, 9; 8, 14; 8, 19; 9, pair; 9, 10; 9, 11; 10, string:'label'; 11, subscript; 11, 12; 11, 13; 12, identifier:x; 13, integer:0; 14, pair; 14, 15; 14, 16; 15, string:'timing'; 16, subscript; 16, 17; 16, 18; 17, identifier:x; 18, integer:1; 19, pair; 19, 20; 19, 21; 20, string:'is_tool'; 21, comparison_operator:in; 21, 22; 21, 25; 22, subscript; 22, 23; 22, 24; 23, identifier:x; 24, integer:0; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_tool_labels; 28, for_in_clause; 28, 29; 28, 30; 29, identifier:x; 30, call; 30, 31; 30, 32; 31, identifier:sorted; 32, argument_list; 32, 33; 32, 40; 32, 48; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_timings_by_path; 38, identifier:items; 39, argument_list; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:key; 42, lambda; 42, 43; 42, 45; 43, lambda_parameters; 43, 44; 44, identifier:x; 45, subscript; 45, 46; 45, 47; 46, identifier:x; 47, integer:1; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:reverse; 50, True | def get_all(self):
return [{'label': x[0], 'timing': x[1], 'is_tool': x[0] in self._tool_labels}
for x in sorted(self._timings_by_path.items(), key=lambda x: x[1], reverse=True)] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:all; 3, parameters; 4, block; 4, 5; 5, return_statement; 5, 6; 6, list_comprehension; 6, 7; 6, 8; 6, 22; 7, identifier:goal; 8, for_in_clause; 8, 9; 8, 12; 9, pattern_list; 9, 10; 9, 11; 10, identifier:_; 11, identifier:goal; 12, call; 12, 13; 12, 14; 13, identifier:sorted; 14, argument_list; 14, 15; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:Goal; 19, identifier:_goal_by_name; 20, identifier:items; 21, argument_list; 22, if_clause; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:goal; 25, identifier:active | def all():
return [goal for _, goal in sorted(Goal._goal_by_name.items()) if goal.active] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:select_best_url; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:best_url; 9, subscript; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:parsed_urls; 13, integer:0; 14, try_statement; 14, 15; 14, 19; 14, 60; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, yield; 17, 18; 18, identifier:best_url; 19, except_clause; 19, 20; 19, 21; 20, identifier:Exception; 21, block; 21, 22; 21, 30; 21, 59; 22, expression_statement; 22, 23; 23, augmented_assignment:+=; 23, 24; 23, 29; 24, subscript; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:unsuccessful_calls; 28, identifier:best_url; 29, integer:1; 30, if_statement; 30, 31; 30, 40; 31, comparison_operator:>; 31, 32; 31, 37; 32, subscript; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:unsuccessful_calls; 36, identifier:best_url; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:max_failures; 40, block; 40, 41; 40, 51; 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:parsed_urls; 47, identifier:rotate; 48, argument_list; 48, 49; 49, unary_operator:-; 49, 50; 50, integer:1; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 58; 53, subscript; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:unsuccessful_calls; 57, identifier:best_url; 58, integer:0; 59, raise_statement; 60, else_clause; 60, 61; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 69; 64, subscript; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:unsuccessful_calls; 68, identifier:best_url; 69, integer:0 | def select_best_url(self):
best_url = self.parsed_urls[0]
try:
yield best_url
except Exception:
self.unsuccessful_calls[best_url] += 1
if self.unsuccessful_calls[best_url] > self.max_failures:
self.parsed_urls.rotate(-1)
self.unsuccessful_calls[best_url] = 0
raise
else:
self.unsuccessful_calls[best_url] = 0 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_topological_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:targets; 6, block; 6, 7; 6, 14; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:target_set; 10, call; 10, 11; 10, 12; 11, identifier:set; 12, argument_list; 12, 13; 13, identifier:targets; 14, return_statement; 14, 15; 15, list_comprehension; 15, 16; 15, 17; 15, 26; 16, identifier:t; 17, for_in_clause; 17, 18; 17, 19; 18, identifier:t; 19, call; 19, 20; 19, 21; 20, identifier:reversed; 21, argument_list; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:sort_targets; 24, argument_list; 24, 25; 25, identifier:targets; 26, if_clause; 26, 27; 27, comparison_operator:in; 27, 28; 27, 29; 28, identifier:t; 29, identifier:target_set | def _topological_sort(self, targets):
target_set = set(targets)
return [t for t in reversed(sort_targets(targets)) if t in target_set] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sortmerna_detailed_barplot; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 18; 5, 53; 5, 72; 5, 85; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:keys; 9, call; 9, 10; 9, 11; 10, identifier:OrderedDict; 11, argument_list; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:metrics; 15, call; 15, 16; 15, 17; 16, identifier:set; 17, argument_list; 18, for_statement; 18, 19; 18, 20; 18, 23; 19, identifier:sample; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:sortmerna; 23, block; 23, 24; 24, for_statement; 24, 25; 24, 26; 24, 31; 25, identifier:key; 26, subscript; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:sortmerna; 30, identifier:sample; 31, block; 31, 32; 32, if_statement; 32, 33; 32, 45; 33, boolean_operator:and; 33, 34; 33, 41; 34, not_operator; 34, 35; 35, comparison_operator:in; 35, 36; 35, 37; 36, identifier:key; 37, list:["total", "rRNA", "non_rRNA"]; 37, 38; 37, 39; 37, 40; 38, string:"total"; 39, string:"rRNA"; 40, string:"non_rRNA"; 41, not_operator; 41, 42; 42, comparison_operator:in; 42, 43; 42, 44; 43, string:"_pct"; 44, identifier:key; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:metrics; 50, identifier:add; 51, argument_list; 51, 52; 52, identifier:key; 53, for_statement; 53, 54; 53, 55; 53, 56; 54, identifier:key; 55, identifier:metrics; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 62; 59, subscript; 59, 60; 59, 61; 60, identifier:keys; 61, identifier:key; 62, dictionary; 62, 63; 63, pair; 63, 64; 63, 65; 64, string:'name'; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:key; 68, identifier:replace; 69, argument_list; 69, 70; 69, 71; 70, string:"_count"; 71, string:""; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:pconfig; 75, dictionary; 75, 76; 75, 79; 75, 82; 76, pair; 76, 77; 76, 78; 77, string:'id'; 78, string:'sortmerna-detailed-plot'; 79, pair; 79, 80; 79, 81; 80, string:'title'; 81, string:'SortMeRNA: Hit Counts'; 82, pair; 82, 83; 82, 84; 83, string:'ylab'; 84, string:'Reads'; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:add_section; 90, argument_list; 90, 91; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:plot; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:bargraph; 96, identifier:plot; 97, argument_list; 97, 98; 97, 101; 97, 102; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:sortmerna; 101, identifier:keys; 102, identifier:pconfig | def sortmerna_detailed_barplot (self):
keys = OrderedDict()
metrics = set()
for sample in self.sortmerna:
for key in self.sortmerna[sample]:
if not key in ["total", "rRNA", "non_rRNA"] and not "_pct" in key:
metrics.add(key)
for key in metrics:
keys[key] = { 'name': key.replace("_count","") }
pconfig = {
'id': 'sortmerna-detailed-plot',
'title': 'SortMeRNA: Hit Counts',
'ylab': 'Reads'
}
self.add_section( plot = bargraph.plot(self.sortmerna, keys, pconfig) ) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_short_chrom; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:chrom; 6, block; 6, 7; 6, 15; 6, 33; 6, 43; 6, 68; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:default_allowed; 10, call; 10, 11; 10, 12; 11, identifier:set; 12, argument_list; 12, 13; 13, list:["X"]; 13, 14; 14, string:"X"; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:allowed_chroms; 18, call; 18, 19; 18, 20; 19, identifier:set; 20, argument_list; 20, 21; 21, call; 21, 22; 21, 30; 22, attribute; 22, 23; 22, 29; 23, call; 23, 24; 23, 25; 24, identifier:getattr; 25, argument_list; 25, 26; 25, 27; 25, 28; 26, identifier:config; 27, string:"goleft_indexcov_config"; 28, dictionary; 29, identifier:get; 30, argument_list; 30, 31; 30, 32; 31, string:"chromosomes"; 32, list:[]; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:chrom_clean; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:chrom; 39, identifier:replace; 40, argument_list; 40, 41; 40, 42; 41, string:"chr"; 42, string:""; 43, try_statement; 43, 44; 43, 52; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:chrom_clean; 48, call; 48, 49; 48, 50; 49, identifier:int; 50, argument_list; 50, 51; 51, identifier:chrom_clean; 52, except_clause; 52, 53; 52, 54; 53, identifier:ValueError; 54, block; 54, 55; 55, if_statement; 55, 56; 55, 63; 56, boolean_operator:and; 56, 57; 56, 60; 57, comparison_operator:not; 57, 58; 57, 59; 58, identifier:chrom_clean; 59, identifier:default_allowed; 60, comparison_operator:not; 60, 61; 60, 62; 61, identifier:chrom_clean; 62, identifier:allowed_chroms; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:chrom_clean; 67, None; 68, if_statement; 68, 69; 68, 70; 68, 82; 69, identifier:allowed_chroms; 70, block; 70, 71; 71, if_statement; 71, 72; 71, 79; 72, boolean_operator:or; 72, 73; 72, 76; 73, comparison_operator:in; 73, 74; 73, 75; 74, identifier:chrom; 75, identifier:allowed_chroms; 76, comparison_operator:in; 76, 77; 76, 78; 77, identifier:chrom_clean; 78, identifier:allowed_chroms; 79, block; 79, 80; 80, return_statement; 80, 81; 81, identifier:chrom_clean; 82, elif_clause; 82, 83; 82, 92; 83, boolean_operator:or; 83, 84; 83, 89; 84, call; 84, 85; 84, 86; 85, identifier:isinstance; 86, argument_list; 86, 87; 86, 88; 87, identifier:chrom_clean; 88, identifier:int; 89, comparison_operator:in; 89, 90; 89, 91; 90, identifier:chrom_clean; 91, identifier:default_allowed; 92, block; 92, 93; 93, return_statement; 93, 94; 94, identifier:chrom_clean | def _short_chrom(self, chrom):
default_allowed = set(["X"])
allowed_chroms = set(getattr(config, "goleft_indexcov_config", {}).get("chromosomes", []))
chrom_clean = chrom.replace("chr", "")
try:
chrom_clean = int(chrom_clean)
except ValueError:
if chrom_clean not in default_allowed and chrom_clean not in allowed_chroms:
chrom_clean = None
if allowed_chroms:
if chrom in allowed_chroms or chrom_clean in allowed_chroms:
return chrom_clean
elif isinstance(chrom_clean, int) or chrom_clean in default_allowed:
return chrom_clean |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:deepvalues; 3, parameters; 3, 4; 4, identifier:mapping; 5, block; 5, 6; 5, 13; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:values; 9, call; 9, 10; 9, 11; 10, identifier:vals_sorted_by_key; 11, argument_list; 11, 12; 12, identifier:mapping; 13, for_statement; 13, 14; 13, 15; 13, 16; 14, identifier:obj; 15, identifier:values; 16, block; 16, 17; 16, 21; 16, 47; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:mapping; 20, False; 21, try_statement; 21, 22; 21, 27; 21, 31; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, attribute; 24, 25; 24, 26; 25, identifier:obj; 26, identifier:items; 27, except_clause; 27, 28; 27, 29; 28, identifier:AttributeError; 29, block; 29, 30; 30, pass_statement; 31, else_clause; 31, 32; 32, block; 32, 33; 32, 37; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:mapping; 36, True; 37, for_statement; 37, 38; 37, 39; 37, 43; 38, identifier:subobj; 39, call; 39, 40; 39, 41; 40, identifier:deepvalues; 41, argument_list; 41, 42; 42, identifier:obj; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, yield; 45, 46; 46, identifier:subobj; 47, if_statement; 47, 48; 47, 50; 48, not_operator; 48, 49; 49, identifier:mapping; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, yield; 52, 53; 53, identifier:obj | def deepvalues(mapping):
values = vals_sorted_by_key(mapping)
for obj in values:
mapping = False
try:
obj.items
except AttributeError:
pass
else:
mapping = True
for subobj in deepvalues(obj):
yield subobj
if not mapping:
yield obj |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:values; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, return_statement; 6, 7; 7, list_comprehension; 7, 8; 7, 17; 8, call; 8, 9; 8, 14; 9, attribute; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:policy; 13, identifier:header_fetch_parse; 14, argument_list; 14, 15; 14, 16; 15, identifier:k; 16, identifier:v; 17, for_in_clause; 17, 18; 17, 21; 18, pattern_list; 18, 19; 18, 20; 19, identifier:k; 20, identifier:v; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_headers | def values(self):
return [self.policy.header_fetch_parse(k, v)
for k, v in self._headers] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:items; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, return_statement; 6, 7; 7, list_comprehension; 7, 8; 7, 19; 8, tuple; 8, 9; 8, 10; 9, identifier:k; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:policy; 15, identifier:header_fetch_parse; 16, argument_list; 16, 17; 16, 18; 17, identifier:k; 18, identifier:v; 19, for_in_clause; 19, 20; 19, 23; 20, pattern_list; 20, 21; 20, 22; 21, identifier:k; 22, identifier:v; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:_headers | def items(self):
return [(k, self.policy.header_fetch_parse(k, v))
for k, v in self._headers] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_all; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:name; 6, default_parameter; 6, 7; 6, 8; 7, identifier:failobj; 8, None; 9, block; 9, 10; 9, 14; 9, 22; 9, 54; 9, 60; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:values; 13, list:[]; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:name; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:name; 20, identifier:lower; 21, argument_list; 22, for_statement; 22, 23; 22, 26; 22, 29; 23, pattern_list; 23, 24; 23, 25; 24, identifier:k; 25, identifier:v; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_headers; 29, block; 29, 30; 30, if_statement; 30, 31; 30, 38; 31, comparison_operator:==; 31, 32; 31, 37; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:k; 35, identifier:lower; 36, argument_list; 37, identifier:name; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:values; 43, identifier:append; 44, argument_list; 44, 45; 45, call; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:policy; 50, identifier:header_fetch_parse; 51, argument_list; 51, 52; 51, 53; 52, identifier:k; 53, identifier:v; 54, if_statement; 54, 55; 54, 57; 55, not_operator; 55, 56; 56, identifier:values; 57, block; 57, 58; 58, return_statement; 58, 59; 59, identifier:failobj; 60, return_statement; 60, 61; 61, identifier:values | def get_all(self, name, failobj=None):
values = []
name = name.lower()
for k, v in self._headers:
if k.lower() == name:
values.append(self.policy.header_fetch_parse(k, v))
if not values:
return failobj
return values |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:setup; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:job; 5, identifier:input_file_id; 6, identifier:n; 7, identifier:down_checkpoints; 8, block; 8, 9; 8, 18; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:job; 14, identifier:fileStore; 15, identifier:logToMaster; 16, argument_list; 16, 17; 17, string:"Starting the merge sort"; 18, return_statement; 18, 19; 19, call; 19, 20; 19, 36; 20, attribute; 20, 21; 20, 35; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:job; 24, identifier:addChildJobFn; 25, argument_list; 25, 26; 25, 27; 25, 28; 25, 29; 25, 32; 26, identifier:down; 27, identifier:input_file_id; 28, identifier:n; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:down_checkpoints; 31, identifier:down_checkpoints; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:memory; 34, string:'600M'; 35, identifier:rv; 36, argument_list | def setup(job, input_file_id, n, down_checkpoints):
job.fileStore.logToMaster("Starting the merge sort")
return job.addChildJobFn(down,
input_file_id, n,
down_checkpoints=down_checkpoints,
memory='600M').rv() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:down; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:job; 5, identifier:input_file_id; 6, identifier:n; 7, identifier:down_checkpoints; 8, block; 8, 9; 8, 23; 8, 34; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:input_file; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:job; 16, identifier:fileStore; 17, identifier:readGlobalFile; 18, argument_list; 18, 19; 18, 20; 19, identifier:input_file_id; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:cache; 22, False; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:length; 26, call; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:os; 30, identifier:path; 31, identifier:getsize; 32, argument_list; 32, 33; 33, identifier:input_file; 34, if_statement; 34, 35; 34, 38; 34, 191; 35, comparison_operator:>; 35, 36; 35, 37; 36, identifier:length; 37, identifier:n; 38, block; 38, 39; 38, 57; 38, 66; 38, 76; 38, 98; 38, 108; 38, 130; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:job; 44, identifier:fileStore; 45, identifier:logToMaster; 46, argument_list; 46, 47; 46, 52; 47, binary_operator:%; 47, 48; 47, 49; 48, string:"Splitting file: %s of size: %s"; 49, tuple; 49, 50; 49, 51; 50, identifier:input_file_id; 51, identifier:length; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:level; 54, attribute; 54, 55; 54, 56; 55, identifier:logging; 56, identifier:CRITICAL; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:mid_point; 60, call; 60, 61; 60, 62; 61, identifier:get_midpoint; 62, argument_list; 62, 63; 62, 64; 62, 65; 63, identifier:input_file; 64, integer:0; 65, identifier:length; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:t1; 69, call; 69, 70; 69, 75; 70, attribute; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:job; 73, identifier:fileStore; 74, identifier:getLocalTempFile; 75, argument_list; 76, with_statement; 76, 77; 76, 87; 77, with_clause; 77, 78; 78, with_item; 78, 79; 79, as_pattern; 79, 80; 79, 85; 80, call; 80, 81; 80, 82; 81, identifier:open; 82, argument_list; 82, 83; 82, 84; 83, identifier:t1; 84, string:'w'; 85, as_pattern_target; 85, 86; 86, identifier:fH; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:copy_subrange_of_file; 91, argument_list; 91, 92; 91, 93; 91, 94; 91, 97; 92, identifier:input_file; 93, integer:0; 94, binary_operator:+; 94, 95; 94, 96; 95, identifier:mid_point; 96, integer:1; 97, identifier:fH; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:t2; 101, call; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:job; 105, identifier:fileStore; 106, identifier:getLocalTempFile; 107, argument_list; 108, with_statement; 108, 109; 108, 119; 109, with_clause; 109, 110; 110, with_item; 110, 111; 111, as_pattern; 111, 112; 111, 117; 112, call; 112, 113; 112, 114; 113, identifier:open; 114, argument_list; 114, 115; 114, 116; 115, identifier:t2; 116, string:'w'; 117, as_pattern_target; 117, 118; 118, identifier:fH; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:copy_subrange_of_file; 123, argument_list; 123, 124; 123, 125; 123, 128; 123, 129; 124, identifier:input_file; 125, binary_operator:+; 125, 126; 125, 127; 126, identifier:mid_point; 127, integer:1; 128, identifier:length; 129, identifier:fH; 130, return_statement; 130, 131; 131, call; 131, 132; 131, 190; 132, attribute; 132, 133; 132, 189; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:job; 136, identifier:addFollowOnJobFn; 137, argument_list; 137, 138; 137, 139; 137, 164; 138, identifier:up; 139, call; 139, 140; 139, 163; 140, attribute; 140, 141; 140, 162; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:job; 144, identifier:addChildJobFn; 145, argument_list; 145, 146; 145, 147; 145, 155; 145, 156; 145, 159; 146, identifier:down; 147, call; 147, 148; 147, 153; 148, attribute; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:job; 151, identifier:fileStore; 152, identifier:writeGlobalFile; 153, argument_list; 153, 154; 154, identifier:t1; 155, identifier:n; 156, keyword_argument; 156, 157; 156, 158; 157, identifier:down_checkpoints; 158, identifier:down_checkpoints; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:memory; 161, string:'600M'; 162, identifier:rv; 163, argument_list; 164, call; 164, 165; 164, 188; 165, attribute; 165, 166; 165, 187; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:job; 169, identifier:addChildJobFn; 170, argument_list; 170, 171; 170, 172; 170, 180; 170, 181; 170, 184; 171, identifier:down; 172, call; 172, 173; 172, 178; 173, attribute; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:job; 176, identifier:fileStore; 177, identifier:writeGlobalFile; 178, argument_list; 178, 179; 179, identifier:t2; 180, identifier:n; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:down_checkpoints; 183, identifier:down_checkpoints; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:memory; 186, string:'600M'; 187, identifier:rv; 188, argument_list; 189, identifier:rv; 190, argument_list; 191, else_clause; 191, 192; 192, block; 192, 193; 192, 211; 192, 221; 192, 227; 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:job; 198, identifier:fileStore; 199, identifier:logToMaster; 200, argument_list; 200, 201; 200, 206; 201, binary_operator:%; 201, 202; 201, 203; 202, string:"Sorting file: %s of size: %s"; 203, tuple; 203, 204; 203, 205; 204, identifier:input_file_id; 205, identifier:length; 206, keyword_argument; 206, 207; 206, 208; 207, identifier:level; 208, attribute; 208, 209; 208, 210; 209, identifier:logging; 210, identifier:CRITICAL; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:output_file; 214, call; 214, 215; 214, 220; 215, attribute; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:job; 218, identifier:fileStore; 219, identifier:getLocalTempFile; 220, argument_list; 221, expression_statement; 221, 222; 222, call; 222, 223; 222, 224; 223, identifier:sort; 224, argument_list; 224, 225; 224, 226; 225, identifier:input_file; 226, identifier:output_file; 227, return_statement; 227, 228; 228, call; 228, 229; 228, 234; 229, attribute; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:job; 232, identifier:fileStore; 233, identifier:writeGlobalFile; 234, argument_list; 234, 235; 235, identifier:output_file | def down(job, input_file_id, n, down_checkpoints):
input_file = job.fileStore.readGlobalFile(input_file_id, cache=False)
length = os.path.getsize(input_file)
if length > n:
job.fileStore.logToMaster("Splitting file: %s of size: %s"
% (input_file_id, length), level=logging.CRITICAL)
mid_point = get_midpoint(input_file, 0, length)
t1 = job.fileStore.getLocalTempFile()
with open(t1, 'w') as fH:
copy_subrange_of_file(input_file, 0, mid_point + 1, fH)
t2 = job.fileStore.getLocalTempFile()
with open(t2, 'w') as fH:
copy_subrange_of_file(input_file, mid_point + 1, length, fH)
return job.addFollowOnJobFn(up, job.addChildJobFn(down, job.fileStore.writeGlobalFile(t1), n,
down_checkpoints=down_checkpoints, memory='600M').rv(),
job.addChildJobFn(down, job.fileStore.writeGlobalFile(t2), n,
down_checkpoints=down_checkpoints,
memory='600M').rv()).rv()
else:
job.fileStore.logToMaster("Sorting file: %s of size: %s"
% (input_file_id, length), level=logging.CRITICAL)
output_file = job.fileStore.getLocalTempFile()
sort(input_file, output_file)
return job.fileStore.writeGlobalFile(output_file) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 4, identifier:in_file; 5, identifier:out_file; 6, block; 6, 7; 6, 15; 6, 23; 6, 29; 6, 35; 6, 43; 6, 54; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:filehandle; 10, call; 10, 11; 10, 12; 11, identifier:open; 12, argument_list; 12, 13; 12, 14; 13, identifier:in_file; 14, string:'r'; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:lines; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:filehandle; 21, identifier:readlines; 22, argument_list; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:filehandle; 27, identifier:close; 28, argument_list; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:lines; 33, identifier:sort; 34, argument_list; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:filehandle; 38, call; 38, 39; 38, 40; 39, identifier:open; 40, argument_list; 40, 41; 40, 42; 41, identifier:out_file; 42, string:'w'; 43, for_statement; 43, 44; 43, 45; 43, 46; 44, identifier:line; 45, identifier:lines; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:filehandle; 51, identifier:write; 52, argument_list; 52, 53; 53, identifier:line; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:filehandle; 58, identifier:close; 59, argument_list | def sort(in_file, out_file):
filehandle = open(in_file, 'r')
lines = filehandle.readlines()
filehandle.close()
lines.sort()
filehandle = open(out_file, 'w')
for line in lines:
filehandle.write(line)
filehandle.close() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:merge; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:filehandle_1; 5, identifier:filehandle_2; 6, identifier:output_filehandle; 7, block; 7, 8; 7, 16; 7, 55; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:line2; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:filehandle_2; 14, identifier:readline; 15, argument_list; 16, for_statement; 16, 17; 16, 18; 16, 23; 17, identifier:line1; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:filehandle_1; 21, identifier:readlines; 22, argument_list; 23, block; 23, 24; 23, 48; 24, while_statement; 24, 25; 24, 32; 25, boolean_operator:and; 25, 26; 25, 29; 26, comparison_operator:!=; 26, 27; 26, 28; 27, identifier:line2; 28, string:''; 29, comparison_operator:<=; 29, 30; 29, 31; 30, identifier:line2; 31, identifier:line1; 32, block; 32, 33; 32, 40; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:output_filehandle; 37, identifier:write; 38, argument_list; 38, 39; 39, identifier:line2; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:line2; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:filehandle_2; 46, identifier:readline; 47, argument_list; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:output_filehandle; 52, identifier:write; 53, argument_list; 53, 54; 54, identifier:line1; 55, while_statement; 55, 56; 55, 59; 56, comparison_operator:!=; 56, 57; 56, 58; 57, identifier:line2; 58, string:''; 59, block; 59, 60; 59, 67; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:output_filehandle; 64, identifier:write; 65, argument_list; 65, 66; 66, identifier:line2; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:line2; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:filehandle_2; 73, identifier:readline; 74, argument_list | def merge(filehandle_1, filehandle_2, output_filehandle):
line2 = filehandle_2.readline()
for line1 in filehandle_1.readlines():
while line2 != '' and line2 <= line1:
output_filehandle.write(line2)
line2 = filehandle_2.readline()
output_filehandle.write(line1)
while line2 != '':
output_filehandle.write(line2)
line2 = filehandle_2.readline() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:decorateSubHeader; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:title; 5, identifier:columnWidths; 6, identifier:options; 7, block; 7, 8; 7, 16; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:title; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:title; 14, identifier:lower; 15, argument_list; 16, if_statement; 16, 17; 16, 22; 16, 71; 17, comparison_operator:!=; 17, 18; 17, 19; 18, identifier:title; 19, attribute; 19, 20; 19, 21; 20, identifier:options; 21, identifier:sortCategory; 22, block; 22, 23; 22, 69; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:s; 26, binary_operator:%; 26, 27; 26, 28; 27, string:"| %*s%*s%*s%*s%*s "; 28, tuple; 28, 29; 28, 36; 28, 37; 28, 44; 28, 45; 28, 52; 28, 53; 28, 60; 28, 61; 28, 68; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:columnWidths; 32, identifier:getWidth; 33, argument_list; 33, 34; 33, 35; 34, identifier:title; 35, string:"min"; 36, string:"min"; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:columnWidths; 40, identifier:getWidth; 41, argument_list; 41, 42; 41, 43; 42, identifier:title; 43, string:"med"; 44, string:"med"; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:columnWidths; 48, identifier:getWidth; 49, argument_list; 49, 50; 49, 51; 50, identifier:title; 51, string:"ave"; 52, string:"ave"; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:columnWidths; 56, identifier:getWidth; 57, argument_list; 57, 58; 57, 59; 58, identifier:title; 59, string:"max"; 60, string:"max"; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:columnWidths; 64, identifier:getWidth; 65, argument_list; 65, 66; 65, 67; 66, identifier:title; 67, string:"total"; 68, string:"total"; 69, return_statement; 69, 70; 70, identifier:s; 71, else_clause; 71, 72; 72, block; 72, 73; 72, 77; 72, 155; 72, 159; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:s; 76, string:"| "; 77, for_statement; 77, 78; 77, 81; 77, 127; 78, pattern_list; 78, 79; 78, 80; 79, identifier:field; 80, identifier:width; 81, list:[("min", columnWidths.getWidth(title, "min")),
("med", columnWidths.getWidth(title, "med")),
("ave", columnWidths.getWidth(title, "ave")),
("max", columnWidths.getWidth(title, "max")),
("total", columnWidths.getWidth(title, "total"))]; 81, 82; 81, 91; 81, 100; 81, 109; 81, 118; 82, tuple; 82, 83; 82, 84; 83, string:"min"; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:columnWidths; 87, identifier:getWidth; 88, argument_list; 88, 89; 88, 90; 89, identifier:title; 90, string:"min"; 91, tuple; 91, 92; 91, 93; 92, string:"med"; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:columnWidths; 96, identifier:getWidth; 97, argument_list; 97, 98; 97, 99; 98, identifier:title; 99, string:"med"; 100, tuple; 100, 101; 100, 102; 101, string:"ave"; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:columnWidths; 105, identifier:getWidth; 106, argument_list; 106, 107; 106, 108; 107, identifier:title; 108, string:"ave"; 109, tuple; 109, 110; 109, 111; 110, string:"max"; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:columnWidths; 114, identifier:getWidth; 115, argument_list; 115, 116; 115, 117; 116, identifier:title; 117, string:"max"; 118, tuple; 118, 119; 118, 120; 119, string:"total"; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:columnWidths; 123, identifier:getWidth; 124, argument_list; 124, 125; 124, 126; 125, identifier:title; 126, string:"total"; 127, block; 127, 128; 128, if_statement; 128, 129; 128, 134; 128, 145; 129, comparison_operator:==; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:options; 132, identifier:sortField; 133, identifier:field; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, augmented_assignment:+=; 136, 137; 136, 138; 137, identifier:s; 138, binary_operator:%; 138, 139; 138, 140; 139, string:"%*s*"; 140, tuple; 140, 141; 140, 144; 141, binary_operator:-; 141, 142; 141, 143; 142, identifier:width; 143, integer:1; 144, identifier:field; 145, else_clause; 145, 146; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, augmented_assignment:+=; 148, 149; 148, 150; 149, identifier:s; 150, binary_operator:%; 150, 151; 150, 152; 151, string:"%*s"; 152, tuple; 152, 153; 152, 154; 153, identifier:width; 154, identifier:field; 155, expression_statement; 155, 156; 156, augmented_assignment:+=; 156, 157; 156, 158; 157, identifier:s; 158, string:" "; 159, return_statement; 159, 160; 160, identifier:s | def decorateSubHeader(title, columnWidths, options):
title = title.lower()
if title != options.sortCategory:
s = "| %*s%*s%*s%*s%*s " % (
columnWidths.getWidth(title, "min"), "min",
columnWidths.getWidth(title, "med"), "med",
columnWidths.getWidth(title, "ave"), "ave",
columnWidths.getWidth(title, "max"), "max",
columnWidths.getWidth(title, "total"), "total")
return s
else:
s = "| "
for field, width in [("min", columnWidths.getWidth(title, "min")),
("med", columnWidths.getWidth(title, "med")),
("ave", columnWidths.getWidth(title, "ave")),
("max", columnWidths.getWidth(title, "max")),
("total", columnWidths.getWidth(title, "total"))]:
if options.sortField == field:
s += "%*s*" % (width - 1, field)
else:
s += "%*s" % (width, field)
s += " "
return s |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sortJobs; 3, parameters; 3, 4; 3, 5; 4, identifier:jobTypes; 5, identifier:options; 6, block; 6, 7; 6, 26; 6, 34; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:longforms; 10, dictionary; 10, 11; 10, 14; 10, 17; 10, 20; 10, 23; 11, pair; 11, 12; 11, 13; 12, string:"med"; 13, string:"median"; 14, pair; 14, 15; 14, 16; 15, string:"ave"; 16, string:"average"; 17, pair; 17, 18; 17, 19; 18, string:"min"; 19, string:"min"; 20, pair; 20, 21; 20, 22; 21, string:"total"; 22, string:"total"; 23, pair; 23, 24; 23, 25; 24, string:"max"; 25, string:"max"; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:sortField; 29, subscript; 29, 30; 29, 31; 30, identifier:longforms; 31, attribute; 31, 32; 31, 33; 32, identifier:options; 33, identifier:sortField; 34, if_statement; 34, 35; 34, 59; 34, 86; 34, 111; 35, parenthesized_expression; 35, 36; 36, boolean_operator:or; 36, 37; 36, 54; 37, boolean_operator:or; 37, 38; 37, 49; 38, boolean_operator:or; 38, 39; 38, 44; 39, comparison_operator:==; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:options; 42, identifier:sortCategory; 43, string:"time"; 44, comparison_operator:==; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:options; 47, identifier:sortCategory; 48, string:"clock"; 49, comparison_operator:==; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:options; 52, identifier:sortCategory; 53, string:"wait"; 54, comparison_operator:==; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:options; 57, identifier:sortCategory; 58, string:"memory"; 59, block; 59, 60; 60, return_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:sorted; 63, argument_list; 63, 64; 63, 65; 63, 81; 64, identifier:jobTypes; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:key; 67, lambda; 67, 68; 67, 70; 68, lambda_parameters; 68, 69; 69, identifier:tag; 70, call; 70, 71; 70, 72; 71, identifier:getattr; 72, argument_list; 72, 73; 72, 74; 73, identifier:tag; 74, binary_operator:%; 74, 75; 74, 76; 75, string:"%s_%s"; 76, tuple; 76, 77; 76, 78; 77, identifier:sortField; 78, attribute; 78, 79; 78, 80; 79, identifier:options; 80, identifier:sortCategory; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:reverse; 83, attribute; 83, 84; 83, 85; 84, identifier:options; 85, identifier:sortReverse; 86, elif_clause; 86, 87; 86, 92; 87, comparison_operator:==; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:options; 90, identifier:sortCategory; 91, string:"alpha"; 92, block; 92, 93; 93, return_statement; 93, 94; 94, call; 94, 95; 94, 96; 95, identifier:sorted; 96, argument_list; 96, 97; 96, 98; 96, 106; 97, identifier:jobTypes; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:key; 100, lambda; 100, 101; 100, 103; 101, lambda_parameters; 101, 102; 102, identifier:tag; 103, attribute; 103, 104; 103, 105; 104, identifier:tag; 105, identifier:name; 106, keyword_argument; 106, 107; 106, 108; 107, identifier:reverse; 108, attribute; 108, 109; 108, 110; 109, identifier:options; 110, identifier:sortReverse; 111, elif_clause; 111, 112; 111, 117; 112, comparison_operator:==; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:options; 115, identifier:sortCategory; 116, string:"count"; 117, block; 117, 118; 118, return_statement; 118, 119; 119, call; 119, 120; 119, 121; 120, identifier:sorted; 121, argument_list; 121, 122; 121, 123; 121, 131; 122, identifier:jobTypes; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:key; 125, lambda; 125, 126; 125, 128; 126, lambda_parameters; 126, 127; 127, identifier:tag; 128, attribute; 128, 129; 128, 130; 129, identifier:tag; 130, identifier:total_number; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:reverse; 133, attribute; 133, 134; 133, 135; 134, identifier:options; 135, identifier:sortReverse | def sortJobs(jobTypes, options):
longforms = {"med": "median",
"ave": "average",
"min": "min",
"total": "total",
"max": "max",}
sortField = longforms[options.sortField]
if (options.sortCategory == "time" or
options.sortCategory == "clock" or
options.sortCategory == "wait" or
options.sortCategory == "memory"
):
return sorted(
jobTypes,
key=lambda tag: getattr(tag, "%s_%s"
% (sortField, options.sortCategory)),
reverse=options.sortReverse)
elif options.sortCategory == "alpha":
return sorted(
jobTypes, key=lambda tag: tag.name,
reverse=options.sortReverse)
elif options.sortCategory == "count":
return sorted(jobTypes, key=lambda tag: tag.total_number,
reverse=options.sortReverse) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_sort_tau_by_y; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:y; 6, block; 6, 7; 6, 17; 6, 25; 6, 38; 6, 53; 6, 61; 6, 72; 6, 84; 6, 104; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:tau_y; 10, subscript; 10, 11; 10, 14; 10, 16; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:tau_matrix; 14, slice; 14, 15; 15, colon; 16, identifier:y; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 22; 19, subscript; 19, 20; 19, 21; 20, identifier:tau_y; 21, identifier:y; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:NaN; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:temp; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:np; 31, identifier:empty; 32, argument_list; 32, 33; 33, list:[self.n_nodes, 3]; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:n_nodes; 37, integer:3; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 45; 40, subscript; 40, 41; 40, 42; 40, 44; 41, identifier:temp; 42, slice; 42, 43; 43, colon; 44, integer:0; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:np; 48, identifier:arange; 49, argument_list; 49, 50; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:n_nodes; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 60; 55, subscript; 55, 56; 55, 57; 55, 59; 56, identifier:temp; 57, slice; 57, 58; 58, colon; 59, integer:1; 60, identifier:tau_y; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 68; 63, subscript; 63, 64; 63, 65; 63, 67; 64, identifier:temp; 65, slice; 65, 66; 66, colon; 67, integer:2; 68, call; 68, 69; 68, 70; 69, identifier:abs; 70, argument_list; 70, 71; 71, identifier:tau_y; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 82; 74, subscript; 74, 75; 74, 76; 75, identifier:temp; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:np; 79, identifier:isnan; 80, argument_list; 80, 81; 81, identifier:temp; 82, unary_operator:-; 82, 83; 83, integer:10; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:tau_sorted; 87, subscript; 87, 88; 87, 89; 88, identifier:temp; 89, subscript; 89, 90; 89, 99; 90, call; 90, 91; 90, 98; 91, attribute; 91, 92; 91, 97; 92, subscript; 92, 93; 92, 94; 92, 96; 93, identifier:temp; 94, slice; 94, 95; 95, colon; 96, integer:2; 97, identifier:argsort; 98, argument_list; 99, slice; 99, 100; 99, 101; 99, 102; 100, colon; 101, colon; 102, unary_operator:-; 102, 103; 103, integer:1; 104, return_statement; 104, 105; 105, identifier:tau_sorted | def _sort_tau_by_y(self, y):
tau_y = self.tau_matrix[:, y]
tau_y[y] = np.NaN
temp = np.empty([self.n_nodes, 3])
temp[:, 0] = np.arange(self.n_nodes)
temp[:, 1] = tau_y
temp[:, 2] = abs(tau_y)
temp[np.isnan(temp)] = -10
tau_sorted = temp[temp[:, 2].argsort()[::-1]]
return tau_sorted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_edge; 3, parameters; 3, 4; 4, identifier:edges; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:sorted; 9, argument_list; 9, 10; 9, 11; 10, identifier:edges; 11, keyword_argument; 11, 12; 11, 13; 12, identifier:key; 13, lambda; 13, 14; 13, 16; 14, lambda_parameters; 14, 15; 15, identifier:x; 16, tuple; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:x; 19, identifier:L; 20, attribute; 20, 21; 20, 22; 21, identifier:x; 22, identifier:R | def sort_edge(edges):
return sorted(edges, key=lambda x: (x.L, x.R)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 25; 2, function_name:stanc; 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:file; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:charset; 9, string:'utf-8'; 10, default_parameter; 10, 11; 10, 12; 11, identifier:model_code; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:model_name; 15, string:"anon_model"; 16, default_parameter; 16, 17; 16, 18; 17, identifier:include_paths; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:verbose; 21, False; 22, default_parameter; 22, 23; 22, 24; 23, identifier:obfuscate_model_name; 24, True; 25, block; 25, 26; 25, 38; 25, 52; 25, 111; 25, 120; 25, 149; 25, 165; 25, 178; 25, 182; 25, 203; 25, 212; 25, 245; 25, 260; 25, 321; 25, 325; 25, 335; 25, 345; 25, 355; 26, if_statement; 26, 27; 26, 30; 27, boolean_operator:and; 27, 28; 27, 29; 28, identifier:file; 29, identifier:model_code; 30, block; 30, 31; 31, raise_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:ValueError; 34, argument_list; 34, 35; 35, concatenated_string; 35, 36; 35, 37; 36, string:"Specify stan model with `file` or `model_code`, "; 37, string:"not both."; 38, if_statement; 38, 39; 38, 46; 39, boolean_operator:and; 39, 40; 39, 43; 40, comparison_operator:is; 40, 41; 40, 42; 41, identifier:file; 42, None; 43, comparison_operator:is; 43, 44; 43, 45; 44, identifier:model_code; 45, None; 46, block; 46, 47; 47, raise_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:ValueError; 50, argument_list; 50, 51; 51, string:"Model file missing and empty model_code."; 52, if_statement; 52, 53; 52, 56; 53, comparison_operator:is; 53, 54; 53, 55; 54, identifier:file; 55, None; 56, block; 56, 57; 57, if_statement; 57, 58; 57, 63; 57, 101; 58, call; 58, 59; 58, 60; 59, identifier:isinstance; 60, argument_list; 60, 61; 60, 62; 61, identifier:file; 62, identifier:string_types; 63, block; 63, 64; 64, try_statement; 64, 65; 64, 91; 65, block; 65, 66; 66, with_statement; 66, 67; 66, 82; 67, with_clause; 67, 68; 68, with_item; 68, 69; 69, as_pattern; 69, 70; 69, 80; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:io; 73, identifier:open; 74, argument_list; 74, 75; 74, 76; 74, 77; 75, identifier:file; 76, string:'rt'; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:encoding; 79, identifier:charset; 80, as_pattern_target; 80, 81; 81, identifier:f; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:model_code; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:f; 89, identifier:read; 90, argument_list; 91, except_clause; 91, 92; 92, block; 92, 93; 92, 100; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:logger; 97, identifier:critical; 98, argument_list; 98, 99; 99, string:"Unable to read file specified by `file`."; 100, raise_statement; 101, else_clause; 101, 102; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:model_code; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:file; 109, identifier:read; 110, argument_list; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:model_code_bytes; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:model_code; 117, identifier:encode; 118, argument_list; 118, 119; 119, string:'utf-8'; 120, if_statement; 120, 121; 120, 124; 120, 137; 121, comparison_operator:is; 121, 122; 121, 123; 122, identifier:include_paths; 123, None; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:include_paths; 128, list:[os.path.abspath('.')]; 128, 129; 129, call; 129, 130; 129, 135; 130, attribute; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:os; 133, identifier:path; 134, identifier:abspath; 135, argument_list; 135, 136; 136, string:'.'; 137, elif_clause; 137, 138; 137, 143; 138, call; 138, 139; 138, 140; 139, identifier:isinstance; 140, argument_list; 140, 141; 140, 142; 141, identifier:include_paths; 142, identifier:string_types; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:include_paths; 147, list:[include_paths]; 147, 148; 148, identifier:include_paths; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:include_paths; 152, list_comprehension; 152, 153; 152, 162; 153, call; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:os; 157, identifier:path; 158, identifier:join; 159, argument_list; 159, 160; 159, 161; 160, identifier:path; 161, string:""; 162, for_in_clause; 162, 163; 162, 164; 163, identifier:path; 164, identifier:include_paths; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:include_paths_bytes; 168, list_comprehension; 168, 169; 168, 175; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:path; 172, identifier:encode; 173, argument_list; 173, 174; 174, string:'utf-8'; 175, for_in_clause; 175, 176; 175, 177; 176, identifier:path; 177, identifier:include_paths; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:allow_undefined; 181, False; 182, if_statement; 182, 183; 182, 184; 183, identifier:obfuscate_model_name; 184, block; 184, 185; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:model_name; 188, parenthesized_expression; 188, 189; 189, binary_operator:+; 189, 190; 189, 193; 190, binary_operator:+; 190, 191; 190, 192; 191, identifier:model_name; 192, string:'_'; 193, call; 193, 194; 193, 202; 194, attribute; 194, 195; 194, 201; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:hashlib; 198, identifier:md5; 199, argument_list; 199, 200; 200, identifier:model_code_bytes; 201, identifier:hexdigest; 202, argument_list; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:model_name_bytes; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:model_name; 209, identifier:encode; 210, argument_list; 210, 211; 211, string:'ascii'; 212, if_statement; 212, 213; 212, 219; 212, 224; 213, not_operator; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:isinstance; 216, argument_list; 216, 217; 216, 218; 217, identifier:file; 218, identifier:string_types; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:filename_bytes; 223, string:b'unknown file name'; 224, else_clause; 224, 225; 225, block; 225, 226; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:filename_bytes; 229, call; 229, 230; 229, 243; 230, attribute; 230, 231; 230, 242; 231, subscript; 231, 232; 231, 240; 232, call; 232, 233; 232, 238; 233, attribute; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:os; 236, identifier:path; 237, identifier:split; 238, argument_list; 238, 239; 239, identifier:file; 240, unary_operator:-; 240, 241; 241, integer:1; 242, identifier:encode; 243, argument_list; 243, 244; 244, string:'utf-8'; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:result; 248, call; 248, 249; 248, 254; 249, attribute; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:pystan; 252, identifier:_api; 253, identifier:stanc; 254, argument_list; 254, 255; 254, 256; 254, 257; 254, 258; 254, 259; 255, identifier:model_code_bytes; 256, identifier:model_name_bytes; 257, identifier:allow_undefined; 258, identifier:filename_bytes; 259, identifier:include_paths_bytes; 260, if_statement; 260, 261; 260, 267; 260, 302; 261, comparison_operator:==; 261, 262; 261, 265; 262, subscript; 262, 263; 262, 264; 263, identifier:result; 264, string:'status'; 265, unary_operator:-; 265, 266; 266, integer:1; 267, block; 267, 268; 267, 274; 267, 287; 267, 297; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:msg; 271, subscript; 271, 272; 271, 273; 272, identifier:result; 273, string:'msg'; 274, if_statement; 274, 275; 274, 276; 275, identifier:PY2; 276, block; 276, 277; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:msg; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:msg; 283, identifier:encode; 284, argument_list; 284, 285; 284, 286; 285, string:'ascii'; 286, string:'replace'; 287, expression_statement; 287, 288; 288, assignment; 288, 289; 288, 290; 289, identifier:error_msg; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, string:"Failed to parse Stan model '{}'. Error message:\n{}"; 293, identifier:format; 294, argument_list; 294, 295; 294, 296; 295, identifier:model_name; 296, identifier:msg; 297, raise_statement; 297, 298; 298, call; 298, 299; 298, 300; 299, identifier:ValueError; 300, argument_list; 300, 301; 301, identifier:error_msg; 302, elif_clause; 302, 303; 302, 308; 303, comparison_operator:==; 303, 304; 303, 307; 304, subscript; 304, 305; 304, 306; 305, identifier:result; 306, string:'status'; 307, integer:0; 308, block; 308, 309; 309, expression_statement; 309, 310; 310, call; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:logger; 313, identifier:debug; 314, argument_list; 314, 315; 315, call; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, string:"Successfully parsed Stan model '{}'."; 318, identifier:format; 319, argument_list; 319, 320; 320, identifier:model_name; 321, delete_statement; 321, 322; 322, subscript; 322, 323; 322, 324; 323, identifier:result; 324, string:'msg'; 325, expression_statement; 325, 326; 326, call; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, identifier:result; 329, identifier:update; 330, argument_list; 330, 331; 331, dictionary; 331, 332; 332, pair; 332, 333; 332, 334; 333, string:'model_name'; 334, identifier:model_name; 335, expression_statement; 335, 336; 336, call; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:result; 339, identifier:update; 340, argument_list; 340, 341; 341, dictionary; 341, 342; 342, pair; 342, 343; 342, 344; 343, string:'model_code'; 344, identifier:model_code; 345, expression_statement; 345, 346; 346, call; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, identifier:result; 349, identifier:update; 350, argument_list; 350, 351; 351, dictionary; 351, 352; 352, pair; 352, 353; 352, 354; 353, string:'include_paths'; 354, identifier:include_paths; 355, return_statement; 355, 356; 356, identifier:result | def stanc(file=None, charset='utf-8', model_code=None, model_name="anon_model",
include_paths=None, verbose=False, obfuscate_model_name=True):
if file and model_code:
raise ValueError("Specify stan model with `file` or `model_code`, "
"not both.")
if file is None and model_code is None:
raise ValueError("Model file missing and empty model_code.")
if file is not None:
if isinstance(file, string_types):
try:
with io.open(file, 'rt', encoding=charset) as f:
model_code = f.read()
except:
logger.critical("Unable to read file specified by `file`.")
raise
else:
model_code = file.read()
model_code_bytes = model_code.encode('utf-8')
if include_paths is None:
include_paths = [os.path.abspath('.')]
elif isinstance(include_paths, string_types):
include_paths = [include_paths]
include_paths = [os.path.join(path, "") for path in include_paths]
include_paths_bytes = [path.encode('utf-8') for path in include_paths]
allow_undefined = False
if obfuscate_model_name:
model_name = (
model_name + '_' +
hashlib.md5(model_code_bytes).hexdigest())
model_name_bytes = model_name.encode('ascii')
if not isinstance(file, string_types):
filename_bytes = b'unknown file name'
else:
filename_bytes = os.path.split(file)[-1].encode('utf-8')
result = pystan._api.stanc(model_code_bytes, model_name_bytes,
allow_undefined, filename_bytes,
include_paths_bytes,
)
if result['status'] == -1:
msg = result['msg']
if PY2:
msg = msg.encode('ascii', 'replace')
error_msg = "Failed to parse Stan model '{}'. Error message:\n{}".format(model_name, msg)
raise ValueError(error_msg)
elif result['status'] == 0:
logger.debug("Successfully parsed Stan model '{}'.".format(model_name))
del result['msg']
result.update({'model_name': model_name})
result.update({'model_code': model_code})
result.update({'include_paths' : include_paths})
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:suggestion_list; 3, parameters; 3, 4; 3, 8; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:input_; 6, type; 6, 7; 7, identifier:str; 8, typed_parameter; 8, 9; 8, 10; 9, identifier:options; 10, type; 10, 11; 11, generic_type; 11, 12; 11, 13; 12, identifier:Collection; 13, type_parameter; 13, 14; 14, type; 14, 15; 15, identifier:str; 16, block; 16, 17; 16, 21; 16, 30; 16, 67; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:options_by_distance; 20, dictionary; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:input_threshold; 24, binary_operator://; 24, 25; 24, 29; 25, call; 25, 26; 25, 27; 26, identifier:len; 27, argument_list; 27, 28; 28, identifier:input_; 29, integer:2; 30, for_statement; 30, 31; 30, 32; 30, 33; 31, identifier:option; 32, identifier:options; 33, block; 33, 34; 33, 42; 33, 56; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:distance; 37, call; 37, 38; 37, 39; 38, identifier:lexical_distance; 39, argument_list; 39, 40; 39, 41; 40, identifier:input_; 41, identifier:option; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:threshold; 45, call; 45, 46; 45, 47; 46, identifier:max; 47, argument_list; 47, 48; 47, 49; 47, 55; 48, identifier:input_threshold; 49, binary_operator://; 49, 50; 49, 54; 50, call; 50, 51; 50, 52; 51, identifier:len; 52, argument_list; 52, 53; 53, identifier:option; 54, integer:2; 55, integer:1; 56, if_statement; 56, 57; 56, 60; 57, comparison_operator:<=; 57, 58; 57, 59; 58, identifier:distance; 59, identifier:threshold; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:options_by_distance; 65, identifier:option; 66, identifier:distance; 67, return_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:sorted; 70, argument_list; 70, 71; 70, 72; 71, identifier:options_by_distance; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:key; 74, attribute; 74, 75; 74, 76; 75, identifier:options_by_distance; 76, identifier:get | def suggestion_list(input_: str, options: Collection[str]):
options_by_distance = {}
input_threshold = len(input_) // 2
for option in options:
distance = lexical_distance(input_, option)
threshold = max(input_threshold, len(option) // 2, 1)
if distance <= threshold:
options_by_distance[option] = distance
return sorted(options_by_distance, key=options_by_distance.get) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 1, 14; 2, function_name:lexical_distance; 3, parameters; 3, 4; 3, 8; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:a_str; 6, type; 6, 7; 7, identifier:str; 8, typed_parameter; 8, 9; 8, 10; 9, identifier:b_str; 10, type; 10, 11; 11, identifier:str; 12, type; 12, 13; 13, identifier:int; 14, block; 14, 15; 14, 22; 14, 38; 14, 52; 14, 59; 14, 74; 14, 97; 14, 232; 15, if_statement; 15, 16; 15, 19; 16, comparison_operator:==; 16, 17; 16, 18; 17, identifier:a_str; 18, identifier:b_str; 19, block; 19, 20; 20, return_statement; 20, 21; 21, integer:0; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 27; 24, pattern_list; 24, 25; 24, 26; 25, identifier:a; 26, identifier:b; 27, expression_list; 27, 28; 27, 33; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:a_str; 31, identifier:lower; 32, argument_list; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:b_str; 36, identifier:lower; 37, argument_list; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 43; 40, pattern_list; 40, 41; 40, 42; 41, identifier:a_len; 42, identifier:b_len; 43, expression_list; 43, 44; 43, 48; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:a; 48, call; 48, 49; 48, 50; 49, identifier:len; 50, argument_list; 50, 51; 51, identifier:b; 52, if_statement; 52, 53; 52, 56; 53, comparison_operator:==; 53, 54; 53, 55; 54, identifier:a; 55, identifier:b; 56, block; 56, 57; 57, return_statement; 57, 58; 58, integer:1; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:d; 62, list:[[j for j in range(0, b_len + 1)]]; 62, 63; 63, list_comprehension; 63, 64; 63, 65; 64, identifier:j; 65, for_in_clause; 65, 66; 65, 67; 66, identifier:j; 67, call; 67, 68; 67, 69; 68, identifier:range; 69, argument_list; 69, 70; 69, 71; 70, integer:0; 71, binary_operator:+; 71, 72; 71, 73; 72, identifier:b_len; 73, integer:1; 74, for_statement; 74, 75; 74, 76; 74, 83; 75, identifier:i; 76, call; 76, 77; 76, 78; 77, identifier:range; 78, argument_list; 78, 79; 78, 80; 79, integer:1; 80, binary_operator:+; 80, 81; 80, 82; 81, identifier:a_len; 82, integer:1; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:d; 88, identifier:append; 89, argument_list; 89, 90; 90, binary_operator:+; 90, 91; 90, 93; 91, list:[i]; 91, 92; 92, identifier:i; 93, binary_operator:*; 93, 94; 93, 96; 94, list:[0]; 94, 95; 95, integer:0; 96, identifier:b_len; 97, for_statement; 97, 98; 97, 99; 97, 106; 98, identifier:i; 99, call; 99, 100; 99, 101; 100, identifier:range; 101, argument_list; 101, 102; 101, 103; 102, integer:1; 103, binary_operator:+; 103, 104; 103, 105; 104, identifier:a_len; 105, integer:1; 106, block; 106, 107; 107, for_statement; 107, 108; 107, 109; 107, 116; 108, identifier:j; 109, call; 109, 110; 109, 111; 110, identifier:range; 111, argument_list; 111, 112; 111, 113; 112, integer:1; 113, binary_operator:+; 113, 114; 113, 115; 114, identifier:b_len; 115, integer:1; 116, block; 116, 117; 116, 134; 116, 173; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:cost; 120, conditional_expression:if; 120, 121; 120, 122; 120, 133; 121, integer:0; 122, comparison_operator:==; 122, 123; 122, 128; 123, subscript; 123, 124; 123, 125; 124, identifier:a; 125, binary_operator:-; 125, 126; 125, 127; 126, identifier:i; 127, integer:1; 128, subscript; 128, 129; 128, 130; 129, identifier:b; 130, binary_operator:-; 130, 131; 130, 132; 131, identifier:j; 132, integer:1; 133, integer:1; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 141; 136, subscript; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:d; 139, identifier:i; 140, identifier:j; 141, call; 141, 142; 141, 143; 142, identifier:min; 143, argument_list; 143, 144; 143, 153; 143, 162; 144, binary_operator:+; 144, 145; 144, 152; 145, subscript; 145, 146; 145, 151; 146, subscript; 146, 147; 146, 148; 147, identifier:d; 148, binary_operator:-; 148, 149; 148, 150; 149, identifier:i; 150, integer:1; 151, identifier:j; 152, integer:1; 153, binary_operator:+; 153, 154; 153, 161; 154, subscript; 154, 155; 154, 158; 155, subscript; 155, 156; 155, 157; 156, identifier:d; 157, identifier:i; 158, binary_operator:-; 158, 159; 158, 160; 159, identifier:j; 160, integer:1; 161, integer:1; 162, binary_operator:+; 162, 163; 162, 172; 163, subscript; 163, 164; 163, 169; 164, subscript; 164, 165; 164, 166; 165, identifier:d; 166, binary_operator:-; 166, 167; 166, 168; 167, identifier:i; 168, integer:1; 169, binary_operator:-; 169, 170; 169, 171; 170, identifier:j; 171, integer:1; 172, identifier:cost; 173, if_statement; 173, 174; 173, 205; 174, boolean_operator:and; 174, 175; 174, 194; 175, boolean_operator:and; 175, 176; 175, 183; 176, boolean_operator:and; 176, 177; 176, 180; 177, comparison_operator:>; 177, 178; 177, 179; 178, identifier:i; 179, integer:1; 180, comparison_operator:>; 180, 181; 180, 182; 181, identifier:j; 182, integer:1; 183, comparison_operator:==; 183, 184; 183, 189; 184, subscript; 184, 185; 184, 186; 185, identifier:a; 186, binary_operator:-; 186, 187; 186, 188; 187, identifier:i; 188, integer:1; 189, subscript; 189, 190; 189, 191; 190, identifier:b; 191, binary_operator:-; 191, 192; 191, 193; 192, identifier:j; 193, integer:2; 194, comparison_operator:==; 194, 195; 194, 200; 195, subscript; 195, 196; 195, 197; 196, identifier:a; 197, binary_operator:-; 197, 198; 197, 199; 198, identifier:i; 199, integer:2; 200, subscript; 200, 201; 200, 202; 201, identifier:b; 202, binary_operator:-; 202, 203; 202, 204; 203, identifier:j; 204, integer:1; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 213; 208, subscript; 208, 209; 208, 212; 209, subscript; 209, 210; 209, 211; 210, identifier:d; 211, identifier:i; 212, identifier:j; 213, call; 213, 214; 213, 215; 214, identifier:min; 215, argument_list; 215, 216; 215, 221; 216, subscript; 216, 217; 216, 220; 217, subscript; 217, 218; 217, 219; 218, identifier:d; 219, identifier:i; 220, identifier:j; 221, binary_operator:+; 221, 222; 221, 231; 222, subscript; 222, 223; 222, 228; 223, subscript; 223, 224; 223, 225; 224, identifier:d; 225, binary_operator:-; 225, 226; 225, 227; 226, identifier:i; 227, integer:2; 228, binary_operator:-; 228, 229; 228, 230; 229, identifier:j; 230, integer:2; 231, identifier:cost; 232, return_statement; 232, 233; 233, subscript; 233, 234; 233, 237; 234, subscript; 234, 235; 234, 236; 235, identifier:d; 236, identifier:a_len; 237, identifier:b_len | def lexical_distance(a_str: str, b_str: str) -> int:
if a_str == b_str:
return 0
a, b = a_str.lower(), b_str.lower()
a_len, b_len = len(a), len(b)
if a == b:
return 1
d = [[j for j in range(0, b_len + 1)]]
for i in range(1, a_len + 1):
d.append([i] + [0] * b_len)
for i in range(1, a_len + 1):
for j in range(1, b_len + 1):
cost = 0 if a[i - 1] == b[j - 1] else 1
d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost)
if i > 1 and j > 1 and a[i - 1] == b[j - 2] and a[i - 2] == b[j - 1]:
d[i][j] = min(d[i][j], d[i - 2][j - 2] + cost)
return d[a_len][b_len] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 1, 22; 2, function_name:get_suggested_type_names; 3, parameters; 3, 4; 3, 8; 3, 12; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:schema; 6, type; 6, 7; 7, identifier:GraphQLSchema; 8, typed_parameter; 8, 9; 8, 10; 9, identifier:type_; 10, type; 10, 11; 11, identifier:GraphQLOutputType; 12, typed_parameter; 12, 13; 12, 14; 13, identifier:field_name; 14, type; 14, 15; 15, identifier:str; 16, type; 16, 17; 17, generic_type; 17, 18; 17, 19; 18, identifier:List; 19, type_parameter; 19, 20; 20, type; 20, 21; 21, identifier:str; 22, block; 22, 23; 22, 124; 23, if_statement; 23, 24; 23, 28; 24, call; 24, 25; 24, 26; 25, identifier:is_abstract_type; 26, argument_list; 26, 27; 27, identifier:type_; 28, block; 28, 29; 28, 37; 28, 41; 28, 56; 28, 104; 28, 120; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:type_; 32, call; 32, 33; 32, 34; 33, identifier:cast; 34, argument_list; 34, 35; 34, 36; 35, identifier:GraphQLAbstractType; 36, identifier:type_; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:suggested_object_types; 40, list:[]; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 42, 52; 43, identifier:interface_usage_count; 44, type; 44, 45; 45, generic_type; 45, 46; 45, 47; 46, identifier:Dict; 47, type_parameter; 47, 48; 47, 50; 48, type; 48, 49; 49, identifier:str; 50, type; 50, 51; 51, identifier:int; 52, call; 52, 53; 52, 54; 53, identifier:defaultdict; 54, argument_list; 54, 55; 55, identifier:int; 56, for_statement; 56, 57; 56, 58; 56, 64; 57, identifier:possible_type; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:schema; 61, identifier:get_possible_types; 62, argument_list; 62, 63; 63, identifier:type_; 64, block; 64, 65; 64, 73; 64, 82; 65, if_statement; 65, 66; 65, 71; 66, comparison_operator:not; 66, 67; 66, 68; 67, identifier:field_name; 68, attribute; 68, 69; 68, 70; 69, identifier:possible_type; 70, identifier:fields; 71, block; 71, 72; 72, continue_statement; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:suggested_object_types; 77, identifier:append; 78, argument_list; 78, 79; 79, attribute; 79, 80; 79, 81; 80, identifier:possible_type; 81, identifier:name; 82, for_statement; 82, 83; 82, 84; 82, 87; 83, identifier:possible_interface; 84, attribute; 84, 85; 84, 86; 85, identifier:possible_type; 86, identifier:interfaces; 87, block; 87, 88; 87, 96; 88, if_statement; 88, 89; 88, 94; 89, comparison_operator:not; 89, 90; 89, 91; 90, identifier:field_name; 91, attribute; 91, 92; 91, 93; 92, identifier:possible_interface; 93, identifier:fields; 94, block; 94, 95; 95, continue_statement; 96, expression_statement; 96, 97; 97, augmented_assignment:+=; 97, 98; 97, 103; 98, subscript; 98, 99; 98, 100; 99, identifier:interface_usage_count; 100, attribute; 100, 101; 100, 102; 101, identifier:possible_interface; 102, identifier:name; 103, integer:1; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:suggested_interface_types; 107, call; 107, 108; 107, 109; 108, identifier:sorted; 109, argument_list; 109, 110; 109, 111; 110, identifier:interface_usage_count; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:key; 113, lambda; 113, 114; 113, 116; 114, lambda_parameters; 114, 115; 115, identifier:k; 116, unary_operator:-; 116, 117; 117, subscript; 117, 118; 117, 119; 118, identifier:interface_usage_count; 119, identifier:k; 120, return_statement; 120, 121; 121, binary_operator:+; 121, 122; 121, 123; 122, identifier:suggested_interface_types; 123, identifier:suggested_object_types; 124, return_statement; 124, 125; 125, list:[] | def get_suggested_type_names(
schema: GraphQLSchema, type_: GraphQLOutputType, field_name: str
) -> List[str]:
if is_abstract_type(type_):
type_ = cast(GraphQLAbstractType, type_)
suggested_object_types = []
interface_usage_count: Dict[str, int] = defaultdict(int)
for possible_type in schema.get_possible_types(type_):
if field_name not in possible_type.fields:
continue
suggested_object_types.append(possible_type.name)
for possible_interface in possible_type.interfaces:
if field_name not in possible_interface.fields:
continue
interface_usage_count[possible_interface.name] += 1
suggested_interface_types = sorted(
interface_usage_count, key=lambda k: -interface_usage_count[k]
)
return suggested_interface_types + suggested_object_types
return [] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:instances_get; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:opts; 5, identifier:plugins; 6, identifier:url_file_input; 7, identifier:out; 8, block; 8, 9; 8, 15; 8, 22; 8, 57; 8, 88; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:instances; 12, call; 12, 13; 12, 14; 13, identifier:OrderedDict; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:preferred_order; 18, list:['wordpress', 'joomla', 'drupal']; 18, 19; 18, 20; 18, 21; 19, string:'wordpress'; 20, string:'joomla'; 21, string:'drupal'; 22, for_statement; 22, 23; 22, 24; 22, 25; 23, identifier:cms_name; 24, identifier:preferred_order; 25, block; 25, 26; 26, for_statement; 26, 27; 26, 28; 26, 29; 27, identifier:plugin; 28, identifier:plugins; 29, block; 29, 30; 29, 40; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:plugin_name; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:plugin; 37, identifier:__name__; 38, identifier:lower; 39, argument_list; 40, if_statement; 40, 41; 40, 44; 41, comparison_operator:==; 41, 42; 41, 43; 42, identifier:cms_name; 43, identifier:plugin_name; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:instances; 49, identifier:plugin_name; 50, call; 50, 51; 50, 52; 51, identifier:instance_get; 52, argument_list; 52, 53; 52, 54; 52, 55; 52, 56; 53, identifier:plugin; 54, identifier:opts; 55, identifier:url_file_input; 56, identifier:out; 57, for_statement; 57, 58; 57, 59; 57, 60; 58, identifier:plugin; 59, identifier:plugins; 60, block; 60, 61; 60, 71; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:plugin_name; 64, call; 64, 65; 64, 70; 65, attribute; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:plugin; 68, identifier:__name__; 69, identifier:lower; 70, argument_list; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:not; 72, 73; 72, 74; 73, identifier:plugin_name; 74, identifier:preferred_order; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 81; 78, subscript; 78, 79; 78, 80; 79, identifier:instances; 80, identifier:plugin_name; 81, call; 81, 82; 81, 83; 82, identifier:instance_get; 83, argument_list; 83, 84; 83, 85; 83, 86; 83, 87; 84, identifier:plugin; 85, identifier:opts; 86, identifier:url_file_input; 87, identifier:out; 88, return_statement; 88, 89; 89, identifier:instances | def instances_get(opts, plugins, url_file_input, out):
instances = OrderedDict()
preferred_order = ['wordpress', 'joomla', 'drupal']
for cms_name in preferred_order:
for plugin in plugins:
plugin_name = plugin.__name__.lower()
if cms_name == plugin_name:
instances[plugin_name] = instance_get(plugin, opts,
url_file_input, out)
for plugin in plugins:
plugin_name = plugin.__name__.lower()
if plugin_name not in preferred_order:
instances[plugin_name] = instance_get(plugin, opts,
url_file_input, out)
return instances |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_signed_headers; 3, parameters; 3, 4; 4, identifier:headers; 5, block; 5, 6; 5, 10; 5, 29; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:signed_headers; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 13; 11, identifier:header; 12, identifier:headers; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:signed_headers; 18, identifier:append; 19, argument_list; 19, 20; 20, call; 20, 21; 20, 28; 21, attribute; 21, 22; 21, 27; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:header; 25, identifier:lower; 26, argument_list; 27, identifier:strip; 28, argument_list; 29, return_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:sorted; 32, argument_list; 32, 33; 33, identifier:signed_headers | def get_signed_headers(headers):
signed_headers = []
for header in headers:
signed_headers.append(header.lower().strip())
return sorted(signed_headers) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:add_from_names_to_locals; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:node; 6, block; 6, 7; 6, 16; 6, 30; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:_key_func; 10, lambda; 10, 11; 10, 13; 11, lambda_parameters; 11, 12; 12, identifier:node; 13, attribute; 13, 14; 13, 15; 14, identifier:node; 15, identifier:fromlineno; 16, function_definition; 16, 17; 16, 18; 16, 20; 17, function_name:sort_locals; 18, parameters; 18, 19; 19, identifier:my_list; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:my_list; 25, identifier:sort; 26, argument_list; 26, 27; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:key; 29, identifier:_key_func; 30, for_statement; 30, 31; 30, 34; 30, 37; 31, tuple_pattern; 31, 32; 31, 33; 32, identifier:name; 33, identifier:asname; 34, attribute; 34, 35; 34, 36; 35, identifier:node; 36, identifier:names; 37, block; 37, 38; 38, if_statement; 38, 39; 38, 42; 38, 92; 39, comparison_operator:==; 39, 40; 39, 41; 40, identifier:name; 41, string:"*"; 42, block; 42, 43; 42, 59; 43, try_statement; 43, 44; 43, 53; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:imported; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:node; 51, identifier:do_import_module; 52, argument_list; 53, except_clause; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:exceptions; 56, identifier:AstroidBuildingError; 57, block; 57, 58; 58, continue_statement; 59, for_statement; 59, 60; 59, 61; 59, 66; 60, identifier:name; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:imported; 64, identifier:public_names; 65, argument_list; 66, block; 66, 67; 66, 77; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 74; 69, attribute; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:node; 72, identifier:parent; 73, identifier:set_local; 74, argument_list; 74, 75; 74, 76; 75, identifier:name; 76, identifier:node; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:sort_locals; 80, argument_list; 80, 81; 81, subscript; 81, 82; 81, 91; 82, attribute; 82, 83; 82, 90; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:node; 87, identifier:parent; 88, identifier:scope; 89, argument_list; 90, identifier:locals; 91, identifier:name; 92, else_clause; 92, 93; 93, block; 93, 94; 93, 106; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:node; 99, identifier:parent; 100, identifier:set_local; 101, argument_list; 101, 102; 101, 105; 102, boolean_operator:or; 102, 103; 102, 104; 103, identifier:asname; 104, identifier:name; 105, identifier:node; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:sort_locals; 109, argument_list; 109, 110; 110, subscript; 110, 111; 110, 120; 111, attribute; 111, 112; 111, 119; 112, call; 112, 113; 112, 118; 113, attribute; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:node; 116, identifier:parent; 117, identifier:scope; 118, argument_list; 119, identifier:locals; 120, boolean_operator:or; 120, 121; 120, 122; 121, identifier:asname; 122, identifier:name | def add_from_names_to_locals(self, node):
_key_func = lambda node: node.fromlineno
def sort_locals(my_list):
my_list.sort(key=_key_func)
for (name, asname) in node.names:
if name == "*":
try:
imported = node.do_import_module()
except exceptions.AstroidBuildingError:
continue
for name in imported.public_names():
node.parent.set_local(name, node)
sort_locals(node.parent.scope().locals[name])
else:
node.parent.set_local(asname or name, node)
sort_locals(node.parent.scope().locals[asname or name]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:nearest; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:nodes; 6, block; 6, 7; 6, 15; 6, 21; 6, 27; 6, 72; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:myroot; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:root; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:mylineno; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:fromlineno; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:nearest; 24, expression_list; 24, 25; 24, 26; 25, None; 26, integer:0; 27, for_statement; 27, 28; 27, 29; 27, 30; 28, identifier:node; 29, identifier:nodes; 30, block; 30, 31; 30, 45; 30, 51; 30, 59; 31, assert_statement; 31, 32; 31, 39; 32, comparison_operator:is; 32, 33; 32, 38; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:node; 36, identifier:root; 37, argument_list; 38, identifier:myroot; 39, parenthesized_expression; 39, 40; 40, binary_operator:%; 40, 41; 40, 42; 41, string:"nodes %s and %s are not from the same module"; 42, tuple; 42, 43; 42, 44; 43, identifier:self; 44, identifier:node; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:lineno; 48, attribute; 48, 49; 48, 50; 49, identifier:node; 50, identifier:fromlineno; 51, if_statement; 51, 52; 51, 57; 52, comparison_operator:>; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:node; 55, identifier:fromlineno; 56, identifier:mylineno; 57, block; 57, 58; 58, break_statement; 59, if_statement; 59, 60; 59, 65; 60, comparison_operator:>; 60, 61; 60, 62; 61, identifier:lineno; 62, subscript; 62, 63; 62, 64; 63, identifier:nearest; 64, integer:1; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:nearest; 69, expression_list; 69, 70; 69, 71; 70, identifier:node; 71, identifier:lineno; 72, return_statement; 72, 73; 73, subscript; 73, 74; 73, 75; 74, identifier:nearest; 75, integer:0 | def nearest(self, nodes):
myroot = self.root()
mylineno = self.fromlineno
nearest = None, 0
for node in nodes:
assert node.root() is myroot, (
"nodes %s and %s are not from the same module" % (self, node)
)
lineno = node.fromlineno
if node.fromlineno > mylineno:
break
if lineno > nearest[1]:
nearest = node, lineno
return nearest[0] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:object_type; 3, parameters; 3, 4; 3, 5; 4, identifier:node; 5, default_parameter; 5, 6; 5, 7; 6, identifier:context; 7, None; 8, block; 8, 9; 8, 31; 8, 46; 9, try_statement; 9, 10; 9, 22; 10, block; 10, 11; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:types; 14, call; 14, 15; 14, 16; 15, identifier:set; 16, argument_list; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:_object_type; 19, argument_list; 19, 20; 19, 21; 20, identifier:node; 21, identifier:context; 22, except_clause; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:exceptions; 25, identifier:InferenceError; 26, block; 26, 27; 27, return_statement; 27, 28; 28, attribute; 28, 29; 28, 30; 29, identifier:util; 30, identifier:Uninferable; 31, if_statement; 31, 32; 31, 41; 32, boolean_operator:or; 32, 33; 32, 39; 33, comparison_operator:>; 33, 34; 33, 38; 34, call; 34, 35; 34, 36; 35, identifier:len; 36, argument_list; 36, 37; 37, identifier:types; 38, integer:1; 39, not_operator; 39, 40; 40, identifier:types; 41, block; 41, 42; 42, return_statement; 42, 43; 43, attribute; 43, 44; 43, 45; 44, identifier:util; 45, identifier:Uninferable; 46, return_statement; 46, 47; 47, subscript; 47, 48; 47, 52; 48, call; 48, 49; 48, 50; 49, identifier:list; 50, argument_list; 50, 51; 51, identifier:types; 52, integer:0 | def object_type(node, context=None):
try:
types = set(_object_type(node, context))
except exceptions.InferenceError:
return util.Uninferable
if len(types) > 1 or not types:
return util.Uninferable
return list(types)[0] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_deffacts; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:sorted; 9, argument_list; 9, 10; 9, 16; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:_get_by_type; 14, argument_list; 14, 15; 15, identifier:DefFacts; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:key; 18, lambda; 18, 19; 18, 21; 19, lambda_parameters; 19, 20; 20, identifier:d; 21, attribute; 21, 22; 21, 23; 22, identifier:d; 23, identifier:order | def get_deffacts(self):
return sorted(self._get_by_type(DefFacts), key=lambda d: d.order) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:json_dumps; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:data; 6, block; 6, 7; 7, return_statement; 7, 8; 8, call; 8, 9; 8, 33; 9, attribute; 9, 10; 9, 32; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:json; 13, identifier:dumps; 14, argument_list; 14, 15; 14, 16; 14, 21; 14, 24; 14, 29; 15, identifier:data; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:separators; 18, tuple; 18, 19; 18, 20; 19, string:','; 20, string:':'; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:sort_keys; 23, True; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:cls; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:json_encoder; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:ensure_ascii; 31, False; 32, identifier:encode; 33, argument_list; 33, 34; 34, string:'utf8' | def json_dumps(self, data):
return json.dumps(
data,
separators=(',', ':'),
sort_keys=True,
cls=self.json_encoder,
ensure_ascii=False
).encode('utf8') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:create_waveform_generator; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:variable_params; 5, identifier:data; 6, default_parameter; 6, 7; 6, 8; 7, identifier:recalibration; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:gates; 11, None; 12, dictionary_splat_pattern; 12, 13; 13, identifier:static_params; 14, block; 14, 15; 14, 31; 14, 40; 14, 44; 14, 106; 14, 145; 15, try_statement; 15, 16; 15, 23; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:approximant; 20, subscript; 20, 21; 20, 22; 21, identifier:static_params; 22, string:'approximant'; 23, except_clause; 23, 24; 23, 25; 24, identifier:KeyError; 25, block; 25, 26; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:ValueError; 29, argument_list; 29, 30; 30, string:"no approximant provided in the static args"; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:generator_function; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:generator; 37, identifier:select_waveform_generator; 38, argument_list; 38, 39; 39, identifier:approximant; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:delta_f; 43, None; 44, for_statement; 44, 45; 44, 46; 44, 51; 45, identifier:d; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:data; 49, identifier:values; 50, argument_list; 51, block; 51, 52; 52, if_statement; 52, 53; 52, 56; 52, 75; 53, comparison_operator:is; 53, 54; 53, 55; 54, identifier:delta_f; 55, None; 56, block; 56, 57; 56, 63; 56, 69; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:delta_f; 60, attribute; 60, 61; 60, 62; 61, identifier:d; 62, identifier:delta_f; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:delta_t; 66, attribute; 66, 67; 66, 68; 67, identifier:d; 68, identifier:delta_t; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:start_time; 72, attribute; 72, 73; 72, 74; 73, identifier:d; 74, identifier:start_time; 75, else_clause; 75, 76; 76, block; 76, 77; 77, if_statement; 77, 78; 77, 98; 78, not_operator; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:all; 81, argument_list; 81, 82; 82, list:[d.delta_f == delta_f, d.delta_t == delta_t,
d.start_time == start_time]; 82, 83; 82, 88; 82, 93; 83, comparison_operator:==; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:d; 86, identifier:delta_f; 87, identifier:delta_f; 88, comparison_operator:==; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:d; 91, identifier:delta_t; 92, identifier:delta_t; 93, comparison_operator:==; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:d; 96, identifier:start_time; 97, identifier:start_time; 98, block; 98, 99; 99, raise_statement; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:ValueError; 102, argument_list; 102, 103; 103, concatenated_string; 103, 104; 103, 105; 104, string:"data must all have the same delta_t, "; 105, string:"delta_f, and start_time"; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:waveform_generator; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:generator; 112, identifier:FDomainDetFrameGenerator; 113, argument_list; 113, 114; 113, 115; 113, 118; 113, 121; 113, 131; 113, 134; 113, 137; 113, 140; 113, 143; 114, identifier:generator_function; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:epoch; 117, identifier:start_time; 118, keyword_argument; 118, 119; 118, 120; 119, identifier:variable_args; 120, identifier:variable_params; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:detectors; 123, call; 123, 124; 123, 125; 124, identifier:list; 125, argument_list; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:data; 129, identifier:keys; 130, argument_list; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:delta_f; 133, identifier:delta_f; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:delta_t; 136, identifier:delta_t; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:recalib; 139, identifier:recalibration; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:gates; 142, identifier:gates; 143, dictionary_splat; 143, 144; 144, identifier:static_params; 145, return_statement; 145, 146; 146, identifier:waveform_generator | def create_waveform_generator(variable_params, data,
recalibration=None, gates=None,
**static_params):
try:
approximant = static_params['approximant']
except KeyError:
raise ValueError("no approximant provided in the static args")
generator_function = generator.select_waveform_generator(approximant)
delta_f = None
for d in data.values():
if delta_f is None:
delta_f = d.delta_f
delta_t = d.delta_t
start_time = d.start_time
else:
if not all([d.delta_f == delta_f, d.delta_t == delta_t,
d.start_time == start_time]):
raise ValueError("data must all have the same delta_t, "
"delta_f, and start_time")
waveform_generator = generator.FDomainDetFrameGenerator(
generator_function, epoch=start_time,
variable_args=variable_params, detectors=list(data.keys()),
delta_f=delta_f, delta_t=delta_t,
recalib=recalibration, gates=gates,
**static_params)
return waveform_generator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:rst_dict_table; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:dict_; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key_format; 7, identifier:str; 8, default_parameter; 8, 9; 8, 10; 9, identifier:val_format; 10, identifier:str; 11, default_parameter; 11, 12; 11, 13; 12, identifier:header; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:sort; 16, True; 17, block; 17, 18; 17, 32; 17, 40; 17, 48; 17, 59; 17, 70; 17, 101; 17, 115; 17, 139; 17, 144; 17, 160; 17, 168; 17, 178; 17, 207; 17, 214; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, pattern_list; 20, 21; 20, 22; 21, identifier:keys; 22, identifier:values; 23, call; 23, 24; 23, 25; 24, identifier:zip; 25, argument_list; 25, 26; 26, list_splat; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:dict_; 30, identifier:items; 31, argument_list; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:keys; 35, call; 35, 36; 35, 37; 36, identifier:map; 37, argument_list; 37, 38; 37, 39; 38, identifier:key_format; 39, identifier:keys; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:values; 43, call; 43, 44; 43, 45; 44, identifier:map; 45, argument_list; 45, 46; 45, 47; 46, identifier:val_format; 47, identifier:values; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:nckey; 51, call; 51, 52; 51, 53; 52, identifier:max; 53, argument_list; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:map; 56, argument_list; 56, 57; 56, 58; 57, identifier:len; 58, identifier:keys; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:ncval; 62, call; 62, 63; 62, 64; 63, identifier:max; 64, argument_list; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:map; 67, argument_list; 67, 68; 67, 69; 68, identifier:len; 69, identifier:values; 70, if_statement; 70, 71; 70, 72; 71, identifier:header; 72, block; 72, 73; 72, 79; 72, 90; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 78; 75, pattern_list; 75, 76; 75, 77; 76, identifier:khead; 77, identifier:vhead; 78, identifier:header; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:nckey; 82, call; 82, 83; 82, 84; 83, identifier:max; 84, argument_list; 84, 85; 84, 86; 85, identifier:nckey; 86, call; 86, 87; 86, 88; 87, identifier:len; 88, argument_list; 88, 89; 89, identifier:khead; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:ncval; 93, call; 93, 94; 93, 95; 94, identifier:max; 95, argument_list; 95, 96; 95, 97; 96, identifier:ncval; 97, call; 97, 98; 97, 99; 98, identifier:len; 99, argument_list; 99, 100; 100, identifier:vhead; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:divider; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, string:"{} {}"; 107, identifier:format; 108, argument_list; 108, 109; 108, 112; 109, binary_operator:*; 109, 110; 109, 111; 110, string:'='; 111, identifier:nckey; 112, binary_operator:*; 112, 113; 112, 114; 113, string:'='; 114, identifier:ncval; 115, function_definition; 115, 116; 115, 117; 115, 120; 116, function_name:row; 117, parameters; 117, 118; 117, 119; 118, identifier:key; 119, identifier:val; 120, block; 120, 121; 120, 131; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:fmt; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, string:'{{0:{0}s}} {{1}}'; 127, identifier:format; 128, argument_list; 128, 129; 128, 130; 129, identifier:nckey; 130, identifier:ncval; 131, return_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:fmt; 135, identifier:format; 136, argument_list; 136, 137; 136, 138; 137, identifier:key; 138, identifier:val; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:lines; 142, list:[divider]; 142, 143; 143, identifier:divider; 144, if_statement; 144, 145; 144, 146; 145, identifier:header; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:lines; 151, identifier:extend; 152, argument_list; 152, 153; 153, tuple; 153, 154; 153, 159; 154, call; 154, 155; 154, 156; 155, identifier:row; 156, argument_list; 156, 157; 157, list_splat; 157, 158; 158, identifier:header; 159, identifier:divider; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:params; 163, call; 163, 164; 163, 165; 164, identifier:zip; 165, argument_list; 165, 166; 165, 167; 166, identifier:keys; 167, identifier:values; 168, if_statement; 168, 169; 168, 170; 169, identifier:sort; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:params; 174, call; 174, 175; 174, 176; 175, identifier:sorted; 176, argument_list; 176, 177; 177, identifier:params; 178, for_statement; 178, 179; 178, 182; 178, 183; 179, pattern_list; 179, 180; 179, 181; 180, identifier:key; 181, identifier:val; 182, identifier:params; 183, block; 183, 184; 183, 194; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:fmt; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, string:'{{0:{0}s}} {{1}}'; 190, identifier:format; 191, argument_list; 191, 192; 191, 193; 192, identifier:nckey; 193, identifier:ncval; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:lines; 198, identifier:append; 199, argument_list; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:fmt; 203, identifier:format; 204, argument_list; 204, 205; 204, 206; 205, identifier:key; 206, identifier:val; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:lines; 211, identifier:append; 212, argument_list; 212, 213; 213, identifier:divider; 214, return_statement; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, string:'\n'; 218, identifier:join; 219, argument_list; 219, 220; 220, identifier:lines | def rst_dict_table(dict_, key_format=str, val_format=str, header=None,
sort=True):
keys, values = zip(*dict_.items())
keys = map(key_format, keys)
values = map(val_format, values)
nckey = max(map(len, keys))
ncval = max(map(len, values))
if header:
khead, vhead = header
nckey = max(nckey, len(khead))
ncval = max(ncval, len(vhead))
divider = "{} {}".format('='*nckey, '='*ncval)
def row(key, val):
fmt = '{{0:{0}s}} {{1}}'.format(nckey, ncval)
return fmt.format(key, val)
lines = [divider]
if header:
lines.extend((row(*header), divider))
params = zip(keys, values)
if sort:
params = sorted(params)
for key, val in params:
fmt = '{{0:{0}s}} {{1}}'.format(nckey, ncval)
lines.append(fmt.format(key, val))
lines.append(divider)
return '\n'.join(lines) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:read_transforms_from_config; 3, parameters; 3, 4; 3, 5; 4, identifier:cp; 5, default_parameter; 5, 6; 5, 7; 6, identifier:section; 7, string:"transforms"; 8, block; 8, 9; 8, 13; 8, 53; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:trans; 12, list:[]; 13, for_statement; 13, 14; 13, 15; 13, 21; 14, identifier:subsection; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:cp; 18, identifier:get_subsections; 19, argument_list; 19, 20; 20, identifier:section; 21, block; 21, 22; 21, 33; 21, 46; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:name; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:cp; 28, identifier:get_opt_tag; 29, argument_list; 29, 30; 29, 31; 29, 32; 30, identifier:section; 31, string:"name"; 32, identifier:subsection; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:t; 36, call; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, subscript; 38, 39; 38, 40; 39, identifier:transforms; 40, identifier:name; 41, identifier:from_config; 42, argument_list; 42, 43; 42, 44; 42, 45; 43, identifier:cp; 44, identifier:section; 45, identifier:subsection; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:trans; 50, identifier:append; 51, argument_list; 51, 52; 52, identifier:t; 53, return_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:order_transforms; 56, argument_list; 56, 57; 57, identifier:trans | def read_transforms_from_config(cp, section="transforms"):
trans = []
for subsection in cp.get_subsections(section):
name = cp.get_opt_tag(section, "name", subsection)
t = transforms[name].from_config(cp, section, subsection)
trans.append(t)
return order_transforms(trans) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:samples_from_cli; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:opts; 6, default_parameter; 6, 7; 6, 8; 7, identifier:parameters; 8, None; 9, dictionary_splat_pattern; 9, 10; 10, identifier:kwargs; 11, block; 11, 12; 11, 40; 11, 50; 11, 60; 11, 72; 12, if_statement; 12, 13; 12, 22; 12, 29; 13, boolean_operator:and; 13, 14; 13, 17; 14, comparison_operator:is; 14, 15; 14, 16; 15, identifier:parameters; 16, None; 17, comparison_operator:is; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:opts; 20, identifier:parameters; 21, None; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:parameters; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:variable_args; 29, elif_clause; 29, 30; 29, 33; 30, comparison_operator:is; 30, 31; 30, 32; 31, identifier:parameters; 32, None; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:parameters; 37, attribute; 37, 38; 37, 39; 38, identifier:opts; 39, identifier:parameters; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 45; 42, pattern_list; 42, 43; 42, 44; 43, identifier:_; 44, identifier:extra_actions; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:extra_args_parser; 49, argument_list; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:extra_args; 53, list_comprehension; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:act; 56, identifier:dest; 57, for_in_clause; 57, 58; 57, 59; 58, identifier:act; 59, identifier:extra_actions; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:kwargs; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_get_optional_args; 67, argument_list; 67, 68; 67, 69; 67, 70; 68, identifier:extra_args; 69, identifier:opts; 70, dictionary_splat; 70, 71; 71, identifier:kwargs; 72, return_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:read_samples; 77, argument_list; 77, 78; 77, 79; 78, identifier:parameters; 79, dictionary_splat; 79, 80; 80, identifier:kwargs | def samples_from_cli(self, opts, parameters=None, **kwargs):
if parameters is None and opts.parameters is None:
parameters = self.variable_args
elif parameters is None:
parameters = opts.parameters
_, extra_actions = self.extra_args_parser()
extra_args = [act.dest for act in extra_actions]
kwargs = self._get_optional_args(extra_args, opts, **kwargs)
return self.read_samples(parameters, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:data_from_cli; 3, parameters; 3, 4; 4, identifier:opts; 5, block; 5, 6; 5, 13; 5, 20; 5, 33; 5, 44; 5, 58; 5, 142; 5, 146; 5, 150; 5, 154; 5, 161; 5, 198; 5, 215; 5, 265; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:gates; 9, call; 9, 10; 9, 11; 10, identifier:gates_from_cli; 11, argument_list; 11, 12; 12, identifier:opts; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:psd_gates; 16, call; 16, 17; 16, 18; 17, identifier:psd_gates_from_cli; 18, argument_list; 18, 19; 19, identifier:opts; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:instruments; 23, conditional_expression:if; 23, 24; 23, 27; 23, 32; 24, attribute; 24, 25; 24, 26; 25, identifier:opts; 26, identifier:instruments; 27, comparison_operator:is; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:opts; 30, identifier:instruments; 31, None; 32, list:[]; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:strain_dict; 36, call; 36, 37; 36, 38; 37, identifier:strain_from_cli_multi_ifos; 38, argument_list; 38, 39; 38, 40; 38, 41; 39, identifier:opts; 40, identifier:instruments; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:precision; 43, string:"double"; 44, if_statement; 44, 45; 44, 49; 45, not_operator; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:opts; 48, identifier:gate_overwhitened; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:strain_dict; 53, call; 53, 54; 53, 55; 54, identifier:apply_gates_to_td; 55, argument_list; 55, 56; 55, 57; 56, identifier:strain_dict; 57, identifier:gates; 58, if_statement; 58, 59; 58, 66; 58, 122; 58, 136; 59, boolean_operator:and; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:opts; 62, identifier:psd_start_time; 63, attribute; 63, 64; 63, 65; 64, identifier:opts; 65, identifier:psd_end_time; 66, block; 66, 67; 66, 76; 66, 80; 66, 88; 66, 96; 66, 107; 66, 114; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:logging; 71, identifier:info; 72, argument_list; 72, 73; 73, concatenated_string; 73, 74; 73, 75; 74, string:"Will generate a different time series for PSD "; 75, string:"estimation"; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:psd_opts; 79, identifier:opts; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:psd_opts; 84, identifier:gps_start_time; 85, attribute; 85, 86; 85, 87; 86, identifier:psd_opts; 87, identifier:psd_start_time; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:psd_opts; 92, identifier:gps_end_time; 93, attribute; 93, 94; 93, 95; 94, identifier:psd_opts; 95, identifier:psd_end_time; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:psd_strain_dict; 99, call; 99, 100; 99, 101; 100, identifier:strain_from_cli_multi_ifos; 101, argument_list; 101, 102; 101, 103; 101, 104; 102, identifier:psd_opts; 103, identifier:instruments; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:precision; 106, string:"double"; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:logging; 111, identifier:info; 112, argument_list; 112, 113; 113, string:"Applying gates to PSD data"; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:psd_strain_dict; 117, call; 117, 118; 117, 119; 118, identifier:apply_gates_to_td; 119, argument_list; 119, 120; 119, 121; 120, identifier:psd_strain_dict; 121, identifier:psd_gates; 122, elif_clause; 122, 123; 122, 130; 123, boolean_operator:or; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:opts; 126, identifier:psd_start_time; 127, attribute; 127, 128; 127, 129; 128, identifier:opts; 129, identifier:psd_end_time; 130, block; 130, 131; 131, raise_statement; 131, 132; 132, call; 132, 133; 132, 134; 133, identifier:ValueError; 134, argument_list; 134, 135; 135, string:"Must give --psd-start-time and --psd-end-time"; 136, else_clause; 136, 137; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:psd_strain_dict; 141, identifier:strain_dict; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:stilde_dict; 145, dictionary; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:length_dict; 149, dictionary; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:delta_f_dict; 153, dictionary; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:low_frequency_cutoff_dict; 157, call; 157, 158; 157, 159; 158, identifier:low_frequency_cutoff_from_cli; 159, argument_list; 159, 160; 160, identifier:opts; 161, for_statement; 161, 162; 161, 163; 161, 164; 162, identifier:ifo; 163, identifier:instruments; 164, block; 164, 165; 164, 177; 164, 188; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 170; 167, subscript; 167, 168; 167, 169; 168, identifier:stilde_dict; 169, identifier:ifo; 170, call; 170, 171; 170, 176; 171, attribute; 171, 172; 171, 175; 172, subscript; 172, 173; 172, 174; 173, identifier:strain_dict; 174, identifier:ifo; 175, identifier:to_frequencyseries; 176, argument_list; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, subscript; 179, 180; 179, 181; 180, identifier:length_dict; 181, identifier:ifo; 182, call; 182, 183; 182, 184; 183, identifier:len; 184, argument_list; 184, 185; 185, subscript; 185, 186; 185, 187; 186, identifier:stilde_dict; 187, identifier:ifo; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 193; 190, subscript; 190, 191; 190, 192; 191, identifier:delta_f_dict; 192, identifier:ifo; 193, attribute; 193, 194; 193, 197; 194, subscript; 194, 195; 194, 196; 195, identifier:stilde_dict; 196, identifier:ifo; 197, identifier:delta_f; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:psd_dict; 201, call; 201, 202; 201, 203; 202, identifier:psd_from_cli_multi_ifos; 203, argument_list; 203, 204; 203, 205; 203, 206; 203, 207; 203, 208; 203, 209; 203, 212; 204, identifier:opts; 205, identifier:length_dict; 206, identifier:delta_f_dict; 207, identifier:low_frequency_cutoff_dict; 208, identifier:instruments; 209, keyword_argument; 209, 210; 209, 211; 210, identifier:strain_dict; 211, identifier:psd_strain_dict; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:precision; 214, string:"double"; 215, if_statement; 215, 216; 215, 225; 216, boolean_operator:and; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:opts; 219, identifier:gate_overwhitened; 220, comparison_operator:is; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:opts; 223, identifier:gate; 224, None; 225, block; 225, 226; 225, 233; 225, 245; 225, 253; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:logging; 230, identifier:info; 231, argument_list; 231, 232; 232, string:"Applying gates to overwhitened data"; 233, for_statement; 233, 234; 233, 235; 233, 236; 234, identifier:ifo; 235, identifier:gates; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, augmented_assignment:/=; 238, 239; 238, 242; 239, subscript; 239, 240; 239, 241; 240, identifier:stilde_dict; 241, identifier:ifo; 242, subscript; 242, 243; 242, 244; 243, identifier:psd_dict; 244, identifier:ifo; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:stilde_dict; 248, call; 248, 249; 248, 250; 249, identifier:apply_gates_to_fd; 250, argument_list; 250, 251; 250, 252; 251, identifier:stilde_dict; 252, identifier:gates; 253, for_statement; 253, 254; 253, 255; 253, 256; 254, identifier:ifo; 255, identifier:gates; 256, block; 256, 257; 257, expression_statement; 257, 258; 258, augmented_assignment:*=; 258, 259; 258, 262; 259, subscript; 259, 260; 259, 261; 260, identifier:stilde_dict; 261, identifier:ifo; 262, subscript; 262, 263; 262, 264; 263, identifier:psd_dict; 264, identifier:ifo; 265, return_statement; 265, 266; 266, expression_list; 266, 267; 266, 268; 266, 269; 267, identifier:strain_dict; 268, identifier:stilde_dict; 269, identifier:psd_dict | def data_from_cli(opts):
gates = gates_from_cli(opts)
psd_gates = psd_gates_from_cli(opts)
instruments = opts.instruments if opts.instruments is not None else []
strain_dict = strain_from_cli_multi_ifos(opts, instruments,
precision="double")
if not opts.gate_overwhitened:
strain_dict = apply_gates_to_td(strain_dict, gates)
if opts.psd_start_time and opts.psd_end_time:
logging.info("Will generate a different time series for PSD "
"estimation")
psd_opts = opts
psd_opts.gps_start_time = psd_opts.psd_start_time
psd_opts.gps_end_time = psd_opts.psd_end_time
psd_strain_dict = strain_from_cli_multi_ifos(psd_opts,
instruments,
precision="double")
logging.info("Applying gates to PSD data")
psd_strain_dict = apply_gates_to_td(psd_strain_dict, psd_gates)
elif opts.psd_start_time or opts.psd_end_time:
raise ValueError("Must give --psd-start-time and --psd-end-time")
else:
psd_strain_dict = strain_dict
stilde_dict = {}
length_dict = {}
delta_f_dict = {}
low_frequency_cutoff_dict = low_frequency_cutoff_from_cli(opts)
for ifo in instruments:
stilde_dict[ifo] = strain_dict[ifo].to_frequencyseries()
length_dict[ifo] = len(stilde_dict[ifo])
delta_f_dict[ifo] = stilde_dict[ifo].delta_f
psd_dict = psd_from_cli_multi_ifos(
opts, length_dict, delta_f_dict, low_frequency_cutoff_dict,
instruments, strain_dict=psd_strain_dict, precision="double")
if opts.gate_overwhitened and opts.gate is not None:
logging.info("Applying gates to overwhitened data")
for ifo in gates:
stilde_dict[ifo] /= psd_dict[ifo]
stilde_dict = apply_gates_to_fd(stilde_dict, gates)
for ifo in gates:
stilde_dict[ifo] *= psd_dict[ifo]
return strain_dict, stilde_dict, psd_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 9; 3, 12; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:axis; 7, unary_operator:-; 7, 8; 8, integer:1; 9, default_parameter; 9, 10; 9, 11; 10, identifier:kind; 11, string:'quicksort'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:order; 14, None; 15, block; 15, 16; 16, try_statement; 16, 17; 16, 36; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:numpy; 23, identifier:recarray; 24, identifier:sort; 25, argument_list; 25, 26; 25, 27; 25, 30; 25, 33; 26, identifier:self; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:axis; 29, identifier:axis; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:kind; 32, identifier:kind; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:order; 35, identifier:order; 36, except_clause; 36, 37; 36, 38; 37, identifier:ValueError; 38, block; 38, 39; 38, 51; 39, if_statement; 39, 40; 39, 45; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 44; 43, identifier:order; 44, identifier:list; 45, block; 45, 46; 46, raise_statement; 46, 47; 47, call; 47, 48; 47, 49; 48, identifier:ValueError; 49, argument_list; 49, 50; 50, string:"Cannot process more than one order field"; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 57; 53, subscript; 53, 54; 53, 55; 54, identifier:self; 55, slice; 55, 56; 56, colon; 57, subscript; 57, 58; 57, 59; 58, identifier:self; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:numpy; 62, identifier:argsort; 63, argument_list; 63, 64; 64, subscript; 64, 65; 64, 66; 65, identifier:self; 66, identifier:order | def sort(self, axis=-1, kind='quicksort', order=None):
try:
numpy.recarray.sort(self, axis=axis, kind=kind, order=order)
except ValueError:
if isinstance(order, list):
raise ValueError("Cannot process more than one order field")
self[:] = self[numpy.argsort(self[order])] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:emit_containers; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:containers; 6, default_parameter; 6, 7; 6, 8; 7, identifier:verbose; 8, True; 9, block; 9, 10; 9, 28; 9, 47; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:containers; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, argument_list; 15, 16; 15, 17; 16, identifier:containers; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:key; 19, lambda; 19, 20; 19, 22; 20, lambda_parameters; 20, 21; 21, identifier:c; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:c; 25, identifier:get; 26, argument_list; 26, 27; 27, string:'name'; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:task_definition; 31, dictionary; 31, 32; 31, 37; 31, 40; 32, pair; 32, 33; 32, 34; 33, string:'family'; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:family; 37, pair; 37, 38; 37, 39; 38, string:'containerDefinitions'; 39, identifier:containers; 40, pair; 40, 41; 40, 42; 41, string:'volumes'; 42, boolean_operator:or; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:volumes; 46, list:[]; 47, if_statement; 47, 48; 47, 49; 47, 63; 48, identifier:verbose; 49, block; 49, 50; 50, return_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:json; 54, identifier:dumps; 55, argument_list; 55, 56; 55, 57; 55, 60; 56, identifier:task_definition; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:indent; 59, integer:4; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:sort_keys; 62, True; 63, else_clause; 63, 64; 64, block; 64, 65; 65, return_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:json; 69, identifier:dumps; 70, argument_list; 70, 71; 71, identifier:task_definition | def emit_containers(self, containers, verbose=True):
containers = sorted(containers, key=lambda c: c.get('name'))
task_definition = {
'family': self.family,
'containerDefinitions': containers,
'volumes': self.volumes or []
}
if verbose:
return json.dumps(task_definition, indent=4, sort_keys=True)
else:
return json.dumps(task_definition) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_completions; 3, parameters; 3, 4; 4, identifier:completions_gen; 5, block; 5, 6; 5, 12; 5, 45; 6, import_from_statement; 6, 7; 6, 10; 7, dotted_name; 7, 8; 7, 9; 8, identifier:knack; 9, identifier:help; 10, dotted_name; 10, 11; 11, identifier:REQUIRED_TAG; 12, function_definition; 12, 13; 12, 14; 12, 16; 13, function_name:_get_weight; 14, parameters; 14, 15; 15, identifier:val; 16, block; 16, 17; 16, 21; 16, 39; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:priority; 20, string:''; 21, if_statement; 21, 22; 21, 34; 22, boolean_operator:and; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:val; 25, identifier:display_meta; 26, call; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:val; 30, identifier:display_meta; 31, identifier:startswith; 32, argument_list; 32, 33; 33, identifier:REQUIRED_TAG; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:priority; 38, string:' '; 39, return_statement; 39, 40; 40, binary_operator:+; 40, 41; 40, 42; 41, identifier:priority; 42, attribute; 42, 43; 42, 44; 43, identifier:val; 44, identifier:text; 45, return_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:sorted; 48, argument_list; 48, 49; 48, 50; 49, identifier:completions_gen; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:key; 52, identifier:_get_weight | def sort_completions(completions_gen):
from knack.help import REQUIRED_TAG
def _get_weight(val):
priority = ''
if val.display_meta and val.display_meta.startswith(REQUIRED_TAG):
priority = ' '
return priority + val.text
return sorted(completions_gen, key=_get_weight) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:attr_list; 3, parameters; 3, 4; 3, 7; 3, 10; 4, default_parameter; 4, 5; 4, 6; 5, identifier:label; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:kwargs; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:attributes; 12, None; 13, block; 13, 14; 13, 23; 13, 29; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:content; 17, call; 17, 18; 17, 19; 18, identifier:a_list; 19, argument_list; 19, 20; 19, 21; 19, 22; 20, identifier:label; 21, identifier:kwargs; 22, identifier:attributes; 23, if_statement; 23, 24; 23, 26; 24, not_operator; 24, 25; 25, identifier:content; 26, block; 26, 27; 27, return_statement; 27, 28; 28, string:''; 29, return_statement; 29, 30; 30, binary_operator:%; 30, 31; 30, 32; 31, string:' [%s]'; 32, identifier:content | def attr_list(label=None, kwargs=None, attributes=None):
content = a_list(label, kwargs, attributes)
if not content:
return ''
return ' [%s]' % content |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:mapping_items; 3, parameters; 3, 4; 3, 5; 4, identifier:mapping; 5, default_parameter; 5, 6; 5, 7; 6, identifier:_iteritems; 7, attribute; 7, 8; 7, 9; 8, identifier:_compat; 9, identifier:iteritems; 10, block; 10, 11; 10, 30; 11, if_statement; 11, 12; 11, 18; 12, comparison_operator:is; 12, 13; 12, 17; 13, call; 13, 14; 13, 15; 14, identifier:type; 15, argument_list; 15, 16; 16, identifier:mapping; 17, identifier:dict; 18, block; 18, 19; 19, return_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:iter; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:sorted; 25, argument_list; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:_iteritems; 28, argument_list; 28, 29; 29, identifier:mapping; 30, return_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:_iteritems; 33, argument_list; 33, 34; 34, identifier:mapping | def mapping_items(mapping, _iteritems=_compat.iteritems):
if type(mapping) is dict:
return iter(sorted(_iteritems(mapping)))
return _iteritems(mapping) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:convert_tensor_to_probability_map; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:scope; 5, identifier:operator; 6, identifier:container; 7, block; 7, 8; 7, 10; 7, 22; 7, 33; 7, 200; 7, 212; 7, 333; 8, expression_statement; 8, 9; 9, string:'''
This converter tries to convert a special operator 'TensorToProbabilityMap' into a sequence of some ONNX operators.
Those operators are used to create a dictionary in which keys are class labels and values are the associated
probabilities. We assume that the elements in the given probability tensor are aligned with the class labels
specified in the CoreML model.
Notice that ONNX<1.2 doesn't support a CoreML classifier with a batch size larger than one because old ONNX ZipMap
is not able to produce a sequence of dictionaries. This issue has been fixed in ONNX-1.2.
'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:attrs; 13, dictionary; 13, 14; 14, pair; 14, 15; 14, 16; 15, string:'name'; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:scope; 19, identifier:get_unique_operator_name; 20, argument_list; 20, 21; 21, string:'ZipMap'; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:model_type; 25, call; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:operator; 29, identifier:raw_operator; 30, identifier:WhichOneof; 31, argument_list; 31, 32; 32, string:'Type'; 33, if_statement; 33, 34; 33, 37; 33, 113; 33, 193; 34, comparison_operator:==; 34, 35; 34, 36; 35, identifier:model_type; 36, string:'neuralNetworkClassifier'; 37, block; 37, 38; 37, 46; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:model; 41, attribute; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:operator; 44, identifier:raw_operator; 45, identifier:neuralNetworkClassifier; 46, if_statement; 46, 47; 46, 55; 46, 77; 46, 106; 47, comparison_operator:==; 47, 48; 47, 54; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:model; 51, identifier:WhichOneof; 52, argument_list; 52, 53; 53, string:'ClassLabels'; 54, string:'stringClassLabels'; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 61; 58, subscript; 58, 59; 58, 60; 59, identifier:attrs; 60, string:'classlabels_strings'; 61, call; 61, 62; 61, 63; 62, identifier:list; 63, generator_expression; 63, 64; 63, 70; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:s; 67, identifier:encode; 68, argument_list; 68, 69; 69, string:'utf-8'; 70, for_in_clause; 70, 71; 70, 72; 71, identifier:s; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:model; 75, identifier:stringClassLabels; 76, identifier:vector; 77, elif_clause; 77, 78; 77, 86; 78, comparison_operator:==; 78, 79; 78, 85; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:model; 82, identifier:WhichOneof; 83, argument_list; 83, 84; 84, string:'ClassLabels'; 85, string:'int64ClassLabels'; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:attrs; 91, string:'classlabels_int64s'; 92, call; 92, 93; 92, 94; 93, identifier:list; 94, generator_expression; 94, 95; 94, 99; 95, call; 95, 96; 95, 97; 96, identifier:int; 97, argument_list; 97, 98; 98, identifier:i; 99, for_in_clause; 99, 100; 99, 101; 100, identifier:i; 101, attribute; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:model; 104, identifier:int64ClassLabels; 105, identifier:vector; 106, else_clause; 106, 107; 107, block; 107, 108; 108, raise_statement; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:ValueError; 111, argument_list; 111, 112; 112, string:'Unknown label type found'; 113, elif_clause; 113, 114; 113, 117; 114, comparison_operator:==; 114, 115; 114, 116; 115, identifier:model_type; 116, string:'pipelineClassifier'; 117, block; 117, 118; 117, 126; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:model; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:operator; 124, identifier:raw_operator; 125, identifier:pipelineClassifier; 126, if_statement; 126, 127; 126, 135; 126, 157; 126, 186; 127, comparison_operator:==; 127, 128; 127, 134; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:model; 131, identifier:WhichOneof; 132, argument_list; 132, 133; 133, string:'ClassLabels'; 134, string:'stringClassLabels'; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 141; 138, subscript; 138, 139; 138, 140; 139, identifier:attrs; 140, string:'classlabels_strings'; 141, call; 141, 142; 141, 143; 142, identifier:list; 143, generator_expression; 143, 144; 143, 150; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:s; 147, identifier:encode; 148, argument_list; 148, 149; 149, string:'utf-8'; 150, for_in_clause; 150, 151; 150, 152; 151, identifier:s; 152, attribute; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:model; 155, identifier:stringClassLabels; 156, identifier:vector; 157, elif_clause; 157, 158; 157, 166; 158, comparison_operator:==; 158, 159; 158, 165; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:model; 162, identifier:WhichOneof; 163, argument_list; 163, 164; 164, string:'ClassLabels'; 165, string:'int64ClassLabels'; 166, block; 166, 167; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 172; 169, subscript; 169, 170; 169, 171; 170, identifier:attrs; 171, string:'classlabels_int64s'; 172, call; 172, 173; 172, 174; 173, identifier:list; 174, generator_expression; 174, 175; 174, 179; 175, call; 175, 176; 175, 177; 176, identifier:int; 177, argument_list; 177, 178; 178, identifier:i; 179, for_in_clause; 179, 180; 179, 181; 180, identifier:i; 181, attribute; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:model; 184, identifier:int64ClassLabels; 185, identifier:vector; 186, else_clause; 186, 187; 187, block; 187, 188; 188, raise_statement; 188, 189; 189, call; 189, 190; 189, 191; 190, identifier:ValueError; 191, argument_list; 191, 192; 192, string:'Unknown label type found'; 193, else_clause; 193, 194; 194, block; 194, 195; 195, raise_statement; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:TypeError; 198, argument_list; 198, 199; 199, string:'Only neural network classifiers and pipeline classifiers are supported'; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:input_shape; 203, attribute; 203, 204; 203, 211; 204, attribute; 204, 205; 204, 210; 205, subscript; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:operator; 208, identifier:inputs; 209, integer:0; 210, identifier:type; 211, identifier:shape; 212, if_statement; 212, 213; 212, 227; 212, 321; 213, comparison_operator:!=; 213, 214; 213, 226; 214, call; 214, 215; 214, 216; 215, identifier:len; 216, argument_list; 216, 217; 217, attribute; 217, 218; 217, 225; 218, attribute; 218, 219; 218, 224; 219, subscript; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:operator; 222, identifier:inputs; 223, integer:0; 224, identifier:type; 225, identifier:shape; 226, integer:2; 227, block; 227, 228; 227, 248; 227, 293; 227, 302; 228, if_statement; 228, 229; 228, 234; 228, 241; 229, comparison_operator:!=; 229, 230; 229, 233; 230, subscript; 230, 231; 230, 232; 231, identifier:input_shape; 232, integer:0; 233, string:'None'; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:N; 238, subscript; 238, 239; 238, 240; 239, identifier:input_shape; 240, integer:0; 241, else_clause; 241, 242; 242, block; 242, 243; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:N; 246, unary_operator:-; 246, 247; 247, integer:1; 248, if_statement; 248, 249; 248, 266; 248, 286; 249, call; 249, 250; 249, 251; 250, identifier:all; 251, generator_expression; 251, 252; 251, 259; 252, call; 252, 253; 252, 254; 253, identifier:isinstance; 254, argument_list; 254, 255; 254, 256; 255, identifier:i; 256, attribute; 256, 257; 256, 258; 257, identifier:numbers; 258, identifier:Integral; 259, for_in_clause; 259, 260; 259, 261; 260, identifier:i; 261, subscript; 261, 262; 261, 263; 262, identifier:input_shape; 263, slice; 263, 264; 263, 265; 264, integer:1; 265, colon; 266, block; 266, 267; 266, 271; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:C; 270, integer:1; 271, for_statement; 271, 272; 271, 273; 271, 278; 272, identifier:i; 273, subscript; 273, 274; 273, 275; 274, identifier:input_shape; 275, slice; 275, 276; 275, 277; 276, integer:1; 277, colon; 278, block; 278, 279; 279, expression_statement; 279, 280; 280, augmented_assignment:*=; 280, 281; 280, 282; 281, identifier:C; 282, call; 282, 283; 282, 284; 283, identifier:int; 284, argument_list; 284, 285; 285, identifier:i; 286, else_clause; 286, 287; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:C; 291, unary_operator:-; 291, 292; 292, integer:1; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 296; 295, identifier:buffer_name; 296, call; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:scope; 299, identifier:get_unique_variable_name; 300, argument_list; 300, 301; 301, string:'buffer'; 302, expression_statement; 302, 303; 303, call; 303, 304; 303, 305; 304, identifier:apply_reshape; 305, argument_list; 305, 306; 305, 307; 305, 314; 305, 315; 305, 316; 306, identifier:scope; 307, attribute; 307, 308; 307, 313; 308, subscript; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:operator; 311, identifier:inputs; 312, integer:0; 313, identifier:full_name; 314, identifier:buffer_name; 315, identifier:container; 316, keyword_argument; 316, 317; 316, 318; 317, identifier:desired_shape; 318, list:[N, C]; 318, 319; 318, 320; 319, identifier:N; 320, identifier:C; 321, else_clause; 321, 322; 322, block; 322, 323; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:buffer_name; 326, attribute; 326, 327; 326, 332; 327, subscript; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:operator; 330, identifier:inputs; 331, integer:0; 332, identifier:full_name; 333, expression_statement; 333, 334; 334, call; 334, 335; 334, 338; 335, attribute; 335, 336; 335, 337; 336, identifier:container; 337, identifier:add_node; 338, argument_list; 338, 339; 338, 340; 338, 341; 338, 348; 338, 351; 339, string:'ZipMap'; 340, identifier:buffer_name; 341, attribute; 341, 342; 341, 347; 342, subscript; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:operator; 345, identifier:outputs; 346, integer:0; 347, identifier:full_name; 348, keyword_argument; 348, 349; 348, 350; 349, identifier:op_domain; 350, string:'ai.onnx.ml'; 351, dictionary_splat; 351, 352; 352, identifier:attrs | def convert_tensor_to_probability_map(scope, operator, container):
'''
This converter tries to convert a special operator 'TensorToProbabilityMap' into a sequence of some ONNX operators.
Those operators are used to create a dictionary in which keys are class labels and values are the associated
probabilities. We assume that the elements in the given probability tensor are aligned with the class labels
specified in the CoreML model.
Notice that ONNX<1.2 doesn't support a CoreML classifier with a batch size larger than one because old ONNX ZipMap
is not able to produce a sequence of dictionaries. This issue has been fixed in ONNX-1.2.
'''
attrs = {'name': scope.get_unique_operator_name('ZipMap')}
model_type = operator.raw_operator.WhichOneof('Type')
if model_type == 'neuralNetworkClassifier':
model = operator.raw_operator.neuralNetworkClassifier
if model.WhichOneof('ClassLabels') == 'stringClassLabels':
attrs['classlabels_strings'] = list(s.encode('utf-8') for s in model.stringClassLabels.vector)
elif model.WhichOneof('ClassLabels') == 'int64ClassLabels':
attrs['classlabels_int64s'] = list(int(i) for i in model.int64ClassLabels.vector)
else:
raise ValueError('Unknown label type found')
elif model_type == 'pipelineClassifier':
model = operator.raw_operator.pipelineClassifier
if model.WhichOneof('ClassLabels') == 'stringClassLabels':
attrs['classlabels_strings'] = list(s.encode('utf-8') for s in model.stringClassLabels.vector)
elif model.WhichOneof('ClassLabels') == 'int64ClassLabels':
attrs['classlabels_int64s'] = list(int(i) for i in model.int64ClassLabels.vector)
else:
raise ValueError('Unknown label type found')
else:
raise TypeError('Only neural network classifiers and pipeline classifiers are supported')
input_shape = operator.inputs[0].type.shape
if len(operator.inputs[0].type.shape) != 2:
if input_shape[0] != 'None':
N = input_shape[0]
else:
N = -1
if all(isinstance(i, numbers.Integral) for i in input_shape[1:]):
C = 1
for i in input_shape[1:]:
C *= int(i)
else:
C = -1
buffer_name = scope.get_unique_variable_name('buffer')
apply_reshape(scope, operator.inputs[0].full_name, buffer_name, container, desired_shape=[N, C])
else:
buffer_name = operator.inputs[0].full_name
container.add_node('ZipMap', buffer_name, operator.outputs[0].full_name,
op_domain='ai.onnx.ml', **attrs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:group_and_sort_nodes; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, if_statement; 6, 7; 6, 15; 6, 143; 6, 189; 7, boolean_operator:and; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:node_grouping; 11, not_operator; 11, 12; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:node_order; 15, block; 15, 16; 16, if_statement; 16, 17; 16, 22; 16, 59; 17, comparison_operator:==; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:group_order; 21, string:"alphabetically"; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:nodes; 28, list_comprehension; 28, 29; 28, 30; 29, identifier:n; 30, for_in_clause; 30, 31; 30, 34; 31, pattern_list; 31, 32; 31, 33; 32, identifier:n; 33, identifier:d; 34, call; 34, 35; 34, 36; 35, identifier:sorted; 36, argument_list; 36, 37; 36, 47; 37, call; 37, 38; 37, 43; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:graph; 42, identifier:nodes; 43, argument_list; 43, 44; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:data; 46, True; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:key; 49, lambda; 49, 50; 49, 52; 50, lambda_parameters; 50, 51; 51, identifier:x; 52, subscript; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:x; 55, integer:1; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:node_grouping; 59, elif_clause; 59, 60; 59, 65; 60, comparison_operator:==; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:group_order; 64, string:"default"; 65, block; 65, 66; 65, 89; 65, 99; 65, 103; 65, 137; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:grp; 69, list_comprehension; 69, 70; 69, 75; 70, subscript; 70, 71; 70, 72; 71, identifier:d; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:node_grouping; 75, for_in_clause; 75, 76; 75, 79; 76, pattern_list; 76, 77; 76, 78; 77, identifier:_; 78, identifier:d; 79, call; 79, 80; 79, 85; 80, attribute; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:graph; 84, identifier:nodes; 85, argument_list; 85, 86; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:data; 88, True; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:grp_name; 92, call; 92, 93; 92, 94; 93, identifier:list; 94, argument_list; 94, 95; 95, call; 95, 96; 95, 97; 96, identifier:unique_everseen; 97, argument_list; 97, 98; 98, identifier:grp; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:nodes; 102, list:[]; 103, for_statement; 103, 104; 103, 105; 103, 106; 104, identifier:key; 105, identifier:grp_name; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:nodes; 111, identifier:extend; 112, argument_list; 112, 113; 113, list_comprehension; 113, 114; 113, 115; 113, 129; 114, identifier:n; 115, for_in_clause; 115, 116; 115, 119; 116, pattern_list; 116, 117; 116, 118; 117, identifier:n; 118, identifier:d; 119, call; 119, 120; 119, 125; 120, attribute; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:graph; 124, identifier:nodes; 125, argument_list; 125, 126; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:data; 128, True; 129, if_clause; 129, 130; 130, comparison_operator:in; 130, 131; 130, 132; 131, identifier:key; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:d; 135, identifier:values; 136, argument_list; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:nodes; 142, identifier:nodes; 143, elif_clause; 143, 144; 143, 152; 144, boolean_operator:and; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:node_order; 148, not_operator; 148, 149; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:node_grouping; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:nodes; 158, list_comprehension; 158, 159; 158, 160; 159, identifier:n; 160, for_in_clause; 160, 161; 160, 164; 161, pattern_list; 161, 162; 161, 163; 162, identifier:n; 163, identifier:_; 164, call; 164, 165; 164, 166; 165, identifier:sorted; 166, argument_list; 166, 167; 166, 177; 167, call; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:self; 171, identifier:graph; 172, identifier:nodes; 173, argument_list; 173, 174; 174, keyword_argument; 174, 175; 174, 176; 175, identifier:data; 176, True; 177, keyword_argument; 177, 178; 177, 179; 178, identifier:key; 179, lambda; 179, 180; 179, 182; 180, lambda_parameters; 180, 181; 181, identifier:x; 182, subscript; 182, 183; 182, 186; 183, subscript; 183, 184; 183, 185; 184, identifier:x; 185, integer:1; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:node_order; 189, elif_clause; 189, 190; 189, 197; 190, boolean_operator:and; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:self; 193, identifier:node_grouping; 194, attribute; 194, 195; 194, 196; 195, identifier:self; 196, identifier:node_order; 197, block; 197, 198; 198, if_statement; 198, 199; 198, 204; 198, 249; 199, comparison_operator:==; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:group_order; 203, string:"alphabetically"; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:self; 209, identifier:nodes; 210, list_comprehension; 210, 211; 210, 212; 211, identifier:n; 212, for_in_clause; 212, 213; 212, 216; 213, pattern_list; 213, 214; 213, 215; 214, identifier:n; 215, identifier:d; 216, call; 216, 217; 216, 218; 217, identifier:sorted; 218, argument_list; 218, 219; 218, 229; 219, call; 219, 220; 219, 225; 220, attribute; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:self; 223, identifier:graph; 224, identifier:nodes; 225, argument_list; 225, 226; 226, keyword_argument; 226, 227; 226, 228; 227, identifier:data; 228, True; 229, keyword_argument; 229, 230; 229, 231; 230, identifier:key; 231, lambda; 231, 232; 231, 234; 232, lambda_parameters; 232, 233; 233, identifier:x; 234, tuple; 234, 235; 234, 242; 235, subscript; 235, 236; 235, 239; 236, subscript; 236, 237; 236, 238; 237, identifier:x; 238, integer:1; 239, attribute; 239, 240; 239, 241; 240, identifier:self; 241, identifier:node_grouping; 242, subscript; 242, 243; 242, 246; 243, subscript; 243, 244; 243, 245; 244, identifier:x; 245, integer:1; 246, attribute; 246, 247; 246, 248; 247, identifier:self; 248, identifier:node_order; 249, elif_clause; 249, 250; 249, 255; 250, comparison_operator:==; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:self; 253, identifier:group_order; 254, string:"default"; 255, block; 255, 256; 255, 279; 255, 289; 255, 293; 255, 342; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 258, identifier:grp; 259, list_comprehension; 259, 260; 259, 265; 260, subscript; 260, 261; 260, 262; 261, identifier:d; 262, attribute; 262, 263; 262, 264; 263, identifier:self; 264, identifier:node_grouping; 265, for_in_clause; 265, 266; 265, 269; 266, pattern_list; 266, 267; 266, 268; 267, identifier:_; 268, identifier:d; 269, call; 269, 270; 269, 275; 270, attribute; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:self; 273, identifier:graph; 274, identifier:nodes; 275, argument_list; 275, 276; 276, keyword_argument; 276, 277; 276, 278; 277, identifier:data; 278, True; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:grp_name; 282, call; 282, 283; 282, 284; 283, identifier:list; 284, argument_list; 284, 285; 285, call; 285, 286; 285, 287; 286, identifier:unique_everseen; 287, argument_list; 287, 288; 288, identifier:grp; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 292; 291, identifier:nodes; 292, list:[]; 293, for_statement; 293, 294; 293, 295; 293, 296; 294, identifier:key; 295, identifier:grp_name; 296, block; 296, 297; 297, expression_statement; 297, 298; 298, call; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:nodes; 301, identifier:extend; 302, argument_list; 302, 303; 303, list_comprehension; 303, 304; 303, 305; 303, 334; 304, identifier:n; 305, for_in_clause; 305, 306; 305, 309; 306, pattern_list; 306, 307; 306, 308; 307, identifier:n; 308, identifier:d; 309, call; 309, 310; 309, 311; 310, identifier:sorted; 311, argument_list; 311, 312; 311, 322; 312, call; 312, 313; 312, 318; 313, attribute; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:self; 316, identifier:graph; 317, identifier:nodes; 318, argument_list; 318, 319; 319, keyword_argument; 319, 320; 319, 321; 320, identifier:data; 321, True; 322, keyword_argument; 322, 323; 322, 324; 323, identifier:key; 324, lambda; 324, 325; 324, 327; 325, lambda_parameters; 325, 326; 326, identifier:x; 327, subscript; 327, 328; 327, 331; 328, subscript; 328, 329; 328, 330; 329, identifier:x; 330, integer:1; 331, attribute; 331, 332; 331, 333; 332, identifier:self; 333, identifier:node_order; 334, if_clause; 334, 335; 335, comparison_operator:in; 335, 336; 335, 337; 336, identifier:key; 337, call; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:d; 340, identifier:values; 341, argument_list; 342, expression_statement; 342, 343; 343, assignment; 343, 344; 343, 347; 344, attribute; 344, 345; 344, 346; 345, identifier:self; 346, identifier:nodes; 347, identifier:nodes | def group_and_sort_nodes(self):
if self.node_grouping and not self.node_order:
if self.group_order == "alphabetically":
self.nodes = [
n
for n, d in sorted(
self.graph.nodes(data=True),
key=lambda x: x[1][self.node_grouping],
)
]
elif self.group_order == "default":
grp = [
d[self.node_grouping]
for _, d in self.graph.nodes(data=True)
]
grp_name = list(unique_everseen(grp))
nodes = []
for key in grp_name:
nodes.extend(
[
n
for n, d in self.graph.nodes(data=True)
if key in d.values()
]
)
self.nodes = nodes
elif self.node_order and not self.node_grouping:
self.nodes = [
n
for n, _ in sorted(
self.graph.nodes(data=True),
key=lambda x: x[1][self.node_order],
)
]
elif self.node_grouping and self.node_order:
if self.group_order == "alphabetically":
self.nodes = [
n
for n, d in sorted(
self.graph.nodes(data=True),
key=lambda x: (
x[1][self.node_grouping],
x[1][self.node_order],
),
)
]
elif self.group_order == "default":
grp = [
d[self.node_grouping]
for _, d in self.graph.nodes(data=True)
]
grp_name = list(unique_everseen(grp))
nodes = []
for key in grp_name:
nodes.extend(
[
n
for n, d in sorted(
self.graph.nodes(data=True),
key=lambda x: x[1][self.node_order],
)
if key in d.values()
]
)
self.nodes = nodes |
Subsets and Splits