sequence
stringlengths 546
16.2k
| code
stringlengths 108
19.3k
|
|---|---|
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, 19; 16, 33; 16, 51; 16, 410; 16, 423; 16, 436; 16, 450; 17, expression_statement; 17, 18; 18, comment; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:scores_tips; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:np; 25, identifier:zeros; 26, argument_list; 26, 27; 27, tuple; 27, 28; 27, 32; 28, call; 28, 29; 28, 30; 29, identifier:len; 30, argument_list; 30, 31; 31, identifier:segs; 32, integer:4; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:allindices; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:np; 39, identifier:arange; 40, argument_list; 40, 41; 40, 48; 41, subscript; 41, 42; 41, 47; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_adata; 46, identifier:shape; 47, integer:0; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:dtype; 50, identifier:int; 51, for_statement; 51, 52; 51, 55; 51, 59; 51, 60; 52, pattern_list; 52, 53; 52, 54; 53, identifier:iseg; 54, identifier:seg; 55, call; 55, 56; 55, 57; 56, identifier:enumerate; 57, argument_list; 57, 58; 58, identifier:segs; 59, comment; 60, block; 60, 61; 60, 72; 60, 73; 60, 110; 60, 114; 60, 186; 60, 187; 60, 210; 60, 211; 60, 212; 60, 226; 60, 240; 60, 241; 60, 242; 60, 251; 60, 305; 60, 315; 60, 316; 60, 317; 60, 318; 60, 319; 60, 320; 60, 337; 60, 349; 60, 350; 60, 379; 60, 393; 60, 394; 60, 401; 61, if_statement; 61, 62; 61, 70; 62, comparison_operator:==; 62, 63; 62, 68; 63, subscript; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:segs_tips; 66, identifier:iseg; 67, integer:0; 68, unary_operator:-; 68, 69; 69, integer:1; 70, block; 70, 71; 71, continue_statement; 72, comment; 73, if_statement; 73, 74; 73, 82; 73, 97; 74, not_operator; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:isinstance; 77, argument_list; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:distances_dpt; 81, identifier:OnFlySymMatrix; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:Dseg; 86, subscript; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:distances_dpt; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:np; 93, identifier:ix_; 94, argument_list; 94, 95; 94, 96; 95, identifier:seg; 96, identifier:seg; 97, else_clause; 97, 98; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:Dseg; 102, call; 102, 103; 102, 108; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:distances_dpt; 107, identifier:restrict; 108, argument_list; 108, 109; 109, identifier:seg; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:third_maximizer; 113, None; 114, if_statement; 114, 115; 114, 118; 114, 119; 114, 120; 115, subscript; 115, 116; 115, 117; 116, identifier:segs_undecided; 117, identifier:iseg; 118, comment; 119, comment; 120, block; 120, 121; 121, for_statement; 121, 122; 121, 123; 121, 130; 122, identifier:jseg; 123, call; 123, 124; 123, 125; 124, identifier:range; 125, argument_list; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:len; 128, argument_list; 128, 129; 129, identifier:segs; 130, block; 130, 131; 131, if_statement; 131, 132; 131, 135; 131, 136; 132, comparison_operator:!=; 132, 133; 132, 134; 133, identifier:jseg; 134, identifier:iseg; 135, comment; 136, block; 136, 137; 137, for_statement; 137, 138; 137, 139; 137, 143; 138, identifier:itip; 139, call; 139, 140; 139, 141; 140, identifier:range; 141, argument_list; 141, 142; 142, integer:2; 143, block; 143, 144; 144, if_statement; 144, 145; 144, 178; 144, 179; 144, 180; 144, 181; 145, parenthesized_expression; 145, 146; 146, comparison_operator:<; 146, 147; 146, 161; 147, subscript; 147, 148; 147, 151; 147, 156; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:distances_dpt; 151, subscript; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:segs_tips; 154, identifier:jseg; 155, integer:1; 156, subscript; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:segs_tips; 159, identifier:iseg; 160, identifier:itip; 161, binary_operator:*; 161, 162; 161, 163; 162, float:0.5; 163, subscript; 163, 164; 163, 167; 163, 173; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:distances_dpt; 167, subscript; 167, 168; 167, 171; 168, subscript; 168, 169; 168, 170; 169, identifier:segs_tips; 170, identifier:iseg; 171, unary_operator:~; 171, 172; 172, identifier:itip; 173, subscript; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:segs_tips; 176, identifier:iseg; 177, identifier:itip; 178, comment; 179, comment; 180, comment; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:third_maximizer; 185, identifier:itip; 186, comment; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:tips; 190, list_comprehension; 190, 191; 190, 205; 191, subscript; 191, 192; 191, 204; 192, subscript; 192, 193; 192, 203; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:np; 196, identifier:where; 197, argument_list; 197, 198; 198, comparison_operator:==; 198, 199; 198, 202; 199, subscript; 199, 200; 199, 201; 200, identifier:allindices; 201, identifier:seg; 202, identifier:tip; 203, integer:0; 204, integer:0; 205, for_in_clause; 205, 206; 205, 207; 206, identifier:tip; 207, subscript; 207, 208; 207, 209; 208, identifier:segs_tips; 209, identifier:iseg; 210, comment; 211, comment; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:dseg; 215, binary_operator:+; 215, 216; 215, 221; 216, subscript; 216, 217; 216, 218; 217, identifier:Dseg; 218, subscript; 218, 219; 218, 220; 219, identifier:tips; 220, integer:0; 221, subscript; 221, 222; 221, 223; 222, identifier:Dseg; 223, subscript; 223, 224; 223, 225; 224, identifier:tips; 225, integer:1; 226, if_statement; 226, 227; 226, 238; 227, not_operator; 227, 228; 228, call; 228, 229; 228, 237; 229, attribute; 229, 230; 229, 236; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:np; 233, identifier:isfinite; 234, argument_list; 234, 235; 235, identifier:dseg; 236, identifier:any; 237, argument_list; 238, block; 238, 239; 239, continue_statement; 240, comment; 241, comment; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:third_tip; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:np; 248, identifier:argmax; 249, argument_list; 249, 250; 250, identifier:dseg; 251, if_statement; 251, 252; 251, 255; 251, 256; 252, comparison_operator:is; 252, 253; 252, 254; 253, identifier:third_maximizer; 254, None; 255, comment; 256, block; 256, 257; 256, 263; 256, 272; 257, expression_statement; 257, 258; 258, augmented_assignment:+=; 258, 259; 258, 260; 259, identifier:dseg; 260, subscript; 260, 261; 260, 262; 261, identifier:Dseg; 262, identifier:third_tip; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 266; 265, identifier:fourth_tip; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:np; 269, identifier:argmax; 270, argument_list; 270, 271; 271, identifier:dseg; 272, if_statement; 272, 273; 272, 282; 272, 297; 273, boolean_operator:and; 273, 274; 273, 279; 274, comparison_operator:!=; 274, 275; 274, 276; 275, identifier:fourth_tip; 276, subscript; 276, 277; 276, 278; 277, identifier:tips; 278, integer:0; 279, comparison_operator:!=; 279, 280; 279, 281; 280, identifier:fourth_tip; 281, identifier:third_tip; 282, block; 282, 283; 282, 289; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 288; 285, subscript; 285, 286; 285, 287; 286, identifier:tips; 287, integer:1; 288, identifier:fourth_tip; 289, expression_statement; 289, 290; 290, augmented_assignment:-=; 290, 291; 290, 292; 291, identifier:dseg; 292, subscript; 292, 293; 292, 294; 293, identifier:Dseg; 294, subscript; 294, 295; 294, 296; 295, identifier:tips; 296, integer:1; 297, else_clause; 297, 298; 298, block; 298, 299; 299, expression_statement; 299, 300; 300, augmented_assignment:-=; 300, 301; 300, 302; 301, identifier:dseg; 302, subscript; 302, 303; 302, 304; 303, identifier:Dseg; 304, identifier:third_tip; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:tips3; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:np; 311, identifier:append; 312, argument_list; 312, 313; 312, 314; 313, identifier:tips; 314, identifier:third_tip; 315, comment; 316, comment; 317, comment; 318, comment; 319, comment; 320, expression_statement; 320, 321; 321, assignment; 321, 322; 321, 323; 322, identifier:score; 323, binary_operator:/; 323, 324; 323, 329; 324, subscript; 324, 325; 324, 326; 325, identifier:dseg; 326, subscript; 326, 327; 326, 328; 327, identifier:tips3; 328, integer:2; 329, subscript; 329, 330; 329, 331; 329, 334; 330, identifier:Dseg; 331, subscript; 331, 332; 331, 333; 332, identifier:tips3; 333, integer:0; 334, subscript; 334, 335; 334, 336; 335, identifier:tips3; 336, integer:1; 337, expression_statement; 337, 338; 338, assignment; 338, 339; 338, 340; 339, identifier:score; 340, conditional_expression:if; 340, 341; 340, 345; 340, 348; 341, call; 341, 342; 341, 343; 342, identifier:len; 343, argument_list; 343, 344; 344, identifier:seg; 345, attribute; 345, 346; 345, 347; 346, identifier:self; 347, identifier:choose_largest_segment; 348, identifier:score; 349, comment; 350, expression_statement; 350, 351; 351, call; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:logg; 354, identifier:m; 355, argument_list; 355, 356; 355, 357; 355, 358; 355, 359; 355, 360; 355, 361; 355, 365; 355, 376; 356, string:' group'; 357, identifier:iseg; 358, string:'score'; 359, identifier:score; 360, string:'n_points'; 361, call; 361, 362; 361, 363; 362, identifier:len; 363, argument_list; 363, 364; 364, identifier:seg; 365, conditional_expression:if; 365, 366; 365, 367; 365, 375; 366, string:'(too small)'; 367, comparison_operator:<; 367, 368; 367, 372; 368, call; 368, 369; 368, 370; 369, identifier:len; 370, argument_list; 370, 371; 371, identifier:seg; 372, attribute; 372, 373; 372, 374; 373, identifier:self; 374, identifier:min_group_size; 375, string:''; 376, keyword_argument; 376, 377; 376, 378; 377, identifier:v; 378, integer:4; 379, if_statement; 379, 380; 379, 388; 380, comparison_operator:<=; 380, 381; 380, 385; 381, call; 381, 382; 381, 383; 382, identifier:len; 383, argument_list; 383, 384; 384, identifier:seg; 385, attribute; 385, 386; 385, 387; 386, identifier:self; 387, identifier:min_group_size; 388, block; 388, 389; 389, expression_statement; 389, 390; 390, assignment; 390, 391; 390, 392; 391, identifier:score; 392, integer:0; 393, comment; 394, expression_statement; 394, 395; 395, assignment; 395, 396; 395, 400; 396, subscript; 396, 397; 396, 398; 396, 399; 397, identifier:scores_tips; 398, identifier:iseg; 399, integer:0; 400, identifier:score; 401, expression_statement; 401, 402; 402, assignment; 402, 403; 402, 409; 403, subscript; 403, 404; 403, 405; 403, 406; 404, identifier:scores_tips; 405, identifier:iseg; 406, slice; 406, 407; 406, 408; 407, integer:1; 408, colon; 409, identifier:tips3; 410, expression_statement; 410, 411; 411, assignment; 411, 412; 411, 413; 412, identifier:iseg; 413, call; 413, 414; 413, 417; 414, attribute; 414, 415; 414, 416; 415, identifier:np; 416, identifier:argmax; 417, argument_list; 417, 418; 418, subscript; 418, 419; 418, 420; 418, 422; 419, identifier:scores_tips; 420, slice; 420, 421; 421, colon; 422, integer:0; 423, if_statement; 423, 424; 423, 430; 424, comparison_operator:==; 424, 425; 424, 429; 425, subscript; 425, 426; 425, 427; 425, 428; 426, identifier:scores_tips; 427, identifier:iseg; 428, integer:0; 429, integer:0; 430, block; 430, 431; 431, return_statement; 431, 432; 432, expression_list; 432, 433; 432, 435; 433, unary_operator:-; 433, 434; 434, integer:1; 435, None; 436, expression_statement; 436, 437; 437, assignment; 437, 438; 437, 439; 438, identifier:tips3; 439, call; 439, 440; 439, 448; 440, attribute; 440, 441; 440, 447; 441, subscript; 441, 442; 441, 443; 441, 444; 442, identifier:scores_tips; 443, identifier:iseg; 444, slice; 444, 445; 444, 446; 445, integer:1; 446, colon; 447, identifier:astype; 448, argument_list; 448, 449; 449, identifier:int; 450, return_statement; 450, 451; 451, expression_list; 451, 452; 451, 453; 452, identifier:iseg; 453, identifier:tips3 | def select_segment(self, segs, segs_tips, segs_undecided) -> Tuple[int, int]:
"""Out of a list of line segments, choose segment that has the most
distant second data point.
Assume the distance matrix Ddiff is sorted according to seg_idcs.
Compute all the distances.
Returns
-------
iseg : int
Index identifying the position within the list of line segments.
tips3 : int
Positions of tips within chosen segment.
"""
scores_tips = np.zeros((len(segs), 4))
allindices = np.arange(self._adata.shape[0], dtype=int)
for iseg, seg in enumerate(segs):
# do not consider too small segments
if segs_tips[iseg][0] == -1: continue
# restrict distance matrix to points in segment
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]:
# check that none of our tips "connects" with a tip of the
# other segments
for jseg in range(len(segs)):
if jseg != iseg:
# take the inner tip, the "second tip" of the segment
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]]):
# logg.m(' group', iseg, 'with tip', segs_tips[iseg][itip],
# 'connects with', jseg, 'with tip', segs_tips[jseg][1], v=4)
# logg.m(' do not use the tip for "triangulation"', v=4)
third_maximizer = itip
# map the global position to the position within the segment
tips = [np.where(allindices[seg] == tip)[0][0]
for tip in segs_tips[iseg]]
# find the third point on the segment that has maximal
# added distance from the two tip points
dseg = Dseg[tips[0]] + Dseg[tips[1]]
if not np.isfinite(dseg).any():
continue
# add this point to tips, it's a third tip, we store it at the first
# position in an array called tips3
third_tip = np.argmax(dseg)
if third_maximizer is not None:
# find a fourth point that has maximal distance to all three
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)
# compute the score as ratio of the added distance to the third tip,
# to what it would be if it were on the straight line between the
# two first tips, given by Dseg[tips[:2]]
# if we did not normalize, there would be a danger of simply
# assigning the highest score to the longest segment
score = dseg[tips3[2]] / Dseg[tips3[0], tips3[1]]
score = len(seg) if self.choose_largest_segment else score # simply the number of points
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
# write result
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, 8; 5, 17; 5, 34; 5, 56; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:categories; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:np; 14, identifier:unique; 15, argument_list; 15, 16; 16, identifier:categories; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:categories; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:np; 23, identifier:setdiff1d; 24, argument_list; 24, 25; 24, 26; 25, identifier:categories; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:np; 29, identifier:array; 30, argument_list; 30, 31; 31, attribute; 31, 32; 31, 33; 32, identifier:settings; 33, identifier:categories_to_ignore; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:categories; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:np; 40, identifier:array; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:natsorted; 44, argument_list; 44, 45; 44, 46; 45, identifier:categories; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:key; 48, lambda; 48, 49; 48, 51; 49, lambda_parameters; 49, 50; 50, identifier:v; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:v; 54, identifier:upper; 55, argument_list; 56, return_statement; 56, 57; 57, identifier:categories | def unique_categories(categories):
"""Pass array-like categories, return sorted cleaned unique 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, 20; 17, 26; 18, expression_statement; 18, 19; 19, comment; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 25; 22, subscript; 22, 23; 22, 24; 23, identifier:kwargs; 24, string:'remove'; 25, True; 26, return_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:__find_and_modify; 31, argument_list; 31, 32; 31, 33; 31, 34; 31, 35; 31, 38; 32, identifier:filter; 33, identifier:projection; 34, identifier:sort; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:session; 37, identifier:session; 38, dictionary_splat; 38, 39; 39, identifier:kwargs | def find_one_and_delete(self, filter,
projection=None, sort=None, session=None, **kwargs):
"""Finds a single document and deletes it, returning the document.
>>> db.test.count_documents({'x': 1})
2
>>> db.test.find_one_and_delete({'x': 1})
{u'x': 1, u'_id': ObjectId('54f4e12bfba5220aa4d6dee8')}
>>> db.test.count_documents({'x': 1})
1
If multiple documents match *filter*, a *sort* can be applied.
>>> for doc in db.test.find({'x': 1}):
... print(doc)
...
{u'x': 1, u'_id': 0}
{u'x': 1, u'_id': 1}
{u'x': 1, u'_id': 2}
>>> db.test.find_one_and_delete(
... {'x': 1}, sort=[('_id', pymongo.DESCENDING)])
{u'x': 1, u'_id': 2}
The *projection* option can be used to limit the fields returned.
>>> db.test.find_one_and_delete({'x': 1}, projection={'_id': False})
{u'x': 1}
:Parameters:
- `filter`: A query that matches the document to delete.
- `projection` (optional): a list of field names that should be
returned in the result document or a mapping specifying the fields
to include or exclude. If `projection` is a list "_id" will
always be returned. Use a mapping to exclude fields from
the result (e.g. projection={'_id': False}).
- `sort` (optional): a list of (key, direction) pairs
specifying the sort order for the query. If multiple documents
match the query, they are sorted and the first is deleted.
- `session` (optional): a
:class:`~pymongo.client_session.ClientSession`.
- `**kwargs` (optional): additional command arguments can be passed
as keyword arguments (for example maxTimeMS can be used with
recent server versions).
.. versionchanged:: 3.6
Added ``session`` parameter.
.. versionchanged:: 3.2
Respects write concern.
.. warning:: Starting in PyMongo 3.2, this command uses the
:class:`~pymongo.write_concern.WriteConcern` of this
:class:`~pymongo.collection.Collection` when connected to MongoDB >=
3.2. Note that using an elevated write concern with this command may
be slower compared to using the default write concern.
.. versionchanged:: 3.4
Added the `collation` option.
.. versionadded:: 3.0
"""
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; 1, 6; 2, function_name:sort; 3, parameters; 3, 4; 4, identifier:lines; 5, comment; 6, block; 6, 7; 6, 9; 6, 10; 6, 17; 6, 27; 6, 57; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:lines; 13, call; 13, 14; 13, 15; 14, identifier:list; 15, argument_list; 15, 16; 16, identifier:lines; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:new_lines; 20, call; 20, 21; 20, 22; 21, identifier:parse_block; 22, argument_list; 22, 23; 22, 24; 23, identifier:lines; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:header; 26, True; 27, for_statement; 27, 28; 27, 29; 27, 39; 28, identifier:block; 29, call; 29, 30; 29, 31; 30, identifier:sorted; 31, argument_list; 31, 32; 31, 36; 32, call; 32, 33; 32, 34; 33, identifier:parse_blocks; 34, argument_list; 34, 35; 35, identifier:lines; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:key; 38, identifier:first_key; 39, block; 39, 40; 39, 50; 40, if_statement; 40, 41; 40, 42; 41, identifier:new_lines; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:new_lines; 47, identifier:append; 48, argument_list; 48, 49; 49, string:''; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:new_lines; 54, identifier:extend; 55, argument_list; 55, 56; 56, identifier:block; 57, return_statement; 57, 58; 58, identifier:new_lines | def sort(lines): # type: (List[str]) -> List[str]
"""Sort a YAML file in alphabetical order, keeping blocks together.
:param lines: array of strings (without newlines)
:return: sorted array of strings
"""
# make a copy of lines since we will clobber it
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; 1, 6; 2, function_name:first_key; 3, parameters; 3, 4; 4, identifier:lines; 5, comment; 6, block; 6, 7; 6, 9; 7, expression_statement; 7, 8; 8, comment; 9, for_statement; 9, 10; 9, 11; 9, 12; 9, 44; 10, identifier:line; 11, identifier:lines; 12, block; 12, 13; 12, 22; 12, 42; 13, if_statement; 13, 14; 13, 20; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:line; 17, identifier:startswith; 18, argument_list; 18, 19; 19, string:'#'; 20, block; 20, 21; 21, continue_statement; 22, if_statement; 22, 23; 22, 35; 23, call; 23, 24; 23, 25; 24, identifier:any; 25, generator_expression; 25, 26; 25, 32; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:line; 29, identifier:startswith; 30, argument_list; 30, 31; 31, identifier:quote; 32, for_in_clause; 32, 33; 32, 34; 33, identifier:quote; 34, identifier:QUOTES; 35, block; 35, 36; 36, return_statement; 36, 37; 37, subscript; 37, 38; 37, 39; 38, identifier:line; 39, slice; 39, 40; 39, 41; 40, integer:1; 41, colon; 42, return_statement; 42, 43; 43, identifier:line; 44, else_clause; 44, 45; 45, block; 45, 46; 46, return_statement; 46, 47; 47, string:'' | def first_key(lines): # type: (List[str]) -> str
"""Returns a string representing the sort key of a block.
The sort key is the first YAML key we encounter, ignoring comments, and
stripping leading quotes.
>>> print(test)
# some comment
'foo': true
>>> first_key(test)
'foo'
"""
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; 13, 16; 14, expression_statement; 14, 15; 15, comment; 16, return_statement; 16, 17; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:execute; 21, argument_list; 21, 22; 21, 23; 21, 24; 21, 25; 21, 26; 21, 27; 21, 29; 22, string:b'GEOADD'; 23, identifier:key; 24, identifier:longitude; 25, identifier:latitude; 26, identifier:member; 27, list_splat; 27, 28; 28, identifier:args; 29, dictionary_splat; 29, 30; 30, identifier:kwargs | def geoadd(self, key, longitude, latitude, member, *args, **kwargs):
"""Add one or more geospatial items in the geospatial index represented
using a sorted set.
:rtype: int
"""
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, 34; 31, 47; 31, 66; 31, 88; 32, expression_statement; 32, 33; 33, comment; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:args; 37, call; 37, 38; 37, 39; 38, identifier:validate_georadius_options; 39, argument_list; 39, 40; 39, 41; 39, 42; 39, 43; 39, 44; 39, 45; 39, 46; 40, identifier:radius; 41, identifier:unit; 42, identifier:with_dist; 43, identifier:with_hash; 44, identifier:with_coord; 45, identifier:count; 46, identifier:sort; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:fut; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:execute; 54, argument_list; 54, 55; 54, 56; 54, 57; 54, 58; 54, 59; 54, 60; 54, 61; 54, 63; 55, string:b'GEORADIUS'; 56, identifier:key; 57, identifier:longitude; 58, identifier:latitude; 59, identifier:radius; 60, identifier:unit; 61, list_splat; 61, 62; 62, identifier:args; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:encoding; 65, identifier:encoding; 66, if_statement; 66, 67; 66, 72; 67, boolean_operator:or; 67, 68; 67, 71; 68, boolean_operator:or; 68, 69; 68, 70; 69, identifier:with_dist; 70, identifier:with_hash; 71, identifier:with_coord; 72, block; 72, 73; 73, return_statement; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:wait_convert; 76, argument_list; 76, 77; 76, 78; 76, 79; 76, 82; 76, 85; 77, identifier:fut; 78, identifier:make_geomember; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:with_dist; 81, identifier:with_dist; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:with_hash; 84, identifier:with_hash; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:with_coord; 87, identifier:with_coord; 88, return_statement; 88, 89; 89, 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):
"""Query a sorted set representing a geospatial index to fetch members
matching a given maximum distance from a point.
Return value follows Redis convention:
* if none of ``WITH*`` flags are set -- list of strings returned:
>>> await redis.georadius('Sicily', 15, 37, 200, 'km')
[b"Palermo", b"Catania"]
* if any flag (or all) is set -- list of named tuples returned:
>>> await redis.georadius('Sicily', 15, 37, 200, 'km',
... with_dist=True)
[GeoMember(name=b"Palermo", dist=190.4424, hash=None, coord=None),
GeoMember(name=b"Catania", dist=56.4413, hash=None, coord=None)]
:raises TypeError: radius is not float or int
:raises TypeError: count is not int
:raises ValueError: if unit not equal ``m``, ``km``, ``mi`` or ``ft``
:raises ValueError: if sort not equal ``ASC`` or ``DESC``
:rtype: list[str] or list[GeoMember]
"""
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, 33; 30, 46; 30, 64; 30, 86; 31, expression_statement; 31, 32; 32, comment; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:args; 36, call; 36, 37; 36, 38; 37, identifier:validate_georadius_options; 38, argument_list; 38, 39; 38, 40; 38, 41; 38, 42; 38, 43; 38, 44; 38, 45; 39, identifier:radius; 40, identifier:unit; 41, identifier:with_dist; 42, identifier:with_hash; 43, identifier:with_coord; 44, identifier:count; 45, identifier:sort; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:fut; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:execute; 53, argument_list; 53, 54; 53, 55; 53, 56; 53, 57; 53, 58; 53, 59; 53, 61; 54, string:b'GEORADIUSBYMEMBER'; 55, identifier:key; 56, identifier:member; 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 georadiusbymember(self, key, member, radius, unit='m', *,
with_dist=False, with_hash=False, with_coord=False,
count=None, sort=None, encoding=_NOTSET):
"""Query a sorted set representing a geospatial index to fetch members
matching a given maximum distance from a member.
Return value follows Redis convention:
* if none of ``WITH*`` flags are set -- list of strings returned:
>>> await redis.georadiusbymember('Sicily', 'Palermo', 200, 'km')
[b"Palermo", b"Catania"]
* if any flag (or all) is set -- list of named tuples returned:
>>> await redis.georadiusbymember('Sicily', 'Palermo', 200, 'km',
... with_dist=True)
[GeoMember(name=b"Palermo", dist=190.4424, hash=None, coord=None),
GeoMember(name=b"Catania", dist=56.4413, hash=None, coord=None)]
:raises TypeError: radius is not float or int
:raises TypeError: count is not int
:raises ValueError: if unit not equal ``m``, ``km``, ``mi`` or ``ft``
:raises ValueError: if sort not equal ``ASC`` or ``DESC``
:rtype: list[str] or list[GeoMember]
"""
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, 29; 26, 33; 26, 44; 26, 60; 26, 77; 26, 93; 26, 101; 26, 112; 27, expression_statement; 27, 28; 28, comment; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:args; 32, list:[]; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:by; 36, None; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, augmented_assignment:+=; 39, 40; 39, 41; 40, identifier:args; 41, list:[b'BY', by]; 41, 42; 41, 43; 42, string:b'BY'; 43, identifier:by; 44, if_statement; 44, 45; 44, 52; 45, boolean_operator:and; 45, 46; 45, 49; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:offset; 48, None; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:count; 51, None; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, augmented_assignment:+=; 54, 55; 54, 56; 55, identifier:args; 56, list:[b'LIMIT', offset, count]; 56, 57; 56, 58; 56, 59; 57, string:b'LIMIT'; 58, identifier:offset; 59, identifier:count; 60, if_statement; 60, 61; 60, 62; 61, identifier:get_patterns; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, augmented_assignment:+=; 64, 65; 64, 66; 65, identifier:args; 66, call; 66, 67; 66, 68; 67, identifier:sum; 68, argument_list; 68, 69; 68, 76; 69, generator_expression; 69, 70; 69, 73; 70, list:[b'GET', pattern]; 70, 71; 70, 72; 71, string:b'GET'; 72, identifier:pattern; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:pattern; 75, identifier:get_patterns; 76, list:[]; 77, if_statement; 77, 78; 77, 81; 78, comparison_operator:is; 78, 79; 78, 80; 79, identifier:asc; 80, None; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, augmented_assignment:+=; 83, 84; 83, 85; 84, identifier:args; 85, list:[asc is True and b'ASC' or b'DESC']; 85, 86; 86, boolean_operator:or; 86, 87; 86, 92; 87, boolean_operator:and; 87, 88; 87, 91; 88, comparison_operator:is; 88, 89; 88, 90; 89, identifier:asc; 90, True; 91, string:b'ASC'; 92, string:b'DESC'; 93, if_statement; 93, 94; 93, 95; 94, identifier:alpha; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, augmented_assignment:+=; 97, 98; 97, 99; 98, identifier:args; 99, list:[b'ALPHA']; 99, 100; 100, string:b'ALPHA'; 101, if_statement; 101, 102; 101, 105; 102, comparison_operator:is; 102, 103; 102, 104; 103, identifier:store; 104, None; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, augmented_assignment:+=; 107, 108; 107, 109; 108, identifier:args; 109, list:[b'STORE', store]; 109, 110; 109, 111; 110, string:b'STORE'; 111, identifier:store; 112, return_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:execute; 117, argument_list; 117, 118; 117, 119; 117, 120; 118, string:b'SORT'; 119, identifier:key; 120, list_splat; 120, 121; 121, identifier:args | def sort(self, key, *get_patterns,
by=None, offset=None, count=None,
asc=None, alpha=False, store=None):
"""Sort the elements in a list, set or sorted set."""
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, 16; 13, 31; 13, 46; 13, 65; 13, 86; 13, 90; 13, 118; 13, 127; 13, 137; 14, expression_statement; 14, 15; 15, comment; 16, if_statement; 16, 17; 16, 25; 17, not_operator; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:isinstance; 20, argument_list; 20, 21; 20, 22; 21, identifier:score; 22, tuple; 22, 23; 22, 24; 23, identifier:int; 24, identifier:float; 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:"score argument must be int or float"; 31, if_statement; 31, 32; 31, 40; 32, comparison_operator:!=; 32, 33; 32, 39; 33, binary_operator:%; 33, 34; 33, 38; 34, call; 34, 35; 34, 36; 35, identifier:len; 36, argument_list; 36, 37; 37, identifier:pairs; 38, integer:2; 39, integer:0; 40, block; 40, 41; 41, raise_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:TypeError; 44, argument_list; 44, 45; 45, string:"length of pairs must be even number"; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:scores; 49, generator_expression; 49, 50; 49, 51; 49, 59; 50, identifier:item; 51, for_in_clause; 51, 52; 51, 55; 52, pattern_list; 52, 53; 52, 54; 53, identifier:i; 54, identifier:item; 55, call; 55, 56; 55, 57; 56, identifier:enumerate; 57, argument_list; 57, 58; 58, identifier:pairs; 59, if_clause; 59, 60; 60, comparison_operator:==; 60, 61; 60, 64; 61, binary_operator:%; 61, 62; 61, 63; 62, identifier:i; 63, integer:2; 64, integer:0; 65, if_statement; 65, 66; 65, 80; 66, call; 66, 67; 66, 68; 67, identifier:any; 68, generator_expression; 68, 69; 68, 77; 69, not_operator; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:isinstance; 72, argument_list; 72, 73; 72, 74; 73, identifier:s; 74, tuple; 74, 75; 74, 76; 75, identifier:int; 76, identifier:float; 77, for_in_clause; 77, 78; 77, 79; 78, identifier:s; 79, identifier:scores; 80, block; 80, 81; 81, raise_statement; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:TypeError; 84, argument_list; 84, 85; 85, string:"all scores must be int or float"; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:args; 89, list:[]; 90, if_statement; 90, 91; 90, 96; 90, 104; 91, comparison_operator:is; 91, 92; 91, 93; 92, identifier:exist; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:ZSET_IF_EXIST; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:args; 101, identifier:append; 102, argument_list; 102, 103; 103, string:b'XX'; 104, elif_clause; 104, 105; 104, 110; 105, comparison_operator:is; 105, 106; 105, 107; 106, identifier:exist; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:ZSET_IF_NOT_EXIST; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:args; 115, identifier:append; 116, argument_list; 116, 117; 117, string:b'NX'; 118, expression_statement; 118, 119; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:args; 122, identifier:extend; 123, argument_list; 123, 124; 124, list:[score, member]; 124, 125; 124, 126; 125, identifier:score; 126, identifier:member; 127, if_statement; 127, 128; 127, 129; 128, identifier:pairs; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:args; 134, identifier:extend; 135, argument_list; 135, 136; 136, identifier:pairs; 137, return_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:execute; 142, argument_list; 142, 143; 142, 144; 142, 145; 143, string:b'ZADD'; 144, identifier:key; 145, list_splat; 145, 146; 146, identifier:args | def zadd(self, key, score, member, *pairs, exist=None):
"""Add one or more members to a sorted set or update its score.
:raises TypeError: score not int or float
:raises TypeError: length of pairs is not even number
"""
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, 25; 22, 40; 22, 55; 22, 65; 23, expression_statement; 23, 24; 24, comment; 25, if_statement; 25, 26; 25, 34; 26, not_operator; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:isinstance; 29, argument_list; 29, 30; 29, 31; 30, identifier:min; 31, tuple; 31, 32; 31, 33; 32, identifier:int; 33, identifier:float; 34, block; 34, 35; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:TypeError; 38, argument_list; 38, 39; 39, string:"min argument must be int or float"; 40, if_statement; 40, 41; 40, 49; 41, not_operator; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:isinstance; 44, argument_list; 44, 45; 44, 46; 45, identifier:max; 46, tuple; 46, 47; 46, 48; 47, identifier:int; 48, identifier:float; 49, block; 49, 50; 50, raise_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:TypeError; 53, argument_list; 53, 54; 54, string:"max argument must be int or float"; 55, if_statement; 55, 56; 55, 59; 56, comparison_operator:>; 56, 57; 56, 58; 57, identifier:min; 58, identifier:max; 59, block; 59, 60; 60, raise_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:ValueError; 63, argument_list; 63, 64; 64, string:"min could not be greater than max"; 65, return_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:execute; 70, argument_list; 70, 71; 70, 72; 70, 73; 71, string:b'ZCOUNT'; 72, identifier:key; 73, list_splat; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:_encode_min_max; 76, argument_list; 76, 77; 76, 78; 76, 79; 77, identifier:exclude; 78, identifier:min; 79, identifier:max | def zcount(self, key, min=float('-inf'), max=float('inf'),
*, exclude=None):
"""Count the members in a sorted set with scores
within the given values.
:raises TypeError: min or max is not float or int
:raises ValueError: if min greater than max
"""
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, 11; 8, 26; 8, 38; 9, expression_statement; 9, 10; 10, comment; 11, if_statement; 11, 12; 11, 20; 12, not_operator; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:isinstance; 15, argument_list; 15, 16; 15, 17; 16, identifier:increment; 17, tuple; 17, 18; 17, 19; 18, identifier:int; 19, identifier:float; 20, block; 20, 21; 21, raise_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:TypeError; 24, argument_list; 24, 25; 25, string:"increment argument must be int or float"; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:fut; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:execute; 33, argument_list; 33, 34; 33, 35; 33, 36; 33, 37; 34, string:b'ZINCRBY'; 35, identifier:key; 36, identifier:increment; 37, identifier:member; 38, return_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:wait_convert; 41, argument_list; 41, 42; 41, 43; 42, identifier:fut; 43, identifier:int_or_float | def zincrby(self, key, increment, member):
"""Increment the score of a member in a sorted set.
:raises TypeError: increment is not float or int
"""
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; 9, 12; 10, expression_statement; 10, 11; 11, comment; 12, return_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:execute; 17, argument_list; 17, 18; 17, 19; 17, 20; 17, 21; 18, string:b'ZREM'; 19, identifier:key; 20, identifier:member; 21, list_splat; 21, 22; 22, identifier:members | def zrem(self, key, member, *members):
"""Remove one or more members from a sorted set."""
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, 21; 18, 35; 18, 49; 18, 65; 18, 81; 19, expression_statement; 19, 20; 20, comment; 21, if_statement; 21, 22; 21, 28; 21, 29; 22, not_operator; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:isinstance; 25, argument_list; 25, 26; 25, 27; 26, identifier:min; 27, identifier:bytes; 28, comment; 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:"min argument must be bytes"; 35, if_statement; 35, 36; 35, 42; 35, 43; 36, not_operator; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:isinstance; 39, argument_list; 39, 40; 39, 41; 40, identifier:max; 41, identifier:bytes; 42, comment; 43, block; 43, 44; 44, raise_statement; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:TypeError; 47, argument_list; 47, 48; 48, string:"max argument must be bytes"; 49, if_statement; 49, 50; 49, 54; 50, not_operator; 50, 51; 51, comparison_operator:==; 51, 52; 51, 53; 52, identifier:min; 53, string:b'-'; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:min; 58, binary_operator:+; 58, 59; 58, 64; 59, parenthesized_expression; 59, 60; 60, conditional_expression:if; 60, 61; 60, 62; 60, 63; 61, string:b'['; 62, identifier:include_min; 63, string:b'('; 64, identifier:min; 65, if_statement; 65, 66; 65, 70; 66, not_operator; 66, 67; 67, comparison_operator:==; 67, 68; 67, 69; 68, identifier:max; 69, string:b'+'; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:max; 74, binary_operator:+; 74, 75; 74, 80; 75, parenthesized_expression; 75, 76; 76, conditional_expression:if; 76, 77; 76, 78; 76, 79; 77, string:b'['; 78, identifier:include_max; 79, string:b'('; 80, identifier:max; 81, return_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:execute; 86, argument_list; 86, 87; 86, 88; 86, 89; 86, 90; 87, string:b'ZREMRANGEBYLEX'; 88, identifier:key; 89, identifier:min; 90, identifier:max | def zremrangebylex(self, key, min=b'-', max=b'+',
include_min=True, include_max=True):
"""Remove all members in a sorted set between the given
lexicographical range.
:raises TypeError: if min is not bytes
:raises TypeError: if max is not bytes
"""
if not isinstance(min, bytes): # FIXME
raise TypeError("min argument must be bytes")
if not isinstance(max, bytes): # FIXME
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, 11; 8, 24; 8, 37; 9, expression_statement; 9, 10; 10, comment; 11, if_statement; 11, 12; 11, 18; 12, not_operator; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:isinstance; 15, argument_list; 15, 16; 15, 17; 16, identifier:start; 17, identifier:int; 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:"start argument must be int"; 24, if_statement; 24, 25; 24, 31; 25, not_operator; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:isinstance; 28, argument_list; 28, 29; 28, 30; 29, identifier:stop; 30, identifier:int; 31, block; 31, 32; 32, raise_statement; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:TypeError; 35, argument_list; 35, 36; 36, string:"stop argument must be int"; 37, return_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:execute; 42, argument_list; 42, 43; 42, 44; 42, 45; 42, 46; 43, string:b'ZREMRANGEBYRANK'; 44, identifier:key; 45, identifier:start; 46, identifier:stop | def zremrangebyrank(self, key, start, stop):
"""Remove all members in a sorted set within the given indexes.
:raises TypeError: if start is not int
:raises TypeError: if stop is not int
"""
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, 25; 22, 40; 22, 55; 22, 66; 23, expression_statement; 23, 24; 24, comment; 25, if_statement; 25, 26; 25, 34; 26, not_operator; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:isinstance; 29, argument_list; 29, 30; 29, 31; 30, identifier:min; 31, tuple; 31, 32; 31, 33; 32, identifier:int; 33, identifier:float; 34, block; 34, 35; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:TypeError; 38, argument_list; 38, 39; 39, string:"min argument must be int or float"; 40, if_statement; 40, 41; 40, 49; 41, not_operator; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:isinstance; 44, argument_list; 44, 45; 44, 46; 45, identifier:max; 46, tuple; 46, 47; 46, 48; 47, identifier:int; 48, identifier:float; 49, block; 49, 50; 50, raise_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:TypeError; 53, argument_list; 53, 54; 54, string:"max argument must be int or float"; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 60; 57, pattern_list; 57, 58; 57, 59; 58, identifier:min; 59, identifier:max; 60, call; 60, 61; 60, 62; 61, identifier:_encode_min_max; 62, argument_list; 62, 63; 62, 64; 62, 65; 63, identifier:exclude; 64, identifier:min; 65, identifier:max; 66, return_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:execute; 71, argument_list; 71, 72; 71, 73; 71, 74; 71, 75; 72, string:b'ZREMRANGEBYSCORE'; 73, identifier:key; 74, identifier:min; 75, identifier:max | def zremrangebyscore(self, key, min=float('-inf'), max=float('inf'),
*, exclude=None):
"""Remove all members in a sorted set within the given scores.
:raises TypeError: if min or max is not int or float
"""
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, 17; 14, 30; 14, 43; 14, 57; 14, 74; 14, 83; 15, expression_statement; 15, 16; 16, comment; 17, if_statement; 17, 18; 17, 24; 18, not_operator; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:isinstance; 21, argument_list; 21, 22; 21, 23; 22, identifier:start; 23, identifier:int; 24, block; 24, 25; 25, raise_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:TypeError; 28, argument_list; 28, 29; 29, string:"start argument must be int"; 30, if_statement; 30, 31; 30, 37; 31, not_operator; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:isinstance; 34, argument_list; 34, 35; 34, 36; 35, identifier:stop; 36, identifier:int; 37, block; 37, 38; 38, raise_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:TypeError; 41, argument_list; 41, 42; 42, string:"stop argument must be int"; 43, if_statement; 43, 44; 43, 45; 43, 51; 44, identifier:withscores; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:args; 49, list:[b'WITHSCORES']; 49, 50; 50, string:b'WITHSCORES'; 51, else_clause; 51, 52; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:args; 56, list:[]; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:fut; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:execute; 64, argument_list; 64, 65; 64, 66; 64, 67; 64, 68; 64, 69; 64, 71; 65, string:b'ZREVRANGE'; 66, identifier:key; 67, identifier:start; 68, identifier:stop; 69, list_splat; 69, 70; 70, identifier:args; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:encoding; 73, identifier:encoding; 74, if_statement; 74, 75; 74, 76; 75, identifier:withscores; 76, block; 76, 77; 77, return_statement; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:wait_convert; 80, argument_list; 80, 81; 80, 82; 81, identifier:fut; 82, identifier:pairs_int_or_float; 83, return_statement; 83, 84; 84, identifier:fut | def zrevrange(self, key, start, stop, withscores=False, encoding=_NOTSET):
"""Return a range of members in a sorted set, by index,
with scores ordered from high to low.
:raises TypeError: if start or stop is not int
"""
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, 37; 34, 52; 34, 67; 34, 92; 34, 109; 34, 126; 34, 137; 34, 141; 34, 149; 34, 168; 34, 185; 34, 194; 35, expression_statement; 35, 36; 36, comment; 37, if_statement; 37, 38; 37, 46; 38, not_operator; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:isinstance; 41, argument_list; 41, 42; 41, 43; 42, identifier:min; 43, tuple; 43, 44; 43, 45; 44, identifier:int; 45, identifier:float; 46, block; 46, 47; 47, raise_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:TypeError; 50, argument_list; 50, 51; 51, string:"min argument must be int or float"; 52, if_statement; 52, 53; 52, 61; 53, not_operator; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:isinstance; 56, argument_list; 56, 57; 56, 58; 57, identifier:max; 58, tuple; 58, 59; 58, 60; 59, identifier:int; 60, identifier:float; 61, block; 61, 62; 62, raise_statement; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:TypeError; 65, argument_list; 65, 66; 66, string:"max argument must be int or float"; 67, if_statement; 67, 68; 67, 86; 68, boolean_operator:or; 68, 69; 68, 77; 68, 78; 69, parenthesized_expression; 69, 70; 70, boolean_operator:and; 70, 71; 70, 74; 71, comparison_operator:is; 71, 72; 71, 73; 72, identifier:offset; 73, None; 74, comparison_operator:is; 74, 75; 74, 76; 75, identifier:count; 76, None; 77, line_continuation:\; 78, parenthesized_expression; 78, 79; 79, boolean_operator:and; 79, 80; 79, 83; 80, comparison_operator:is; 80, 81; 80, 82; 81, identifier:count; 82, None; 83, comparison_operator:is; 83, 84; 83, 85; 84, identifier:offset; 85, None; 86, block; 86, 87; 87, raise_statement; 87, 88; 88, call; 88, 89; 88, 90; 89, identifier:TypeError; 90, argument_list; 90, 91; 91, string:"offset and count must both be specified"; 92, if_statement; 92, 93; 92, 103; 93, boolean_operator:and; 93, 94; 93, 97; 94, comparison_operator:is; 94, 95; 94, 96; 95, identifier:offset; 96, None; 97, not_operator; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:isinstance; 100, argument_list; 100, 101; 100, 102; 101, identifier:offset; 102, identifier:int; 103, block; 103, 104; 104, raise_statement; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:TypeError; 107, argument_list; 107, 108; 108, string:"offset argument must be int"; 109, if_statement; 109, 110; 109, 120; 110, boolean_operator:and; 110, 111; 110, 114; 111, comparison_operator:is; 111, 112; 111, 113; 112, identifier:count; 113, None; 114, not_operator; 114, 115; 115, call; 115, 116; 115, 117; 116, identifier:isinstance; 117, argument_list; 117, 118; 117, 119; 118, identifier:count; 119, identifier:int; 120, block; 120, 121; 121, raise_statement; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:TypeError; 124, argument_list; 124, 125; 125, string:"count argument must be int"; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 131; 128, pattern_list; 128, 129; 128, 130; 129, identifier:min; 130, identifier:max; 131, call; 131, 132; 131, 133; 132, identifier:_encode_min_max; 133, argument_list; 133, 134; 133, 135; 133, 136; 134, identifier:exclude; 135, identifier:min; 136, identifier:max; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:args; 140, list:[]; 141, if_statement; 141, 142; 141, 143; 142, identifier:withscores; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:args; 147, list:[b'WITHSCORES']; 147, 148; 148, string:b'WITHSCORES'; 149, if_statement; 149, 150; 149, 157; 150, boolean_operator:and; 150, 151; 150, 154; 151, comparison_operator:is; 151, 152; 151, 153; 152, identifier:offset; 153, None; 154, comparison_operator:is; 154, 155; 154, 156; 155, identifier:count; 156, None; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:args; 162, identifier:extend; 163, argument_list; 163, 164; 164, list:[b'LIMIT', offset, count]; 164, 165; 164, 166; 164, 167; 165, string:b'LIMIT'; 166, identifier:offset; 167, identifier:count; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:fut; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:execute; 175, argument_list; 175, 176; 175, 177; 175, 178; 175, 179; 175, 180; 175, 182; 176, string:b'ZREVRANGEBYSCORE'; 177, identifier:key; 178, identifier:max; 179, identifier:min; 180, list_splat; 180, 181; 181, identifier:args; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:encoding; 184, identifier:encoding; 185, if_statement; 185, 186; 185, 187; 186, identifier:withscores; 187, block; 187, 188; 188, return_statement; 188, 189; 189, call; 189, 190; 189, 191; 190, identifier:wait_convert; 191, argument_list; 191, 192; 191, 193; 192, identifier:fut; 193, identifier:pairs_int_or_float; 194, return_statement; 194, 195; 195, identifier:fut | def zrevrangebyscore(self, key, max=float('inf'), min=float('-inf'),
*, exclude=None, withscores=False,
offset=None, count=None, encoding=_NOTSET):
"""Return a range of members in a sorted set, by score,
with scores ordered from high to low.
:raises TypeError: if min or max is not float or int
:raises TypeError: if both offset and count are not specified
:raises TypeError: if offset is not int
:raises TypeError: if count is not int
"""
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, 10; 7, 21; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:fut; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:execute; 17, argument_list; 17, 18; 17, 19; 17, 20; 18, string:b'ZSCORE'; 19, identifier:key; 20, identifier:member; 21, return_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:wait_convert; 24, argument_list; 24, 25; 24, 26; 25, identifier:fut; 26, identifier:optional_int_or_float | def zscore(self, key, member):
"""Get the score associated with the given member in a sorted set."""
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, 18; 15, 25; 15, 32; 15, 36; 15, 96; 15, 144; 15, 157; 16, expression_statement; 16, 17; 17, comment; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:keys; 21, binary_operator:+; 21, 22; 21, 24; 22, tuple; 22, 23; 23, identifier:key; 24, identifier:keys; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:numkeys; 28, call; 28, 29; 28, 30; 29, identifier:len; 30, argument_list; 30, 31; 31, identifier:keys; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:args; 35, list:[]; 36, if_statement; 36, 37; 36, 38; 36, 87; 37, identifier:with_weights; 38, block; 38, 39; 38, 55; 38, 60; 38, 80; 39, assert_statement; 39, 40; 39, 53; 40, call; 40, 41; 40, 42; 41, identifier:all; 42, generator_expression; 42, 43; 42, 50; 43, call; 43, 44; 43, 45; 44, identifier:isinstance; 45, argument_list; 45, 46; 45, 47; 46, identifier:val; 47, tuple; 47, 48; 47, 49; 48, identifier:list; 49, identifier:tuple; 50, for_in_clause; 50, 51; 50, 52; 51, identifier:val; 52, identifier:keys; 53, parenthesized_expression; 53, 54; 54, string:"All key arguments must be (key, weight) tuples"; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:weights; 58, list:['WEIGHTS']; 58, 59; 59, string:'WEIGHTS'; 60, for_statement; 60, 61; 60, 64; 60, 65; 61, pattern_list; 61, 62; 61, 63; 62, identifier:key; 63, identifier:weight; 64, identifier:keys; 65, block; 65, 66; 65, 73; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:args; 70, identifier:append; 71, argument_list; 71, 72; 72, identifier:key; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:weights; 77, identifier:append; 78, argument_list; 78, 79; 79, identifier:weight; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:args; 84, identifier:extend; 85, argument_list; 85, 86; 86, identifier:weights; 87, else_clause; 87, 88; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:args; 93, identifier:extend; 94, argument_list; 94, 95; 95, identifier:keys; 96, if_statement; 96, 97; 96, 102; 96, 112; 96, 128; 97, comparison_operator:is; 97, 98; 97, 99; 98, identifier:aggregate; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:ZSET_AGGREGATE_SUM; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:args; 107, identifier:extend; 108, argument_list; 108, 109; 109, tuple; 109, 110; 109, 111; 110, string:'AGGREGATE'; 111, string:'SUM'; 112, elif_clause; 112, 113; 112, 118; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:aggregate; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:ZSET_AGGREGATE_MAX; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:args; 123, identifier:extend; 124, argument_list; 124, 125; 125, tuple; 125, 126; 125, 127; 126, string:'AGGREGATE'; 127, string:'MAX'; 128, elif_clause; 128, 129; 128, 134; 129, comparison_operator:is; 129, 130; 129, 131; 130, identifier:aggregate; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:ZSET_AGGREGATE_MIN; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:args; 139, identifier:extend; 140, argument_list; 140, 141; 141, tuple; 141, 142; 141, 143; 142, string:'AGGREGATE'; 143, string:'MIN'; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:fut; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:execute; 151, argument_list; 151, 152; 151, 153; 151, 154; 151, 155; 152, string:b'ZUNIONSTORE'; 153, identifier:destkey; 154, identifier:numkeys; 155, list_splat; 155, 156; 156, identifier:args; 157, return_statement; 157, 158; 158, identifier:fut | def zunionstore(self, destkey, key, *keys,
with_weights=False, aggregate=None):
"""Add multiple sorted sets and store result in a new key."""
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, 18; 15, 22; 15, 33; 15, 44; 15, 57; 15, 76; 16, expression_statement; 16, 17; 17, comment; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:args; 21, list:[]; 22, if_statement; 22, 23; 22, 26; 23, comparison_operator:is; 23, 24; 23, 25; 24, identifier:match; 25, None; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, augmented_assignment:+=; 28, 29; 28, 30; 29, identifier:args; 30, list:[b'MATCH', match]; 30, 31; 30, 32; 31, string:b'MATCH'; 32, identifier:match; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:count; 36, None; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, augmented_assignment:+=; 39, 40; 39, 41; 40, identifier:args; 41, list:[b'COUNT', count]; 41, 42; 41, 43; 42, string:b'COUNT'; 43, identifier:count; 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; 52, string:b'ZSCAN'; 53, identifier:key; 54, identifier:cursor; 55, list_splat; 55, 56; 56, identifier:args; 57, function_definition; 57, 58; 57, 59; 57, 61; 58, function_name:_converter; 59, parameters; 59, 60; 60, identifier:obj; 61, block; 61, 62; 62, return_statement; 62, 63; 63, tuple; 63, 64; 63, 70; 64, call; 64, 65; 64, 66; 65, identifier:int; 66, argument_list; 66, 67; 67, subscript; 67, 68; 67, 69; 68, identifier:obj; 69, integer:0; 70, call; 70, 71; 70, 72; 71, identifier:pairs_int_or_float; 72, argument_list; 72, 73; 73, subscript; 73, 74; 73, 75; 74, identifier:obj; 75, integer:1; 76, return_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:wait_convert; 79, argument_list; 79, 80; 79, 81; 80, identifier:fut; 81, identifier:_converter | def zscan(self, key, cursor=0, match=None, count=None):
"""Incrementally iterate sorted sets elements and associated scores."""
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, 16; 13, 33; 13, 37; 13, 50; 13, 65; 14, expression_statement; 14, 15; 15, comment; 16, if_statement; 16, 17; 16, 27; 17, boolean_operator:and; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:count; 20, None; 21, not_operator; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 26; 25, identifier:count; 26, identifier:int; 27, block; 27, 28; 28, raise_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:TypeError; 31, argument_list; 31, 32; 32, string:"count argument must be int"; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:args; 36, list:[]; 37, if_statement; 37, 38; 37, 41; 38, comparison_operator:is; 38, 39; 38, 40; 39, identifier:count; 40, None; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:args; 46, identifier:extend; 47, argument_list; 47, 48; 48, list:[count]; 48, 49; 49, identifier:count; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:fut; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:execute; 57, argument_list; 57, 58; 57, 59; 57, 60; 57, 62; 58, string:b'ZPOPMIN'; 59, identifier:key; 60, list_splat; 60, 61; 61, identifier:args; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:encoding; 64, identifier:encoding; 65, return_statement; 65, 66; 66, identifier:fut | def zpopmin(self, key, count=None, *, encoding=_NOTSET):
"""Removes and returns up to count members with the lowest scores
in the sorted set stored at key.
:raises TypeError: if count is not int
"""
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, 16; 13, 33; 13, 37; 13, 50; 13, 65; 14, expression_statement; 14, 15; 15, comment; 16, if_statement; 16, 17; 16, 27; 17, boolean_operator:and; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:count; 20, None; 21, not_operator; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 26; 25, identifier:count; 26, identifier:int; 27, block; 27, 28; 28, raise_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:TypeError; 31, argument_list; 31, 32; 32, string:"count argument must be int"; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:args; 36, list:[]; 37, if_statement; 37, 38; 37, 41; 38, comparison_operator:is; 38, 39; 38, 40; 39, identifier:count; 40, None; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:args; 46, identifier:extend; 47, argument_list; 47, 48; 48, list:[count]; 48, 49; 49, identifier:count; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:fut; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:execute; 57, argument_list; 57, 58; 57, 59; 57, 60; 57, 62; 58, string:b'ZPOPMAX'; 59, identifier:key; 60, list_splat; 60, 61; 61, identifier:args; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:encoding; 64, identifier:encoding; 65, return_statement; 65, 66; 66, identifier:fut | def zpopmax(self, key, count=None, *, encoding=_NOTSET):
"""Removes and returns up to count members with the highest scores
in the sorted set stored at key.
:raises TypeError: if count is not int
"""
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, 8; 5, 109; 6, expression_statement; 6, 7; 7, comment; 8, try_statement; 8, 9; 8, 29; 9, block; 9, 10; 10, return_statement; 10, 11; 11, comparison_operator:==; 11, 12; 11, 25; 12, call; 12, 13; 12, 14; 13, identifier:len; 14, argument_list; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:set; 17, generator_expression; 17, 18; 17, 22; 18, call; 18, 19; 18, 20; 19, identifier:unbool; 20, argument_list; 20, 21; 21, identifier:i; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:i; 24, identifier:container; 25, call; 25, 26; 25, 27; 26, identifier:len; 27, argument_list; 27, 28; 28, identifier:container; 29, except_clause; 29, 30; 29, 31; 30, identifier:TypeError; 31, block; 31, 32; 32, try_statement; 32, 33; 32, 75; 33, block; 33, 34; 33, 47; 33, 58; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:sort; 37, call; 37, 38; 37, 39; 38, identifier:sorted; 39, generator_expression; 39, 40; 39, 44; 40, call; 40, 41; 40, 42; 41, identifier:unbool; 42, argument_list; 42, 43; 43, identifier:i; 44, for_in_clause; 44, 45; 44, 46; 45, identifier:i; 46, identifier:container; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:sliced; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:itertools; 53, identifier:islice; 54, argument_list; 54, 55; 54, 56; 54, 57; 55, identifier:sort; 56, integer:1; 57, None; 58, for_statement; 58, 59; 58, 62; 58, 67; 59, pattern_list; 59, 60; 59, 61; 60, identifier:i; 61, identifier:j; 62, call; 62, 63; 62, 64; 63, identifier:zip; 64, argument_list; 64, 65; 64, 66; 65, identifier:sort; 66, identifier:sliced; 67, block; 67, 68; 68, if_statement; 68, 69; 68, 72; 69, comparison_operator:==; 69, 70; 69, 71; 70, identifier:i; 71, identifier:j; 72, block; 72, 73; 73, return_statement; 73, 74; 74, False; 75, except_clause; 75, 76; 75, 79; 76, tuple; 76, 77; 76, 78; 77, identifier:NotImplementedError; 78, identifier:TypeError; 79, block; 79, 80; 79, 84; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:seen; 83, list:[]; 84, for_statement; 84, 85; 84, 86; 84, 87; 85, identifier:e; 86, identifier:container; 87, block; 87, 88; 87, 95; 87, 102; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:e; 91, call; 91, 92; 91, 93; 92, identifier:unbool; 93, argument_list; 93, 94; 94, identifier:e; 95, if_statement; 95, 96; 95, 99; 96, comparison_operator:in; 96, 97; 96, 98; 97, identifier:e; 98, identifier:seen; 99, block; 99, 100; 100, return_statement; 100, 101; 101, False; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:seen; 106, identifier:append; 107, argument_list; 107, 108; 108, identifier:e; 109, return_statement; 109, 110; 110, True | def uniq(container):
"""
Check if all of a container's elements are unique.
Successively tries first to rely that the elements are hashable, then
falls back on them being sortable, and finally falls back on brute
force.
"""
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, 12; 9, 26; 9, 27; 9, 49; 9, 50; 9, 70; 9, 71; 9, 88; 9, 89; 9, 99; 9, 100; 9, 159; 9, 160; 9, 270; 9, 279; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:traversal; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:np; 18, identifier:asanyarray; 19, argument_list; 19, 20; 19, 21; 20, identifier:traversal; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:dtype; 23, attribute; 23, 24; 23, 25; 24, identifier:np; 25, identifier:int64; 26, comment; 27, if_statement; 27, 28; 27, 31; 28, comparison_operator:is; 28, 29; 28, 30; 29, identifier:edges_hash; 30, None; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:edges_hash; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:grouping; 38, identifier:hashable_rows; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:np; 43, identifier:sort; 44, argument_list; 44, 45; 44, 46; 45, identifier:edges; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:axis; 48, integer:1; 49, comment; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:trav_edge; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:np; 56, identifier:column_stack; 57, argument_list; 57, 58; 58, tuple; 58, 59; 58, 65; 59, subscript; 59, 60; 59, 61; 60, identifier:traversal; 61, slice; 61, 62; 61, 63; 62, colon; 63, unary_operator:-; 63, 64; 64, integer:1; 65, subscript; 65, 66; 65, 67; 66, identifier:traversal; 67, slice; 67, 68; 67, 69; 68, integer:1; 69, colon; 70, comment; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:trav_hash; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:grouping; 77, identifier:hashable_rows; 78, argument_list; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:np; 82, identifier:sort; 83, argument_list; 83, 84; 83, 85; 84, identifier:trav_edge; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:axis; 87, integer:1; 88, comment; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:contained; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:np; 95, identifier:in1d; 96, argument_list; 96, 97; 96, 98; 97, identifier:trav_hash; 98, identifier:edges_hash; 99, comment; 100, if_statement; 100, 101; 100, 106; 100, 107; 100, 113; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:contained; 104, identifier:all; 105, argument_list; 106, comment; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:split; 111, list:[traversal]; 111, 112; 112, identifier:traversal; 113, else_clause; 113, 114; 113, 115; 114, comment; 115, block; 115, 116; 115, 131; 115, 132; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:blocks; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:grouping; 122, identifier:blocks; 123, argument_list; 123, 124; 123, 125; 123, 128; 124, identifier:contained; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:min_len; 127, integer:1; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:only_nonzero; 130, True; 131, comment; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:split; 135, list_comprehension; 135, 136; 135, 156; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:np; 139, identifier:append; 140, argument_list; 140, 141; 140, 148; 141, subscript; 141, 142; 141, 145; 141, 147; 142, subscript; 142, 143; 142, 144; 143, identifier:trav_edge; 144, identifier:b; 145, slice; 145, 146; 146, colon; 147, integer:0; 148, subscript; 148, 149; 148, 155; 149, subscript; 149, 150; 149, 151; 150, identifier:trav_edge; 151, subscript; 151, 152; 151, 153; 152, identifier:b; 153, unary_operator:-; 153, 154; 154, integer:1; 155, integer:1; 156, for_in_clause; 156, 157; 156, 158; 157, identifier:b; 158, identifier:blocks; 159, comment; 160, for_statement; 160, 161; 160, 164; 160, 168; 160, 169; 161, pattern_list; 161, 162; 161, 163; 162, identifier:i; 163, identifier:t; 164, call; 164, 165; 164, 166; 165, identifier:enumerate; 166, argument_list; 166, 167; 167, identifier:split; 168, comment; 169, block; 169, 170; 169, 188; 169, 189; 169, 198; 169, 199; 169, 215; 169, 225; 169, 243; 169, 244; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 175; 172, subscript; 172, 173; 172, 174; 173, identifier:split; 174, identifier:i; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:np; 178, identifier:asanyarray; 179, argument_list; 179, 180; 179, 183; 180, subscript; 180, 181; 180, 182; 181, identifier:split; 182, identifier:i; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:dtype; 185, attribute; 185, 186; 185, 187; 186, identifier:np; 187, identifier:int64; 188, comment; 189, if_statement; 189, 190; 189, 196; 190, comparison_operator:<=; 190, 191; 190, 195; 191, call; 191, 192; 191, 193; 192, identifier:len; 193, argument_list; 193, 194; 194, identifier:t; 195, integer:2; 196, block; 196, 197; 197, continue_statement; 198, comment; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:edge; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:np; 205, identifier:sort; 206, argument_list; 206, 207; 207, list:[t[0], t[-1]]; 207, 208; 207, 211; 208, subscript; 208, 209; 208, 210; 209, identifier:t; 210, integer:0; 211, subscript; 211, 212; 211, 213; 212, identifier:t; 213, unary_operator:-; 213, 214; 214, integer:1; 215, if_statement; 215, 216; 215, 223; 216, comparison_operator:==; 216, 217; 216, 222; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:edge; 220, identifier:ptp; 221, argument_list; 222, integer:0; 223, block; 223, 224; 224, continue_statement; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:close; 228, subscript; 228, 229; 228, 242; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:grouping; 232, identifier:hashable_rows; 233, argument_list; 233, 234; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:edge; 237, identifier:reshape; 238, argument_list; 238, 239; 239, tuple; 239, 240; 239, 241; 240, integer:1; 241, integer:2; 242, integer:0; 243, comment; 244, if_statement; 244, 245; 244, 248; 245, comparison_operator:in; 245, 246; 245, 247; 246, identifier:close; 247, identifier:edges_hash; 248, block; 248, 249; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 254; 251, subscript; 251, 252; 251, 253; 252, identifier:split; 253, identifier:i; 254, call; 254, 255; 254, 266; 255, attribute; 255, 256; 255, 265; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:np; 259, identifier:append; 260, argument_list; 260, 261; 260, 262; 261, identifier:t; 262, subscript; 262, 263; 262, 264; 263, identifier:t; 264, integer:0; 265, identifier:astype; 266, argument_list; 266, 267; 267, attribute; 267, 268; 267, 269; 268, identifier:np; 269, identifier:int64; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:result; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:np; 276, identifier:array; 277, argument_list; 277, 278; 278, identifier:split; 279, return_statement; 279, 280; 280, identifier:result | def split_traversal(traversal,
edges,
edges_hash=None):
"""
Given a traversal as a list of nodes, split the traversal
if a sequential index pair is not in the given edges.
Parameters
--------------
edges : (n, 2) int
Graph edge indexes
traversal : (m,) int
Traversal through edges
edge_hash : (n,)
Edges sorted on axis=1 and
passed to grouping.hashable_rows
Returns
---------------
split : sequence of (p,) int
"""
traversal = np.asanyarray(traversal,
dtype=np.int64)
# hash edge rows for contains checks
if edges_hash is None:
edges_hash = grouping.hashable_rows(
np.sort(edges, axis=1))
# turn the (n,) traversal into (n-1,2) edges
trav_edge = np.column_stack((traversal[:-1],
traversal[1:]))
# hash each edge so we can compare to edge set
trav_hash = grouping.hashable_rows(
np.sort(trav_edge, axis=1))
# check if each edge is contained in edge set
contained = np.in1d(trav_hash, edges_hash)
# exit early if every edge of traversal exists
if contained.all():
# just reshape one traversal
split = [traversal]
else:
# find contiguous groups of contained edges
blocks = grouping.blocks(contained,
min_len=1,
only_nonzero=True)
# turn edges back in to sequence of traversals
split = [np.append(trav_edge[b][:, 0],
trav_edge[b[-1]][1])
for b in blocks]
# close traversals if necessary
for i, t in enumerate(split):
# make sure elements of sequence are numpy arrays
split[i] = np.asanyarray(split[i], dtype=np.int64)
# don't close if its a single edge
if len(t) <= 2:
continue
# make sure it's not already closed
edge = np.sort([t[0], t[-1]])
if edge.ptp() == 0:
continue
close = grouping.hashable_rows(edge.reshape((1, 2)))[0]
# if we need the edge add it
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, 12; 9, 13; 9, 27; 9, 28; 9, 37; 9, 38; 9, 52; 9, 53; 9, 67; 9, 71; 9, 95; 9, 96; 9, 125; 9, 175; 10, expression_statement; 10, 11; 11, comment; 12, comment; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:edges; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:np; 19, identifier:asanyarray; 20, argument_list; 20, 21; 20, 22; 21, identifier:edges; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:dtype; 24, attribute; 24, 25; 24, 26; 25, identifier:np; 26, identifier:int64; 27, comment; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:edges; 32, identifier:sort; 33, argument_list; 33, 34; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:axis; 36, integer:1; 37, comment; 38, if_statement; 38, 39; 38, 45; 39, comparison_operator:==; 39, 40; 39, 44; 40, call; 40, 41; 40, 42; 41, identifier:len; 42, argument_list; 42, 43; 43, identifier:traversals; 44, integer:0; 45, block; 45, 46; 46, return_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:edges; 50, identifier:copy; 51, argument_list; 52, comment; 53, if_statement; 53, 54; 53, 57; 54, comparison_operator:is; 54, 55; 54, 56; 55, identifier:edges_hash; 56, None; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:edges_hash; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:grouping; 64, identifier:hashable_rows; 65, argument_list; 65, 66; 66, identifier:edges; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:splits; 70, list:[]; 71, for_statement; 71, 72; 71, 73; 71, 74; 71, 75; 71, 76; 72, identifier:nodes; 73, identifier:traversals; 74, comment; 75, comment; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:splits; 81, identifier:extend; 82, argument_list; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:split_traversal; 85, argument_list; 85, 86; 85, 89; 85, 92; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:traversal; 88, identifier:nodes; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:edges; 91, identifier:edges; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:edges_hash; 94, identifier:edges_hash; 95, comment; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:included; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:util; 102, identifier:vstack_empty; 103, argument_list; 103, 104; 104, list_comprehension; 104, 105; 104, 122; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:np; 108, identifier:column_stack; 109, argument_list; 109, 110; 110, tuple; 110, 111; 110, 117; 111, subscript; 111, 112; 111, 113; 112, identifier:i; 113, slice; 113, 114; 113, 115; 114, colon; 115, unary_operator:-; 115, 116; 116, integer:1; 117, subscript; 117, 118; 117, 119; 118, identifier:i; 119, slice; 119, 120; 119, 121; 120, integer:1; 121, colon; 122, for_in_clause; 122, 123; 122, 124; 123, identifier:i; 124, identifier:splits; 125, if_statement; 125, 126; 125, 132; 125, 133; 125, 163; 126, comparison_operator:>; 126, 127; 126, 131; 127, call; 127, 128; 127, 129; 128, identifier:len; 129, argument_list; 129, 130; 130, identifier:included; 131, integer:0; 132, comment; 133, block; 133, 134; 133, 143; 133, 144; 133, 145; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:included; 138, identifier:sort; 139, argument_list; 139, 140; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:axis; 142, integer:1; 143, comment; 144, comment; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:splits; 149, identifier:extend; 150, argument_list; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:grouping; 154, identifier:boolean_rows; 155, argument_list; 155, 156; 155, 157; 155, 158; 156, identifier:edges; 157, identifier:included; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:operation; 160, attribute; 160, 161; 160, 162; 161, identifier:np; 162, identifier:setdiff1d; 163, else_clause; 163, 164; 163, 165; 163, 166; 164, comment; 165, comment; 166, block; 166, 167; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:splits; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:edges; 173, identifier:copy; 174, argument_list; 175, return_statement; 175, 176; 176, identifier:splits | def fill_traversals(traversals, edges, edges_hash=None):
"""
Convert a traversal of a list of edges into a sequence of
traversals where every pair of consecutive node indexes
is an edge in a passed edge list
Parameters
-------------
traversals : sequence of (m,) int
Node indexes of traversals of a graph
edges : (n, 2) int
Pairs of connected node indexes
edges_hash : None, or (n,) int
Edges sorted along axis 1 then hashed
using grouping.hashable_rows
Returns
--------------
splits : sequence of (p,) int
Node indexes of connected traversals
"""
# make sure edges are correct type
edges = np.asanyarray(edges, dtype=np.int64)
# make sure edges are sorted
edges.sort(axis=1)
# if there are no traversals just return edges
if len(traversals) == 0:
return edges.copy()
# hash edges for contains checks
if edges_hash is None:
edges_hash = grouping.hashable_rows(edges)
splits = []
for nodes in traversals:
# split traversals to remove edges
# that don't actually exist
splits.extend(split_traversal(
traversal=nodes,
edges=edges,
edges_hash=edges_hash))
# turn the split traversals back into (n,2) edges
included = util.vstack_empty([np.column_stack((i[:-1], i[1:]))
for i in splits])
if len(included) > 0:
# sort included edges in place
included.sort(axis=1)
# make sure any edges not included in split traversals
# are just added as a length 2 traversal
splits.extend(grouping.boolean_rows(
edges,
included,
operation=np.setdiff1d))
else:
# no edges were included, so our filled traversal
# is just the original edges copied over
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, 11; 8, 12; 8, 27; 8, 28; 8, 38; 8, 39; 8, 51; 8, 52; 8, 53; 8, 168; 8, 169; 8, 192; 8, 193; 8, 213; 9, expression_statement; 9, 10; 10, comment; 11, comment; 12, if_statement; 12, 13; 12, 19; 13, comparison_operator:==; 13, 14; 13, 18; 14, call; 14, 15; 14, 16; 15, identifier:len; 16, argument_list; 16, 17; 17, identifier:data; 18, integer:0; 19, block; 19, 20; 20, return_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:array; 25, argument_list; 25, 26; 26, list:[]; 27, comment; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:as_int; 31, call; 31, 32; 31, 33; 32, identifier:float_to_int; 33, argument_list; 33, 34; 33, 35; 34, identifier:data; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:digits; 37, identifier:digits; 38, comment; 39, if_statement; 39, 40; 39, 48; 40, comparison_operator:==; 40, 41; 40, 47; 41, call; 41, 42; 41, 43; 42, identifier:len; 43, argument_list; 43, 44; 44, attribute; 44, 45; 44, 46; 45, identifier:as_int; 46, identifier:shape; 47, integer:1; 48, block; 48, 49; 49, return_statement; 49, 50; 50, identifier:as_int; 51, comment; 52, comment; 53, if_statement; 53, 54; 53, 70; 53, 71; 53, 72; 54, boolean_operator:and; 54, 55; 54, 63; 55, comparison_operator:==; 55, 56; 55, 62; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, attribute; 59, 60; 59, 61; 60, identifier:as_int; 61, identifier:shape; 62, integer:2; 63, comparison_operator:<=; 63, 64; 63, 69; 64, subscript; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:as_int; 67, identifier:shape; 68, integer:1; 69, integer:4; 70, comment; 71, comment; 72, block; 72, 73; 72, 91; 72, 92; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:precision; 76, call; 76, 77; 76, 78; 77, identifier:int; 78, argument_list; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:np; 82, identifier:floor; 83, argument_list; 83, 84; 84, binary_operator:/; 84, 85; 84, 86; 85, integer:64; 86, subscript; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:as_int; 89, identifier:shape; 90, integer:1; 91, comment; 92, if_statement; 92, 93; 92, 110; 92, 111; 93, comparison_operator:<; 93, 94; 93, 104; 94, call; 94, 95; 94, 103; 95, attribute; 95, 96; 95, 102; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:np; 99, identifier:abs; 100, argument_list; 100, 101; 101, identifier:as_int; 102, identifier:max; 103, argument_list; 104, binary_operator:**; 104, 105; 104, 106; 105, integer:2; 106, parenthesized_expression; 106, 107; 107, binary_operator:-; 107, 108; 107, 109; 108, identifier:precision; 109, integer:1; 110, comment; 111, block; 111, 112; 111, 129; 111, 130; 111, 131; 111, 166; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:hashable; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:np; 118, identifier:zeros; 119, argument_list; 119, 120; 119, 124; 120, call; 120, 121; 120, 122; 121, identifier:len; 122, argument_list; 122, 123; 123, identifier:as_int; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:dtype; 126, attribute; 126, 127; 126, 128; 127, identifier:np; 128, identifier:int64; 129, comment; 130, comment; 131, for_statement; 131, 132; 131, 135; 131, 148; 131, 149; 132, pattern_list; 132, 133; 132, 134; 133, identifier:offset; 134, identifier:column; 135, call; 135, 136; 135, 137; 136, identifier:enumerate; 137, argument_list; 137, 138; 138, attribute; 138, 139; 138, 147; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:as_int; 142, identifier:astype; 143, argument_list; 143, 144; 144, attribute; 144, 145; 144, 146; 145, identifier:np; 146, identifier:int64; 147, identifier:T; 148, comment; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:np; 154, identifier:bitwise_xor; 155, argument_list; 155, 156; 155, 157; 155, 163; 156, identifier:hashable; 157, binary_operator:<<; 157, 158; 157, 159; 158, identifier:column; 159, parenthesized_expression; 159, 160; 160, binary_operator:*; 160, 161; 160, 162; 161, identifier:offset; 162, identifier:precision; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:out; 165, identifier:hashable; 166, return_statement; 166, 167; 167, identifier:hashable; 168, comment; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:dtype; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:np; 175, identifier:dtype; 176, argument_list; 176, 177; 177, tuple; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:np; 180, identifier:void; 181, binary_operator:*; 181, 182; 181, 187; 182, attribute; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:as_int; 185, identifier:dtype; 186, identifier:itemsize; 187, subscript; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:as_int; 190, identifier:shape; 191, integer:1; 192, comment; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:hashable; 196, call; 196, 197; 196, 210; 197, attribute; 197, 198; 197, 209; 198, call; 198, 199; 198, 207; 199, attribute; 199, 200; 199, 206; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:np; 203, identifier:ascontiguousarray; 204, argument_list; 204, 205; 205, identifier:as_int; 206, identifier:view; 207, argument_list; 207, 208; 208, identifier:dtype; 209, identifier:reshape; 210, argument_list; 210, 211; 211, unary_operator:-; 211, 212; 212, integer:1; 213, return_statement; 213, 214; 214, identifier:hashable | def hashable_rows(data, digits=None):
"""
We turn our array into integers based on the precision
given by digits and then put them in a hashable format.
Parameters
---------
data : (n, m) array
Input data
digits : int or None
How many digits to add to hash if data is floating point
If None, tol.merge will be used
Returns
---------
hashable : (n,) array
Custom data type which can be sorted
or used as hash keys
"""
# if there is no data return immediately
if len(data) == 0:
return np.array([])
# get array as integer to precision we care about
as_int = float_to_int(data, digits=digits)
# if it is flat integers already, return
if len(as_int.shape) == 1:
return as_int
# if array is 2D and smallish, we can try bitbanging
# this is significantly faster than the custom dtype
if len(as_int.shape) == 2 and as_int.shape[1] <= 4:
# time for some righteous bitbanging
# can we pack the whole row into a single 64 bit integer
precision = int(np.floor(64 / as_int.shape[1]))
# if the max value is less than precision we can do this
if np.abs(as_int).max() < 2**(precision - 1):
# the resulting package
hashable = np.zeros(len(as_int), dtype=np.int64)
# loop through each column and bitwise xor to combine
# make sure as_int is int64 otherwise bit offset won't work
for offset, column in enumerate(as_int.astype(np.int64).T):
# will modify hashable in place
np.bitwise_xor(hashable,
column << (offset * precision),
out=hashable)
return hashable
# reshape array into magical data type that is weird but hashable
dtype = np.dtype((np.void, as_int.dtype.itemsize * as_int.shape[1]))
# make sure result is contiguous and flat
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, 12; 9, 21; 9, 27; 9, 33; 9, 42; 9, 119; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:x_sort_args; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:np; 18, identifier:argsort; 19, argument_list; 19, 20; 20, identifier:x; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:x; 24, subscript; 24, 25; 24, 26; 25, identifier:x; 26, identifier:x_sort_args; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:y; 30, subscript; 30, 31; 30, 32; 31, identifier:y; 32, identifier:x_sort_args; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:nans; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:np; 39, identifier:isnan; 40, argument_list; 40, 41; 41, identifier:y; 42, if_statement; 42, 43; 42, 46; 42, 68; 42, 104; 43, comparison_operator:==; 43, 44; 43, 45; 44, identifier:kind; 45, string:'linear'; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 52; 49, subscript; 49, 50; 49, 51; 50, identifier:y; 51, identifier:nans; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:np; 55, identifier:interp; 56, argument_list; 56, 57; 56, 60; 56, 64; 57, subscript; 57, 58; 57, 59; 58, identifier:x; 59, identifier:nans; 60, subscript; 60, 61; 60, 62; 61, identifier:x; 62, unary_operator:~; 62, 63; 63, identifier:nans; 64, subscript; 64, 65; 64, 66; 65, identifier:y; 66, unary_operator:~; 66, 67; 67, identifier:nans; 68, elif_clause; 68, 69; 68, 72; 69, comparison_operator:==; 69, 70; 69, 71; 70, identifier:kind; 71, string:'log'; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 78; 75, subscript; 75, 76; 75, 77; 76, identifier:y; 77, identifier:nans; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:np; 81, identifier:interp; 82, argument_list; 82, 83; 82, 91; 82, 100; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:np; 86, identifier:log; 87, argument_list; 87, 88; 88, subscript; 88, 89; 88, 90; 89, identifier:x; 90, identifier:nans; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:np; 94, identifier:log; 95, argument_list; 95, 96; 96, subscript; 96, 97; 96, 98; 97, identifier:x; 98, unary_operator:~; 98, 99; 99, identifier:nans; 100, subscript; 100, 101; 100, 102; 101, identifier:y; 102, unary_operator:~; 102, 103; 103, identifier:nans; 104, else_clause; 104, 105; 105, block; 105, 106; 106, raise_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:ValueError; 109, argument_list; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, string:'Unknown option for kind: {0}'; 113, identifier:format; 114, argument_list; 114, 115; 115, call; 115, 116; 115, 117; 116, identifier:str; 117, argument_list; 117, 118; 118, identifier:kind; 119, return_statement; 119, 120; 120, subscript; 120, 121; 120, 122; 121, identifier:y; 122, identifier:x_sort_args | def interpolate_nans_1d(x, y, kind='linear'):
"""Interpolate NaN values in y.
Interpolate NaN values in the y dimension. Works with unsorted x values.
Parameters
----------
x : array-like
1-dimensional array of numeric x-values
y : array-like
1-dimensional array of numeric y-values
kind : string
specifies the kind of interpolation x coordinate - 'linear' or 'log', optional.
Defaults to 'linear'.
Returns
-------
An array of the y coordinate data with NaN values interpolated.
"""
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, 14; 10, 26; 10, 36; 10, 37; 10, 52; 10, 53; 10, 59; 10, 60; 10, 72; 10, 81; 10, 82; 10, 92; 10, 93; 10, 99; 10, 100; 10, 110; 10, 111; 10, 117; 10, 126; 10, 135; 10, 144; 10, 145; 10, 161; 10, 170; 10, 171; 10, 206; 10, 207; 10, 208; 10, 247; 10, 265; 10, 266; 10, 276; 10, 288; 10, 307; 10, 308; 10, 312; 10, 313; 10, 418; 11, expression_statement; 11, 12; 12, comment; 13, comment; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:fill_value; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:kwargs; 20, identifier:pop; 21, argument_list; 21, 22; 21, 23; 22, string:'fill_value'; 23, attribute; 23, 24; 23, 25; 24, identifier:np; 25, identifier:nan; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:axis; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:kwargs; 32, identifier:pop; 33, argument_list; 33, 34; 33, 35; 34, string:'axis'; 35, integer:0; 36, comment; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:x; 40, call; 40, 41; 40, 49; 41, attribute; 41, 42; 41, 48; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:np; 45, identifier:asanyarray; 46, argument_list; 46, 47; 47, identifier:x; 48, identifier:reshape; 49, argument_list; 49, 50; 50, unary_operator:-; 50, 51; 51, integer:1; 52, comment; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:ndim; 56, attribute; 56, 57; 56, 58; 57, identifier:xp; 58, identifier:ndim; 59, comment; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:sort_args; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:np; 66, identifier:argsort; 67, argument_list; 67, 68; 67, 69; 68, identifier:xp; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:axis; 71, identifier:axis; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:sort_x; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:np; 78, identifier:argsort; 79, argument_list; 79, 80; 80, identifier:x; 81, comment; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:sorter; 85, call; 85, 86; 85, 87; 86, identifier:broadcast_indices; 87, argument_list; 87, 88; 87, 89; 87, 90; 87, 91; 88, identifier:xp; 89, identifier:sort_args; 90, identifier:ndim; 91, identifier:axis; 92, comment; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:xp; 96, subscript; 96, 97; 96, 98; 97, identifier:xp; 98, identifier:sorter; 99, comment; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:variables; 103, list_comprehension; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:arr; 106, identifier:sorter; 107, for_in_clause; 107, 108; 107, 109; 108, identifier:arr; 109, identifier:args; 110, comment; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:x_array; 114, subscript; 114, 115; 114, 116; 115, identifier:x; 116, identifier:sort_x; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:expand; 120, binary_operator:*; 120, 121; 120, 125; 121, list:[np.newaxis]; 121, 122; 122, attribute; 122, 123; 122, 124; 123, identifier:np; 124, identifier:newaxis; 125, identifier:ndim; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 131; 128, subscript; 128, 129; 128, 130; 129, identifier:expand; 130, identifier:axis; 131, call; 131, 132; 131, 133; 132, identifier:slice; 133, argument_list; 133, 134; 134, None; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:x_array; 138, subscript; 138, 139; 138, 140; 139, identifier:x_array; 140, call; 140, 141; 140, 142; 141, identifier:tuple; 142, argument_list; 142, 143; 143, identifier:expand; 144, comment; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:minv; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:np; 151, identifier:apply_along_axis; 152, argument_list; 152, 153; 152, 156; 152, 157; 152, 158; 153, attribute; 153, 154; 153, 155; 154, identifier:np; 155, identifier:searchsorted; 156, identifier:axis; 157, identifier:xp; 158, subscript; 158, 159; 158, 160; 159, identifier:x; 160, identifier:sort_x; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:minv2; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:np; 167, identifier:copy; 168, argument_list; 168, 169; 169, identifier:minv; 170, comment; 171, if_statement; 171, 172; 171, 200; 172, boolean_operator:and; 172, 173; 172, 197; 173, parenthesized_expression; 173, 174; 174, boolean_operator:or; 174, 175; 174, 188; 175, parenthesized_expression; 175, 176; 176, comparison_operator:==; 176, 177; 176, 183; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:np; 180, identifier:max; 181, argument_list; 181, 182; 182, identifier:minv; 183, subscript; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:xp; 186, identifier:shape; 187, identifier:axis; 188, parenthesized_expression; 188, 189; 189, comparison_operator:==; 189, 190; 189, 196; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:np; 193, identifier:min; 194, argument_list; 194, 195; 195, identifier:minv; 196, integer:0; 197, comparison_operator:is; 197, 198; 197, 199; 198, identifier:fill_value; 199, None; 200, block; 200, 201; 201, raise_statement; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:ValueError; 204, argument_list; 204, 205; 205, string:'Interpolation point out of data bounds encountered'; 206, comment; 207, comment; 208, if_statement; 208, 209; 208, 221; 209, comparison_operator:==; 209, 210; 209, 216; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:np; 213, identifier:max; 214, argument_list; 214, 215; 215, identifier:minv; 216, subscript; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:xp; 219, identifier:shape; 220, identifier:axis; 221, block; 221, 222; 221, 229; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:warnings; 226, identifier:warn; 227, argument_list; 227, 228; 228, string:'Interpolation point out of data bounds encountered'; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 240; 231, subscript; 231, 232; 231, 233; 232, identifier:minv2; 233, comparison_operator:==; 233, 234; 233, 235; 234, identifier:minv; 235, subscript; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:xp; 238, identifier:shape; 239, identifier:axis; 240, binary_operator:-; 240, 241; 240, 246; 241, subscript; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:xp; 244, identifier:shape; 245, identifier:axis; 246, integer:1; 247, if_statement; 247, 248; 247, 256; 248, comparison_operator:==; 248, 249; 248, 255; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:np; 252, identifier:min; 253, argument_list; 253, 254; 254, identifier:minv; 255, integer:0; 256, block; 256, 257; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 264; 259, subscript; 259, 260; 259, 261; 260, identifier:minv2; 261, comparison_operator:==; 261, 262; 261, 263; 262, identifier:minv; 263, integer:0; 264, integer:1; 265, comment; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:above; 269, call; 269, 270; 269, 271; 270, identifier:broadcast_indices; 271, argument_list; 271, 272; 271, 273; 271, 274; 271, 275; 272, identifier:xp; 273, identifier:minv2; 274, identifier:ndim; 275, identifier:axis; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:below; 279, call; 279, 280; 279, 281; 280, identifier:broadcast_indices; 281, argument_list; 281, 282; 281, 283; 281, 286; 281, 287; 282, identifier:xp; 283, binary_operator:-; 283, 284; 283, 285; 284, identifier:minv2; 285, integer:1; 286, identifier:ndim; 287, identifier:axis; 288, if_statement; 288, 289; 288, 299; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:np; 292, identifier:any; 293, argument_list; 293, 294; 294, comparison_operator:<; 294, 295; 294, 296; 295, identifier:x_array; 296, subscript; 296, 297; 296, 298; 297, identifier:xp; 298, identifier:below; 299, block; 299, 300; 300, expression_statement; 300, 301; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:warnings; 304, identifier:warn; 305, argument_list; 305, 306; 306, string:'Interpolation point out of data bounds encountered'; 307, comment; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 311; 310, identifier:ret; 311, list:[]; 312, comment; 313, for_statement; 313, 314; 313, 315; 313, 316; 313, 317; 313, 318; 313, 319; 314, identifier:var; 315, identifier:variables; 316, comment; 317, comment; 318, comment; 319, block; 319, 320; 319, 352; 319, 353; 319, 365; 319, 375; 319, 376; 319, 410; 319, 411; 320, expression_statement; 320, 321; 321, assignment; 321, 322; 321, 323; 322, identifier:var_interp; 323, binary_operator:+; 323, 324; 323, 327; 324, subscript; 324, 325; 324, 326; 325, identifier:var; 326, identifier:below; 327, binary_operator:*; 327, 328; 327, 336; 328, parenthesized_expression; 328, 329; 329, binary_operator:-; 329, 330; 329, 333; 330, subscript; 330, 331; 330, 332; 331, identifier:var; 332, identifier:above; 333, subscript; 333, 334; 333, 335; 334, identifier:var; 335, identifier:below; 336, parenthesized_expression; 336, 337; 337, binary_operator:/; 337, 338; 337, 344; 338, parenthesized_expression; 338, 339; 339, binary_operator:-; 339, 340; 339, 341; 340, identifier:x_array; 341, subscript; 341, 342; 341, 343; 342, identifier:xp; 343, identifier:below; 344, parenthesized_expression; 344, 345; 345, binary_operator:-; 345, 346; 345, 349; 346, subscript; 346, 347; 346, 348; 347, identifier:xp; 348, identifier:above; 349, subscript; 349, 350; 349, 351; 350, identifier:xp; 351, identifier:below; 352, comment; 353, expression_statement; 353, 354; 354, assignment; 354, 355; 354, 364; 355, subscript; 355, 356; 355, 357; 356, identifier:var_interp; 357, comparison_operator:==; 357, 358; 357, 359; 358, identifier:minv; 359, subscript; 359, 360; 359, 363; 360, attribute; 360, 361; 360, 362; 361, identifier:xp; 362, identifier:shape; 363, identifier:axis; 364, identifier:fill_value; 365, expression_statement; 365, 366; 366, assignment; 366, 367; 366, 374; 367, subscript; 367, 368; 367, 369; 368, identifier:var_interp; 369, comparison_operator:<; 369, 370; 369, 371; 370, identifier:x_array; 371, subscript; 371, 372; 371, 373; 372, identifier:xp; 373, identifier:below; 374, identifier:fill_value; 375, comment; 376, if_statement; 376, 377; 376, 385; 377, comparison_operator:>; 377, 378; 377, 381; 378, subscript; 378, 379; 378, 380; 379, identifier:x; 380, integer:0; 381, subscript; 381, 382; 381, 383; 382, identifier:x; 383, unary_operator:-; 383, 384; 384, integer:1; 385, block; 385, 386; 386, expression_statement; 386, 387; 387, assignment; 387, 388; 387, 389; 388, identifier:var_interp; 389, call; 389, 390; 389, 393; 390, attribute; 390, 391; 390, 392; 391, identifier:np; 392, identifier:swapaxes; 393, argument_list; 393, 394; 393, 408; 393, 409; 394, subscript; 394, 395; 394, 403; 395, call; 395, 396; 395, 399; 396, attribute; 396, 397; 396, 398; 397, identifier:np; 398, identifier:swapaxes; 399, argument_list; 399, 400; 399, 401; 399, 402; 400, identifier:var_interp; 401, integer:0; 402, identifier:axis; 403, slice; 403, 404; 403, 405; 403, 406; 404, colon; 405, colon; 406, unary_operator:-; 406, 407; 407, integer:1; 408, integer:0; 409, identifier:axis; 410, comment; 411, expression_statement; 411, 412; 412, call; 412, 413; 412, 416; 413, attribute; 413, 414; 413, 415; 414, identifier:ret; 415, identifier:append; 416, argument_list; 416, 417; 417, identifier:var_interp; 418, if_statement; 418, 419; 418, 425; 418, 430; 419, comparison_operator:==; 419, 420; 419, 424; 420, call; 420, 421; 420, 422; 421, identifier:len; 422, argument_list; 422, 423; 423, identifier:ret; 424, integer:1; 425, block; 425, 426; 426, return_statement; 426, 427; 427, subscript; 427, 428; 427, 429; 428, identifier:ret; 429, integer:0; 430, else_clause; 430, 431; 431, block; 431, 432; 432, return_statement; 432, 433; 433, identifier:ret | def interpolate_1d(x, xp, *args, **kwargs):
r"""Interpolates data with any shape over a specified axis.
Interpolation over a specified axis for arrays of any shape.
Parameters
----------
x : array-like
1-D array of desired interpolated values.
xp : array-like
The x-coordinates of the data points.
args : array-like
The data to be interpolated. Can be multiple arguments, all must be the same shape as
xp.
axis : int, optional
The axis to interpolate over. Defaults to 0.
fill_value: float, optional
Specify handling of interpolation points out of data bounds. If None, will return
ValueError if points are out of bounds. Defaults to nan.
Returns
-------
array-like
Interpolated values for each point with coordinates sorted in ascending order.
Examples
--------
>>> x = np.array([1., 2., 3., 4.])
>>> y = np.array([1., 2., 3., 4.])
>>> x_interp = np.array([2.5, 3.5])
>>> metpy.calc.interp(x_interp, x, y)
array([2.5, 3.5])
Notes
-----
xp and args must be the same shape.
"""
# Pull out keyword args
fill_value = kwargs.pop('fill_value', np.nan)
axis = kwargs.pop('axis', 0)
# Make x an array
x = np.asanyarray(x).reshape(-1)
# Save number of dimensions in xp
ndim = xp.ndim
# Sort input data
sort_args = np.argsort(xp, axis=axis)
sort_x = np.argsort(x)
# indices for sorting
sorter = broadcast_indices(xp, sort_args, ndim, axis)
# sort xp
xp = xp[sorter]
# Ensure pressure in increasing order
variables = [arr[sorter] for arr in args]
# Make x broadcast with xp
x_array = x[sort_x]
expand = [np.newaxis] * ndim
expand[axis] = slice(None)
x_array = x_array[tuple(expand)]
# Calculate value above interpolated value
minv = np.apply_along_axis(np.searchsorted, axis, xp, x[sort_x])
minv2 = np.copy(minv)
# If fill_value is none and data is out of bounds, raise value error
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')
# Warn if interpolated values are outside data bounds, will make these the values
# at end of data range.
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
# Get indices for broadcasting arrays
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')
# Create empty output list
ret = []
# Calculate interpolation for each variable
for var in variables:
# Var needs to be on the *left* of the multiply to ensure that if it's a pint
# Quantity, it gets to control the operation--at least until we make sure
# masked arrays and pint play together better. See https://github.com/hgrecco/pint#633
var_interp = var[below] + (var[above] - var[below]) * ((x_array - xp[below])
/ (xp[above] - xp[below]))
# Set points out of bounds to fill value.
var_interp[minv == xp.shape[axis]] = fill_value
var_interp[x_array < xp[below]] = fill_value
# Check for input points in decreasing order and return output to match.
if x[0] > x[-1]:
var_interp = np.swapaxes(np.swapaxes(var_interp, 0, axis)[::-1], 0, axis)
# Output to list
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, 14; 10, 26; 10, 36; 10, 37; 10, 46; 10, 55; 11, expression_statement; 11, 12; 12, comment; 13, comment; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:fill_value; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:kwargs; 20, identifier:pop; 21, argument_list; 21, 22; 21, 23; 22, string:'fill_value'; 23, attribute; 23, 24; 23, 25; 24, identifier:np; 25, identifier:nan; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:axis; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:kwargs; 32, identifier:pop; 33, argument_list; 33, 34; 33, 35; 34, string:'axis'; 35, integer:0; 36, comment; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:log_x; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:np; 43, identifier:log; 44, argument_list; 44, 45; 45, identifier:x; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:log_xp; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:np; 52, identifier:log; 53, argument_list; 53, 54; 54, identifier:xp; 55, return_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:interpolate_1d; 58, argument_list; 58, 59; 58, 60; 58, 61; 58, 63; 58, 66; 59, identifier:log_x; 60, identifier:log_xp; 61, list_splat; 61, 62; 62, identifier:args; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:axis; 65, identifier:axis; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:fill_value; 68, identifier:fill_value | def log_interpolate_1d(x, xp, *args, **kwargs):
r"""Interpolates data with logarithmic x-scale over a specified axis.
Interpolation on a logarithmic x-scale for interpolation values in pressure coordintates.
Parameters
----------
x : array-like
1-D array of desired interpolated values.
xp : array-like
The x-coordinates of the data points.
args : array-like
The data to be interpolated. Can be multiple arguments, all must be the same shape as
xp.
axis : int, optional
The axis to interpolate over. Defaults to 0.
fill_value: float, optional
Specify handling of interpolation points out of data bounds. If None, will return
ValueError if points are out of bounds. Defaults to nan.
Returns
-------
array-like
Interpolated values for each point with coordinates sorted in ascending order.
Examples
--------
>>> x_log = np.array([1e3, 1e4, 1e5, 1e6])
>>> y_log = np.log(x_log) * 2 + 3
>>> x_interp = np.array([5e3, 5e4, 5e5])
>>> metpy.calc.log_interp(x_interp, x_log, y_log)
array([20.03438638, 24.63955657, 29.24472675])
Notes
-----
xp and args must be the same shape.
"""
# Pull out kwargs
fill_value = kwargs.pop('fill_value', np.nan)
axis = kwargs.pop('axis', 0)
# Log x and xp
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, 10; 6, 40; 6, 51; 6, 62; 6, 63; 6, 72; 6, 78; 6, 84; 6, 85; 6, 100; 6, 106; 6, 112; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:crossings; 13, call; 13, 14; 13, 15; 14, identifier:find_intersections; 15, argument_list; 15, 16; 15, 21; 15, 26; 16, subscript; 16, 17; 16, 18; 17, identifier:x; 18, slice; 18, 19; 18, 20; 19, integer:1; 20, colon; 21, subscript; 21, 22; 21, 23; 22, identifier:y; 23, slice; 23, 24; 23, 25; 24, integer:1; 25, colon; 26, binary_operator:*; 26, 27; 26, 37; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:np; 30, identifier:zeros_like; 31, argument_list; 31, 32; 32, subscript; 32, 33; 32, 34; 33, identifier:y; 34, slice; 34, 35; 34, 36; 35, integer:1; 36, colon; 37, attribute; 37, 38; 37, 39; 38, identifier:y; 39, identifier:units; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:x; 43, call; 43, 44; 43, 45; 44, identifier:concatenate; 45, argument_list; 45, 46; 46, tuple; 46, 47; 46, 48; 47, identifier:x; 48, subscript; 48, 49; 48, 50; 49, identifier:crossings; 50, integer:0; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:y; 54, call; 54, 55; 54, 56; 55, identifier:concatenate; 56, argument_list; 56, 57; 57, tuple; 57, 58; 57, 59; 58, identifier:y; 59, subscript; 59, 60; 59, 61; 60, identifier:crossings; 61, integer:1; 62, comment; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:sort_idx; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:np; 69, identifier:argsort; 70, argument_list; 70, 71; 71, identifier:x; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:x; 75, subscript; 75, 76; 75, 77; 76, identifier:x; 77, identifier:sort_idx; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:y; 81, subscript; 81, 82; 81, 83; 82, identifier:y; 83, identifier:sort_idx; 84, comment; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:keep_idx; 88, comparison_operator:>; 88, 89; 88, 99; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:np; 92, identifier:ediff1d; 93, argument_list; 93, 94; 93, 95; 94, identifier:x; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:to_end; 97, list:[1]; 97, 98; 98, integer:1; 99, integer:0; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:x; 103, subscript; 103, 104; 103, 105; 104, identifier:x; 105, identifier:keep_idx; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:y; 109, subscript; 109, 110; 109, 111; 110, identifier:y; 111, identifier:keep_idx; 112, return_statement; 112, 113; 113, expression_list; 113, 114; 113, 115; 114, identifier:x; 115, identifier:y | def _find_append_zero_crossings(x, y):
r"""
Find and interpolate zero crossings.
Estimate the zero crossings of an x,y series and add estimated crossings to series,
returning a sorted array with no duplicate values.
Parameters
----------
x : `pint.Quantity`
x values of data
y : `pint.Quantity`
y values of data
Returns
-------
x : `pint.Quantity`
x values of data
y : `pint.Quantity`
y values of data
"""
# Find and append crossings to the data
crossings = find_intersections(x[1:], y[1:], np.zeros_like(y[1:]) * y.units)
x = concatenate((x, crossings[0]))
y = concatenate((y, crossings[1]))
# Resort so that data are in order
sort_idx = np.argsort(x)
x = x[sort_idx]
y = y[sort_idx]
# Remove duplicate data points if there are any
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; 11, 14; 12, expression_statement; 12, 13; 13, comment; 14, return_statement; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:sorted; 17, argument_list; 17, 18; 17, 19; 18, identifier:items; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:key; 21, lambda; 21, 22; 21, 24; 22, lambda_parameters; 22, 23; 23, identifier:x; 24, call; 24, 25; 24, 26; 25, identifier:getattr; 26, argument_list; 26, 27; 26, 31; 26, 34; 27, call; 27, 28; 27, 29; 28, identifier:getter; 29, argument_list; 29, 30; 30, identifier:x; 31, attribute; 31, 32; 31, 33; 32, identifier:OrderedBase; 33, identifier:CREATION_COUNTER_FIELD; 34, unary_operator:-; 34, 35; 35, integer:1 | def sort_ordered_objects(items, getter=lambda x: x):
"""Sort an iterable of OrderedBase instances.
Args:
items (iterable): the objects to sort
getter (callable or None): a function to extract the OrderedBase instance from an object.
Examples:
>>> sort_ordered_objects([x, y, z])
>>> sort_ordered_objects(v.items(), getter=lambda e: e[1])
"""
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, 8; 5, 25; 5, 31; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:all_nodes; 11, call; 11, 12; 11, 17; 12, attribute; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:parser; 16, identifier:getElementsByTags; 17, argument_list; 17, 18; 17, 23; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:get_top_node; 22, argument_list; 23, list:['*']; 23, 24; 24, string:'*'; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:all_nodes; 29, identifier:reverse; 30, argument_list; 31, for_statement; 31, 32; 31, 33; 31, 34; 32, identifier:el; 33, identifier:all_nodes; 34, block; 34, 35; 34, 46; 34, 57; 34, 77; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:tag; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:parser; 43, identifier:getTag; 44, argument_list; 44, 45; 45, identifier:el; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:text; 49, call; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:parser; 54, identifier:getText; 55, argument_list; 55, 56; 56, identifier:el; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:stop_words; 60, call; 60, 61; 60, 75; 61, attribute; 61, 62; 61, 74; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:stopwords_class; 66, argument_list; 66, 67; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:language; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:get_language; 73, argument_list; 74, identifier:get_stopword_count; 75, argument_list; 75, 76; 76, identifier:text; 77, if_statement; 77, 78; 77, 130; 77, 140; 77, 141; 77, 142; 78, boolean_operator:and; 78, 79; 78, 113; 78, 114; 79, boolean_operator:and; 79, 80; 79, 96; 79, 97; 80, boolean_operator:and; 80, 81; 80, 89; 81, parenthesized_expression; 81, 82; 82, boolean_operator:or; 82, 83; 82, 86; 83, comparison_operator:!=; 83, 84; 83, 85; 84, identifier:tag; 85, string:'br'; 86, comparison_operator:!=; 86, 87; 86, 88; 87, identifier:text; 88, string:'\\r'; 89, comparison_operator:<; 89, 90; 89, 95; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:stop_words; 93, identifier:get_stopword_count; 94, argument_list; 95, integer:3; 96, line_continuation:\; 97, comparison_operator:==; 97, 98; 97, 112; 98, call; 98, 99; 98, 100; 99, identifier:len; 100, argument_list; 100, 101; 101, call; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:parser; 106, identifier:getElementsByTag; 107, argument_list; 107, 108; 107, 109; 108, identifier:el; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:tag; 111, string:'object'; 112, integer:0; 113, line_continuation:\; 114, comparison_operator:==; 114, 115; 114, 129; 115, call; 115, 116; 115, 117; 116, identifier:len; 117, argument_list; 117, 118; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:parser; 123, identifier:getElementsByTag; 124, argument_list; 124, 125; 124, 126; 125, identifier:el; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:tag; 128, string:'embed'; 129, integer:0; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 138; 133, attribute; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:self; 136, identifier:parser; 137, identifier:remove; 138, argument_list; 138, 139; 139, identifier:el; 140, comment; 141, comment; 142, else_clause; 142, 143; 143, block; 143, 144; 143, 155; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:trimmed; 147, call; 147, 148; 147, 153; 148, attribute; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:parser; 152, identifier:getText; 153, argument_list; 153, 154; 154, identifier:el; 155, if_statement; 155, 156; 155, 169; 156, boolean_operator:and; 156, 157; 156, 163; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:trimmed; 160, identifier:startswith; 161, argument_list; 161, 162; 162, string:"("; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:trimmed; 166, identifier:endswith; 167, argument_list; 167, 168; 168, string:")"; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 177; 172, attribute; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:parser; 176, identifier:remove; 177, argument_list; 177, 178; 178, identifier:el | def remove_fewwords_paragraphs(self):
"""\
remove paragraphs that have less than x number of words,
would indicate that it's some sort of link
"""
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)
# TODO
# check if it is in the right place
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, 9; 6, 16; 6, 23; 6, 30; 6, 35; 6, 40; 6, 41; 6, 49; 6, 56; 6, 60; 6, 67; 7, expression_statement; 7, 8; 8, comment; 9, if_statement; 9, 10; 9, 13; 10, comparison_operator:==; 10, 11; 10, 12; 11, identifier:old_baseline_filename; 12, identifier:new_baseline_filename; 13, block; 13, 14; 14, raise_statement; 14, 15; 15, identifier:RedundantComparisonError; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:old_baseline; 19, call; 19, 20; 19, 21; 20, identifier:_get_baseline_from_file; 21, argument_list; 21, 22; 22, identifier:old_baseline_filename; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:new_baseline; 26, call; 26, 27; 26, 28; 27, identifier:_get_baseline_from_file; 28, argument_list; 28, 29; 29, identifier:new_baseline_filename; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:_remove_nonexistent_files_from_baseline; 33, argument_list; 33, 34; 34, identifier:old_baseline; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:_remove_nonexistent_files_from_baseline; 38, argument_list; 38, 39; 39, identifier:new_baseline; 40, comment; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:secrets_to_compare; 44, call; 44, 45; 44, 46; 45, identifier:_get_secrets_to_compare; 46, argument_list; 46, 47; 46, 48; 47, identifier:old_baseline; 48, identifier:new_baseline; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:total_reviews; 52, call; 52, 53; 52, 54; 53, identifier:len; 54, argument_list; 54, 55; 55, identifier:secrets_to_compare; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:current_index; 59, integer:0; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:secret_iterator; 63, call; 63, 64; 63, 65; 64, identifier:BidirectionalIterator; 65, argument_list; 65, 66; 66, identifier:secrets_to_compare; 67, for_statement; 67, 68; 67, 72; 67, 73; 68, pattern_list; 68, 69; 68, 70; 68, 71; 69, identifier:filename; 70, identifier:secret; 71, identifier:is_removed; 72, identifier:secret_iterator; 73, block; 73, 74; 73, 78; 73, 82; 73, 86; 73, 157; 73, 202; 73, 213; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:_clear_screen; 77, argument_list; 78, expression_statement; 78, 79; 79, augmented_assignment:+=; 79, 80; 79, 81; 80, identifier:current_index; 81, integer:1; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:header; 85, string:'{} {}'; 86, if_statement; 86, 87; 86, 88; 86, 122; 87, identifier:is_removed; 88, block; 88, 89; 88, 95; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:plugins_used; 92, subscript; 92, 93; 92, 94; 93, identifier:old_baseline; 94, string:'plugins_used'; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:header; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:header; 101, identifier:format; 102, argument_list; 102, 103; 102, 110; 103, call; 103, 104; 103, 105; 104, identifier:colorize; 105, argument_list; 105, 106; 105, 107; 106, string:'Status:'; 107, attribute; 107, 108; 107, 109; 108, identifier:AnsiColor; 109, identifier:BOLD; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, string:'>> {} <<'; 113, identifier:format; 114, argument_list; 114, 115; 115, call; 115, 116; 115, 117; 116, identifier:colorize; 117, argument_list; 117, 118; 117, 119; 118, string:'REMOVED'; 119, attribute; 119, 120; 119, 121; 120, identifier:AnsiColor; 121, identifier:RED; 122, else_clause; 122, 123; 123, block; 123, 124; 123, 130; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:plugins_used; 127, subscript; 127, 128; 127, 129; 128, identifier:new_baseline; 129, string:'plugins_used'; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:header; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:header; 136, identifier:format; 137, argument_list; 137, 138; 137, 145; 138, call; 138, 139; 138, 140; 139, identifier:colorize; 140, argument_list; 140, 141; 140, 142; 141, string:'Status:'; 142, attribute; 142, 143; 142, 144; 143, identifier:AnsiColor; 144, identifier:BOLD; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, string:'>> {} <<'; 148, identifier:format; 149, argument_list; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:colorize; 152, argument_list; 152, 153; 152, 154; 153, string:'ADDED'; 154, attribute; 154, 155; 154, 156; 155, identifier:AnsiColor; 156, identifier:LIGHT_GREEN; 157, try_statement; 157, 158; 157, 190; 158, block; 158, 159; 158, 174; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:_print_context; 162, argument_list; 162, 163; 162, 164; 162, 165; 162, 166; 162, 167; 162, 168; 162, 171; 163, identifier:filename; 164, identifier:secret; 165, identifier:current_index; 166, identifier:total_reviews; 167, identifier:plugins_used; 168, keyword_argument; 168, 169; 168, 170; 169, identifier:additional_header_lines; 170, identifier:header; 171, keyword_argument; 171, 172; 171, 173; 172, identifier:force; 173, identifier:is_removed; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:decision; 177, call; 177, 178; 177, 179; 178, identifier:_get_user_decision; 179, argument_list; 179, 180; 179, 187; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:can_step_back; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:secret_iterator; 185, identifier:can_step_back; 186, argument_list; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:prompt_secret_decision; 189, False; 190, except_clause; 190, 191; 190, 192; 191, identifier:SecretNotFoundOnSpecifiedLineError; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:decision; 196, call; 196, 197; 196, 198; 197, identifier:_get_user_decision; 198, argument_list; 198, 199; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:prompt_secret_decision; 201, False; 202, if_statement; 202, 203; 202, 206; 203, comparison_operator:==; 203, 204; 203, 205; 204, identifier:decision; 205, string:'q'; 206, block; 206, 207; 206, 212; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 210; 209, identifier:print; 210, argument_list; 210, 211; 211, string:'Quitting...'; 212, break_statement; 213, if_statement; 213, 214; 213, 217; 213, 218; 214, comparison_operator:==; 214, 215; 214, 216; 215, identifier:decision; 216, string:'b'; 217, comment; 218, block; 218, 219; 218, 223; 219, expression_statement; 219, 220; 220, augmented_assignment:-=; 220, 221; 220, 222; 221, identifier:current_index; 222, integer:2; 223, expression_statement; 223, 224; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:secret_iterator; 227, identifier:step_back_on_next_iteration; 228, argument_list | def compare_baselines(old_baseline_filename, new_baseline_filename):
"""
This function enables developers to more easily configure plugin
settings, by comparing two generated baselines and highlighting
their differences.
For effective use, a few assumptions are made:
1. Baselines are sorted by (filename, line_number, hash).
This allows for a deterministic order, when doing a side-by-side
comparison.
2. Baselines are generated for the same codebase snapshot.
This means that we won't have cases where secrets are moved around;
only added or removed.
NOTE: We don't want to do a version check, because we want to be able to
use this functionality across versions (to see how the new version fares
compared to the old one).
"""
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)
# We aggregate the secrets first, so that we can display a total count.
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': # pragma: no cover
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, 9; 6, 13; 6, 24; 6, 31; 6, 153; 6, 154; 6, 155; 6, 193; 6, 203; 6, 212; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:attributes; 12, list:[]; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:attribute_string; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, string:'data_type: {0:s}'; 19, identifier:format; 20, argument_list; 20, 21; 21, attribute; 21, 22; 21, 23; 22, identifier:event; 23, identifier:data_type; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:attributes; 28, identifier:append; 29, argument_list; 29, 30; 30, identifier:attribute_string; 31, for_statement; 31, 32; 31, 35; 31, 43; 32, pattern_list; 32, 33; 32, 34; 33, identifier:attribute_name; 34, identifier:attribute_value; 35, call; 35, 36; 35, 37; 36, identifier:sorted; 37, argument_list; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:event; 41, identifier:GetAttributes; 42, argument_list; 43, block; 43, 44; 43, 52; 43, 57; 43, 119; 43, 146; 44, if_statement; 44, 45; 44, 50; 45, comparison_operator:in; 45, 46; 45, 47; 46, identifier:attribute_name; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_IDENTIFIER_EXCLUDED_ATTRIBUTES; 50, block; 50, 51; 51, continue_statement; 52, if_statement; 52, 53; 52, 55; 53, not_operator; 53, 54; 54, identifier:attribute_value; 55, block; 55, 56; 56, continue_statement; 57, if_statement; 57, 58; 57, 61; 57, 68; 57, 86; 57, 103; 58, comparison_operator:==; 58, 59; 58, 60; 59, identifier:attribute_name; 60, string:'pathspec'; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:attribute_value; 65, attribute; 65, 66; 65, 67; 66, identifier:attribute_value; 67, identifier:comparable; 68, elif_clause; 68, 69; 68, 74; 69, call; 69, 70; 69, 71; 70, identifier:isinstance; 71, argument_list; 71, 72; 71, 73; 72, identifier:attribute_value; 73, identifier:dict; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:attribute_value; 78, call; 78, 79; 78, 80; 79, identifier:sorted; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:attribute_value; 84, identifier:items; 85, argument_list; 86, elif_clause; 86, 87; 86, 92; 87, call; 87, 88; 87, 89; 88, identifier:isinstance; 89, argument_list; 89, 90; 89, 91; 90, identifier:attribute_value; 91, identifier:set; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:attribute_value; 96, call; 96, 97; 96, 98; 97, identifier:sorted; 98, argument_list; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:list; 101, argument_list; 101, 102; 102, identifier:attribute_value; 103, elif_clause; 103, 104; 103, 111; 104, call; 104, 105; 104, 106; 105, identifier:isinstance; 106, argument_list; 106, 107; 106, 108; 107, identifier:attribute_value; 108, attribute; 108, 109; 108, 110; 109, identifier:py2to3; 110, identifier:BYTES_TYPE; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:attribute_value; 115, call; 115, 116; 115, 117; 116, identifier:repr; 117, argument_list; 117, 118; 118, identifier:attribute_value; 119, try_statement; 119, 120; 119, 131; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:attribute_string; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, string:'{0:s}: {1!s}'; 127, identifier:format; 128, argument_list; 128, 129; 128, 130; 129, identifier:attribute_name; 130, identifier:attribute_value; 131, except_clause; 131, 132; 131, 133; 132, identifier:UnicodeDecodeError; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:logger; 138, identifier:error; 139, argument_list; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, string:'Failed to decode attribute {0:s}'; 143, identifier:format; 144, argument_list; 144, 145; 145, identifier:attribute_name; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:attributes; 150, identifier:append; 151, argument_list; 151, 152; 152, identifier:attribute_string; 153, comment; 154, comment; 155, if_statement; 155, 156; 155, 177; 155, 187; 156, comparison_operator:in; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:event; 159, identifier:timestamp_desc; 160, tuple; 160, 161; 160, 162; 160, 163; 160, 164; 160, 165; 160, 168; 160, 171; 160, 174; 161, string:'atime'; 162, string:'ctime'; 163, string:'crtime'; 164, string:'mtime'; 165, attribute; 165, 166; 165, 167; 166, identifier:definitions; 167, identifier:TIME_DESCRIPTION_LAST_ACCESS; 168, attribute; 168, 169; 168, 170; 169, identifier:definitions; 170, identifier:TIME_DESCRIPTION_CHANGE; 171, attribute; 171, 172; 171, 173; 172, identifier:definitions; 173, identifier:TIME_DESCRIPTION_CREATION; 174, attribute; 174, 175; 174, 176; 175, identifier:definitions; 176, identifier:TIME_DESCRIPTION_MODIFICATION; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:macb_group_identifier; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, string:', '; 184, identifier:join; 185, argument_list; 185, 186; 186, identifier:attributes; 187, else_clause; 187, 188; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:macb_group_identifier; 192, None; 193, expression_statement; 193, 194; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:attributes; 197, identifier:insert; 198, argument_list; 198, 199; 198, 200; 199, integer:0; 200, attribute; 200, 201; 200, 202; 201, identifier:event; 202, identifier:timestamp_desc; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:content_identifier; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, string:', '; 209, identifier:join; 210, argument_list; 210, 211; 211, identifier:attributes; 212, return_statement; 212, 213; 213, expression_list; 213, 214; 213, 215; 214, identifier:macb_group_identifier; 215, identifier:content_identifier | def _GetEventIdentifiers(self, event):
"""Retrieves different identifiers of the event.
Every event contains event data, which consists of attributes and values.
These attributes and values can be represented as a string and used for
sorting and uniquely identifying events. This function determines multiple
identifiers:
* an identifier of the attributes and values without the timestamp
description (or usage). This is referred to as the MACB group
identifier.
* an identifier of the attributes and values including the timestamp
description (or usage). This is referred to as the event content
identifier.
The identifier without the timestamp description can be used to group
events that have the same MACB (modification, access, change, birth)
timestamps. The PsortEventHeap will store these events individually and
relies on PsortMultiProcessEngine to do the actual grouping of events.
Args:
event (EventObject): event.
Returns:
tuple: containing:
str: identifier of the event MACB group or None if the event cannot
be grouped.
str: identifier of the event content.
"""
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)
# The 'atime', 'ctime', 'crtime', 'mtime' are included for backwards
# compatibility with the filestat parser.
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, 8; 5, 16; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:event; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:PopEvent; 15, argument_list; 16, while_statement; 16, 17; 16, 18; 17, identifier:event; 18, block; 18, 19; 18, 22; 19, expression_statement; 19, 20; 20, yield; 20, 21; 21, identifier:event; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:event; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:PopEvent; 29, argument_list | def PopEvents(self):
"""Pops events from the heap.
Yields:
EventObject: event.
"""
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, 9; 6, 10; 6, 11; 6, 18; 6, 268; 6, 277; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, comment; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:_RaiseIfNotRegistered; 16, argument_list; 16, 17; 17, identifier:pid; 18, if_statement; 18, 19; 18, 24; 18, 42; 19, comparison_operator:in; 19, 20; 19, 21; 20, identifier:pid; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_completed_analysis_processes; 24, block; 24, 25; 24, 31; 24, 38; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:status_indicator; 28, attribute; 28, 29; 28, 30; 29, identifier:definitions; 30, identifier:STATUS_INDICATOR_COMPLETED; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:process_status; 34, dictionary; 34, 35; 35, pair; 35, 36; 35, 37; 36, string:'processing_status'; 37, identifier:status_indicator; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:used_memory; 41, integer:0; 42, else_clause; 42, 43; 43, block; 43, 44; 43, 52; 43, 61; 43, 76; 43, 84; 43, 94; 43, 133; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:process; 47, subscript; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:_processes_per_pid; 51, identifier:pid; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:process_status; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_QueryProcessStatus; 59, argument_list; 59, 60; 60, identifier:process; 61, if_statement; 61, 62; 61, 65; 61, 70; 62, comparison_operator:is; 62, 63; 62, 64; 63, identifier:process_status; 64, None; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:process_is_alive; 69, False; 70, else_clause; 70, 71; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:process_is_alive; 75, True; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:process_information; 79, subscript; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:_process_information_per_pid; 83, identifier:pid; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:used_memory; 87, boolean_operator:or; 87, 88; 87, 93; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:process_information; 91, identifier:GetUsedMemory; 92, argument_list; 93, integer:0; 94, if_statement; 94, 95; 94, 104; 95, boolean_operator:and; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:_worker_memory_limit; 99, comparison_operator:>; 99, 100; 99, 101; 100, identifier:used_memory; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:_worker_memory_limit; 104, block; 104, 105; 104, 126; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:logger; 109, identifier:warning; 110, argument_list; 110, 111; 111, call; 111, 112; 111, 118; 112, attribute; 112, 113; 112, 117; 113, parenthesized_expression; 113, 114; 114, concatenated_string; 114, 115; 114, 116; 115, string:'Process: {0:s} (PID: {1:d}) killed because it exceeded the '; 116, string:'memory limit: {2:d}.'; 117, identifier:format; 118, argument_list; 118, 119; 118, 122; 118, 123; 119, attribute; 119, 120; 119, 121; 120, identifier:process; 121, identifier:name; 122, identifier:pid; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:_worker_memory_limit; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:_KillProcess; 131, argument_list; 131, 132; 132, identifier:pid; 133, if_statement; 133, 134; 133, 139; 133, 174; 134, call; 134, 135; 134, 136; 135, identifier:isinstance; 136, argument_list; 136, 137; 136, 138; 137, identifier:process_status; 138, identifier:dict; 139, block; 139, 140; 139, 148; 139, 158; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 147; 142, subscript; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:_rpc_errors_per_pid; 146, identifier:pid; 147, integer:0; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:status_indicator; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:process_status; 154, identifier:get; 155, argument_list; 155, 156; 155, 157; 156, string:'processing_status'; 157, None; 158, if_statement; 158, 159; 158, 164; 159, comparison_operator:==; 159, 160; 159, 161; 160, identifier:status_indicator; 161, attribute; 161, 162; 161, 163; 162, identifier:definitions; 163, identifier:STATUS_INDICATOR_COMPLETED; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, call; 166, 167; 166, 172; 167, attribute; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:_completed_analysis_processes; 171, identifier:add; 172, argument_list; 172, 173; 173, identifier:pid; 174, else_clause; 174, 175; 175, block; 175, 176; 175, 190; 175, 198; 175, 209; 175, 261; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:rpc_errors; 179, binary_operator:+; 179, 180; 179, 189; 180, call; 180, 181; 180, 186; 181, attribute; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:self; 184, identifier:_rpc_errors_per_pid; 185, identifier:get; 186, argument_list; 186, 187; 186, 188; 187, identifier:pid; 188, integer:0; 189, integer:1; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 197; 192, subscript; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:self; 195, identifier:_rpc_errors_per_pid; 196, identifier:pid; 197, identifier:rpc_errors; 198, if_statement; 198, 199; 198, 204; 199, comparison_operator:>; 199, 200; 199, 201; 200, identifier:rpc_errors; 201, attribute; 201, 202; 201, 203; 202, identifier:self; 203, identifier:_MAXIMUM_RPC_ERRORS; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:process_is_alive; 208, False; 209, if_statement; 209, 210; 209, 211; 209, 249; 210, identifier:process_is_alive; 211, block; 211, 212; 211, 220; 211, 239; 211, 243; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:rpc_port; 215, attribute; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:process; 218, identifier:rpc_port; 219, identifier:value; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:logger; 224, identifier:warning; 225, argument_list; 225, 226; 226, call; 226, 227; 226, 233; 227, attribute; 227, 228; 227, 232; 228, parenthesized_expression; 228, 229; 229, concatenated_string; 229, 230; 229, 231; 230, string:'Unable to retrieve process: {0:s} (PID: {1:d}) status via '; 231, string:'RPC socket: http://localhost:{2:d}'; 232, identifier:format; 233, argument_list; 233, 234; 233, 237; 233, 238; 234, attribute; 234, 235; 234, 236; 235, identifier:process; 236, identifier:name; 237, identifier:pid; 238, identifier:rpc_port; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:processing_status_string; 242, string:'RPC error'; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:status_indicator; 246, attribute; 246, 247; 246, 248; 247, identifier:definitions; 248, identifier:STATUS_INDICATOR_RUNNING; 249, else_clause; 249, 250; 250, block; 250, 251; 250, 255; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:processing_status_string; 254, string:'killed'; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:status_indicator; 258, attribute; 258, 259; 258, 260; 259, identifier:definitions; 260, identifier:STATUS_INDICATOR_KILLED; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:process_status; 264, dictionary; 264, 265; 265, pair; 265, 266; 265, 267; 266, string:'processing_status'; 267, identifier:processing_status_string; 268, expression_statement; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:self; 272, identifier:_UpdateProcessingStatus; 273, argument_list; 273, 274; 273, 275; 273, 276; 274, identifier:pid; 275, identifier:process_status; 276, identifier:used_memory; 277, if_statement; 277, 278; 277, 283; 278, comparison_operator:in; 278, 279; 278, 280; 279, identifier:status_indicator; 280, attribute; 280, 281; 280, 282; 281, identifier:definitions; 282, identifier:ERROR_STATUS_INDICATORS; 283, block; 283, 284; 283, 303; 284, expression_statement; 284, 285; 285, call; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:logger; 288, identifier:error; 289, argument_list; 289, 290; 290, call; 290, 291; 290, 297; 291, attribute; 291, 292; 291, 296; 292, parenthesized_expression; 292, 293; 293, concatenated_string; 293, 294; 293, 295; 294, string:'Process {0:s} (PID: {1:d}) is not functioning correctly. '; 295, string:'Status code: {2!s}.'; 296, identifier:format; 297, argument_list; 297, 298; 297, 301; 297, 302; 298, attribute; 298, 299; 298, 300; 299, identifier:process; 300, identifier:name; 301, identifier:pid; 302, identifier:status_indicator; 303, expression_statement; 303, 304; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:self; 307, identifier:_TerminateProcessByPid; 308, argument_list; 308, 309; 309, identifier:pid | def _CheckStatusAnalysisProcess(self, pid):
"""Checks the status of an analysis process.
Args:
pid (int): process ID (PID) of a registered analysis process.
Raises:
KeyError: if the process is not registered with the engine.
"""
# TODO: Refactor this method, simplify and separate concerns (monitoring
# vs management).
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, 13; 10, 40; 11, expression_statement; 11, 12; 12, comment; 13, if_statement; 13, 14; 13, 21; 14, comparison_operator:!=; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:event; 17, identifier:timestamp; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_export_event_timestamp; 21, block; 21, 22; 21, 32; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_FlushExportBuffer; 27, argument_list; 27, 28; 27, 29; 28, identifier:output_module; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:deduplicate_events; 31, identifier:deduplicate_events; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_export_event_timestamp; 37, attribute; 37, 38; 37, 39; 38, identifier:event; 39, identifier:timestamp; 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:_export_event_heap; 46, identifier:PushEvent; 47, argument_list; 47, 48; 48, identifier:event | def _ExportEvent(self, output_module, event, deduplicate_events=True):
"""Exports an event using an output module.
Args:
output_module (OutputModule): output module.
event (EventObject): event.
deduplicate_events (Optional[bool]): True if events should be
deduplicated.
"""
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, 12; 9, 16; 9, 20; 9, 24; 9, 34; 9, 131; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:last_macb_group_identifier; 15, None; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:last_content_identifier; 19, None; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:macb_group; 23, list:[]; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:generator; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_export_event_heap; 32, identifier:PopEvents; 33, argument_list; 34, for_statement; 34, 35; 34, 39; 34, 40; 35, pattern_list; 35, 36; 35, 37; 35, 38; 36, identifier:macb_group_identifier; 37, identifier:content_identifier; 38, identifier:event; 39, identifier:generator; 40, block; 40, 41; 40, 57; 40, 123; 40, 127; 41, if_statement; 41, 42; 41, 47; 42, boolean_operator:and; 42, 43; 42, 44; 43, identifier:deduplicate_events; 44, comparison_operator:==; 44, 45; 44, 46; 45, identifier:last_content_identifier; 46, identifier:content_identifier; 47, block; 47, 48; 47, 56; 48, expression_statement; 48, 49; 49, augmented_assignment:+=; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:_events_status; 54, identifier:number_of_duplicate_events; 55, integer:1; 56, continue_statement; 57, if_statement; 57, 58; 57, 61; 57, 83; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:macb_group_identifier; 60, None; 61, block; 61, 62; 61, 76; 62, if_statement; 62, 63; 62, 64; 63, identifier:macb_group; 64, block; 64, 65; 64, 72; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:output_module; 69, identifier:WriteEventMACBGroup; 70, argument_list; 70, 71; 71, identifier:macb_group; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:macb_group; 75, list:[]; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:output_module; 80, identifier:WriteEvent; 81, argument_list; 81, 82; 82, identifier:event; 83, else_clause; 83, 84; 84, block; 84, 85; 84, 115; 85, if_statement; 85, 86; 85, 93; 85, 101; 86, parenthesized_expression; 86, 87; 87, boolean_operator:or; 87, 88; 87, 91; 88, comparison_operator:==; 88, 89; 88, 90; 89, identifier:last_macb_group_identifier; 90, identifier:macb_group_identifier; 91, not_operator; 91, 92; 92, identifier:macb_group; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:macb_group; 98, identifier:append; 99, argument_list; 99, 100; 100, identifier:event; 101, else_clause; 101, 102; 102, block; 102, 103; 102, 110; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:output_module; 107, identifier:WriteEventMACBGroup; 108, argument_list; 108, 109; 109, identifier:macb_group; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:macb_group; 113, list:[event]; 113, 114; 114, identifier:event; 115, expression_statement; 115, 116; 116, augmented_assignment:+=; 116, 117; 116, 122; 117, attribute; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:_events_status; 121, identifier:number_of_macb_grouped_events; 122, integer:1; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:last_macb_group_identifier; 126, identifier:macb_group_identifier; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:last_content_identifier; 130, identifier:content_identifier; 131, if_statement; 131, 132; 131, 133; 132, identifier:macb_group; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:output_module; 138, identifier:WriteEventMACBGroup; 139, argument_list; 139, 140; 140, identifier:macb_group | def _FlushExportBuffer(self, output_module, deduplicate_events=True):
"""Flushes buffered events and writes them to the output module.
Args:
output_module (OutputModule): output module.
deduplicate_events (Optional[bool]): True if events should be
deduplicated.
"""
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, 10; 7, 18; 7, 26; 7, 31; 7, 32; 7, 33; 7, 45; 7, 66; 8, expression_statement; 8, 9; 9, comment; 10, if_statement; 10, 11; 10, 16; 11, comparison_operator:!=; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:attribute_container; 14, identifier:CONTAINER_TYPE; 15, string:'event_tag'; 16, block; 16, 17; 17, return_statement; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:event_identifier; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:attribute_container; 24, identifier:GetEventIdentifier; 25, argument_list; 26, if_statement; 26, 27; 26, 29; 27, not_operator; 27, 28; 28, identifier:event_identifier; 29, block; 29, 30; 30, return_statement; 31, comment; 32, comment; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:stored_event_tag; 36, call; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:_event_tag_index; 41, identifier:GetEventTagByIdentifier; 42, argument_list; 42, 43; 42, 44; 43, identifier:storage_writer; 44, identifier:event_identifier; 45, if_statement; 45, 46; 45, 47; 46, identifier:stored_event_tag; 47, block; 47, 48; 47, 57; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:attribute_container; 52, identifier:AddComment; 53, argument_list; 53, 54; 54, attribute; 54, 55; 54, 56; 55, identifier:stored_event_tag; 56, identifier:comment; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:attribute_container; 61, identifier:AddLabels; 62, argument_list; 62, 63; 63, attribute; 63, 64; 63, 65; 64, identifier:stored_event_tag; 65, identifier:labels; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:_event_tag_index; 72, identifier:SetEventTag; 73, argument_list; 73, 74; 74, identifier:attribute_container | def _MergeEventTag(self, storage_writer, attribute_container):
"""Merges an event tag with the last stored event tag.
If there is an existing event the provided event tag is updated with
the contents of the existing one. After which the event tag index is
updated.
Args:
storage_writer (StorageWriter): storage writer.
attribute_container (AttributeContainer): container.
"""
if attribute_container.CONTAINER_TYPE != 'event_tag':
return
event_identifier = attribute_container.GetEventIdentifier()
if not event_identifier:
return
# Check if the event has already been tagged on a previous occasion,
# we need to append the event tag to the last stored one.
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, 10; 7, 17; 7, 65; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:logger; 14, identifier:info; 15, argument_list; 15, 16; 16, string:'Starting analysis plugins.'; 17, for_statement; 17, 18; 17, 19; 17, 24; 18, identifier:analysis_plugin; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:analysis_plugins; 22, identifier:values; 23, argument_list; 24, block; 24, 25; 24, 35; 24, 47; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 34; 27, subscript; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:_analysis_plugins; 31, attribute; 31, 32; 31, 33; 32, identifier:analysis_plugin; 33, identifier:NAME; 34, identifier:analysis_plugin; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:process; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_StartWorkerProcess; 42, argument_list; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:analysis_plugin; 45, identifier:NAME; 46, identifier:storage_writer; 47, if_statement; 47, 48; 47, 50; 48, not_operator; 48, 49; 49, identifier:process; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:logger; 55, identifier:error; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, string:'Unable to create analysis process: {0:s}'; 60, identifier:format; 61, argument_list; 61, 62; 62, attribute; 62, 63; 62, 64; 63, identifier:analysis_plugin; 64, identifier:NAME; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:logger; 69, identifier:info; 70, argument_list; 70, 71; 71, string:'Analysis plugins running' | def _StartAnalysisProcesses(self, storage_writer, analysis_plugins):
"""Starts the analysis processes.
Args:
storage_writer (StorageWriter): storage writer.
analysis_plugins (dict[str, AnalysisPlugin]): analysis plugins that
should be run and their names.
"""
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, 11; 8, 18; 8, 24; 8, 25; 8, 26; 8, 27; 8, 37; 8, 66; 8, 67; 8, 68; 8, 92; 8, 93; 8, 104; 8, 123; 9, expression_statement; 9, 10; 10, comment; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:logger; 15, identifier:debug; 16, argument_list; 16, 17; 17, string:'Stopping analysis processes.'; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_StopMonitoringProcesses; 23, argument_list; 24, comment; 25, comment; 26, comment; 27, if_statement; 27, 28; 27, 29; 27, 30; 28, identifier:abort; 29, comment; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:_AbortTerminate; 36, argument_list; 37, if_statement; 37, 38; 37, 42; 38, not_operator; 38, 39; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_use_zeromq; 42, block; 42, 43; 42, 50; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:logger; 47, identifier:debug; 48, argument_list; 48, 49; 49, string:'Emptying queues.'; 50, for_statement; 50, 51; 50, 52; 50, 59; 51, identifier:event_queue; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:_event_queues; 57, identifier:values; 58, argument_list; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:event_queue; 64, identifier:Empty; 65, argument_list; 66, comment; 67, comment; 68, for_statement; 68, 69; 68, 70; 68, 77; 69, identifier:event_queue; 70, call; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:_event_queues; 75, identifier:values; 76, argument_list; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:event_queue; 82, identifier:PushItem; 83, argument_list; 83, 84; 83, 89; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:plaso_queue; 87, identifier:QueueAbort; 88, argument_list; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:block; 91, False; 92, comment; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:_AbortJoin; 98, argument_list; 98, 99; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:timeout; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:_PROCESS_JOIN_TIMEOUT; 104, for_statement; 104, 105; 104, 106; 104, 113; 105, identifier:event_queue; 106, call; 106, 107; 106, 112; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:_event_queues; 111, identifier:values; 112, argument_list; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:event_queue; 118, identifier:Close; 119, argument_list; 119, 120; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:abort; 122, identifier:abort; 123, if_statement; 123, 124; 123, 125; 123, 126; 123, 133; 124, identifier:abort; 125, comment; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:_AbortKill; 132, argument_list; 133, else_clause; 133, 134; 133, 135; 134, comment; 135, block; 135, 136; 135, 142; 135, 153; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:self; 140, identifier:_AbortTerminate; 141, argument_list; 142, expression_statement; 142, 143; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:_AbortJoin; 147, argument_list; 147, 148; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:timeout; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:_PROCESS_JOIN_TIMEOUT; 153, for_statement; 153, 154; 153, 155; 153, 162; 154, identifier:event_queue; 155, call; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:_event_queues; 160, identifier:values; 161, argument_list; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:event_queue; 167, identifier:Close; 168, argument_list; 168, 169; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:abort; 171, True | def _StopAnalysisProcesses(self, abort=False):
"""Stops the analysis processes.
Args:
abort (bool): True to indicated the stop is issued on abort.
"""
logger.debug('Stopping analysis processes.')
self._StopMonitoringProcesses()
# Note that multiprocessing.Queue is very sensitive regarding
# blocking on either a get or a put. So we try to prevent using
# any blocking behavior.
if abort:
# Signal all the processes to abort.
self._AbortTerminate()
if not self._use_zeromq:
logger.debug('Emptying queues.')
for event_queue in self._event_queues.values():
event_queue.Empty()
# Wake the processes to make sure that they are not blocking
# waiting for the queue new items.
for event_queue in self._event_queues.values():
event_queue.PushItem(plaso_queue.QueueAbort(), block=False)
# Try waiting for the processes to exit normally.
self._AbortJoin(timeout=self._PROCESS_JOIN_TIMEOUT)
for event_queue in self._event_queues.values():
event_queue.Close(abort=abort)
if abort:
# Kill any remaining processes.
self._AbortKill()
else:
# Check if the processes are still alive and terminate them if necessary.
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, 8; 5, 20; 5, 31; 5, 80; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:used_memory; 11, boolean_operator:or; 11, 12; 11, 19; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_process_information; 17, identifier:GetUsedMemory; 18, argument_list; 19, integer:0; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:display_name; 23, call; 23, 24; 23, 25; 24, identifier:getattr; 25, argument_list; 25, 26; 25, 29; 25, 30; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_merge_task; 29, string:'identifier'; 30, string:''; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_processing_status; 37, identifier:UpdateForemanStatus; 38, argument_list; 38, 39; 38, 42; 38, 45; 38, 48; 38, 49; 38, 50; 38, 53; 38, 56; 38, 59; 38, 62; 38, 65; 38, 68; 38, 71; 38, 74; 38, 77; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_name; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:_status; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_pid; 48, identifier:used_memory; 49, identifier:display_name; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:_number_of_consumed_sources; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:_number_of_produced_sources; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_number_of_consumed_events; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:_number_of_produced_events; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:_number_of_consumed_event_tags; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:_number_of_produced_event_tags; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:_number_of_consumed_warnings; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:_number_of_produced_warnings; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:_number_of_consumed_reports; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:_number_of_produced_reports; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:_processing_status; 86, identifier:UpdateEventsStatus; 87, argument_list; 87, 88; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:_events_status | def _UpdateForemanProcessStatus(self):
"""Update the foreman process status."""
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; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, return_statement; 8, 9; 9, list_comprehension; 9, 10; 9, 15; 10, subscript; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:_workers_status; 14, identifier:identifier; 15, for_in_clause; 15, 16; 15, 17; 16, identifier:identifier; 17, call; 17, 18; 17, 19; 18, identifier:sorted; 19, argument_list; 19, 20; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_workers_status; 25, identifier:keys; 26, argument_list | def workers_status(self):
"""The worker status objects sorted by identifier."""
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, 8; 5, 17; 5, 28; 5, 39; 5, 50; 5, 70; 5, 83; 5, 102; 5, 113; 5, 119; 5, 127; 5, 135; 5, 145; 5, 155; 5, 165; 5, 169; 5, 267; 5, 339; 5, 345; 5, 354; 5, 417; 5, 430; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_CheckStorageFile; 13, argument_list; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_storage_file_path; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_status_view; 23, identifier:SetMode; 24, argument_list; 24, 25; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_status_view_mode; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:_status_view; 34, identifier:SetStorageFileInformation; 35, argument_list; 35, 36; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:_storage_file_path; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:status_update_callback; 42, parenthesized_expression; 42, 43; 43, call; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_status_view; 48, identifier:GetAnalysisStatusUpdateCallback; 49, argument_list; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:session; 53, call; 53, 54; 53, 59; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:engine; 57, identifier:BaseEngine; 58, identifier:CreateSession; 59, argument_list; 59, 60; 59, 65; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:command_line_arguments; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:_command_line_arguments; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:preferred_encoding; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:preferred_encoding; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:storage_reader; 73, call; 73, 74; 73, 79; 74, attribute; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:storage_factory; 77, identifier:StorageFactory; 78, identifier:CreateStorageReaderForFile; 79, argument_list; 79, 80; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:_storage_file_path; 83, if_statement; 83, 84; 83, 86; 84, not_operator; 84, 85; 85, identifier:storage_reader; 86, block; 86, 87; 86, 101; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:logger; 91, identifier:error; 92, argument_list; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, string:'Format of storage file: {0:s} not supported'; 96, identifier:format; 97, argument_list; 97, 98; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:_storage_file_path; 101, return_statement; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:_number_of_analysis_reports; 107, parenthesized_expression; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:storage_reader; 111, identifier:GetNumberOfAnalysisReports; 112, argument_list; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:storage_reader; 117, identifier:Close; 118, argument_list; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:configuration; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:configurations; 125, identifier:ProcessingConfiguration; 126, argument_list; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:configuration; 131, identifier:data_location; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:_data_location; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 142; 137, attribute; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:configuration; 140, identifier:profiling; 141, identifier:directory; 142, attribute; 142, 143; 142, 144; 143, identifier:self; 144, identifier:_profiling_directory; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 152; 147, attribute; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:configuration; 150, identifier:profiling; 151, identifier:sample_rate; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:_profiling_sample_rate; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 162; 157, attribute; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:configuration; 160, identifier:profiling; 161, identifier:profilers; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:_profilers; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:analysis_counter; 168, None; 169, if_statement; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:self; 172, identifier:_analysis_plugins; 173, block; 173, 174; 173, 189; 173, 190; 173, 203; 173, 238; 173, 246; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:storage_writer; 177, parenthesized_expression; 177, 178; 178, call; 178, 179; 178, 184; 179, attribute; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:storage_factory; 182, identifier:StorageFactory; 183, identifier:CreateStorageWriterForFile; 184, argument_list; 184, 185; 184, 186; 185, identifier:session; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:_storage_file_path; 189, comment; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:analysis_engine; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:psort; 196, identifier:PsortMultiProcessEngine; 197, argument_list; 197, 198; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:use_zeromq; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:_use_zeromq; 203, expression_statement; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:analysis_engine; 207, identifier:AnalyzeEvents; 208, argument_list; 208, 209; 208, 212; 208, 213; 208, 216; 208, 219; 208, 220; 208, 225; 208, 230; 208, 233; 209, attribute; 209, 210; 209, 211; 210, identifier:self; 211, identifier:_knowledge_base; 212, identifier:storage_writer; 213, attribute; 213, 214; 213, 215; 214, identifier:self; 215, identifier:_data_location; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:_analysis_plugins; 219, identifier:configuration; 220, keyword_argument; 220, 221; 220, 222; 221, identifier:event_filter; 222, attribute; 222, 223; 222, 224; 223, identifier:self; 224, identifier:_event_filter; 225, keyword_argument; 225, 226; 225, 227; 226, identifier:event_filter_expression; 227, attribute; 227, 228; 227, 229; 228, identifier:self; 229, identifier:_event_filter_expression; 230, keyword_argument; 230, 231; 230, 232; 231, identifier:status_update_callback; 232, identifier:status_update_callback; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:worker_memory_limit; 235, attribute; 235, 236; 235, 237; 236, identifier:self; 237, identifier:_worker_memory_limit; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:analysis_counter; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:collections; 244, identifier:Counter; 245, argument_list; 246, for_statement; 246, 247; 246, 250; 246, 260; 247, pattern_list; 247, 248; 247, 249; 248, identifier:item; 249, identifier:value; 250, call; 250, 251; 250, 252; 251, identifier:iter; 252, argument_list; 252, 253; 253, call; 253, 254; 253, 259; 254, attribute; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:session; 257, identifier:analysis_reports_counter; 258, identifier:items; 259, argument_list; 260, block; 260, 261; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 266; 263, subscript; 263, 264; 263, 265; 264, identifier:analysis_counter; 265, identifier:item; 266, identifier:value; 267, if_statement; 267, 268; 267, 273; 268, comparison_operator:!=; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:self; 271, identifier:_output_format; 272, string:'null'; 273, block; 273, 274; 273, 288; 273, 289; 273, 302; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:storage_reader; 277, parenthesized_expression; 277, 278; 278, call; 278, 279; 278, 284; 279, attribute; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:storage_factory; 282, identifier:StorageFactory; 283, identifier:CreateStorageReaderForFile; 284, argument_list; 284, 285; 285, attribute; 285, 286; 285, 287; 286, identifier:self; 287, identifier:_storage_file_path; 288, comment; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 292; 291, identifier:analysis_engine; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:psort; 295, identifier:PsortMultiProcessEngine; 296, argument_list; 296, 297; 297, keyword_argument; 297, 298; 297, 299; 298, identifier:use_zeromq; 299, attribute; 299, 300; 299, 301; 300, identifier:self; 301, identifier:_use_zeromq; 302, expression_statement; 302, 303; 303, call; 303, 304; 303, 307; 304, attribute; 304, 305; 304, 306; 305, identifier:analysis_engine; 306, identifier:ExportEvents; 307, argument_list; 307, 308; 307, 311; 307, 312; 307, 315; 307, 316; 307, 321; 307, 326; 307, 329; 307, 334; 308, attribute; 308, 309; 308, 310; 309, identifier:self; 310, identifier:_knowledge_base; 311, identifier:storage_reader; 312, attribute; 312, 313; 312, 314; 313, identifier:self; 314, identifier:_output_module; 315, identifier:configuration; 316, keyword_argument; 316, 317; 316, 318; 317, identifier:deduplicate_events; 318, attribute; 318, 319; 318, 320; 319, identifier:self; 320, identifier:_deduplicate_events; 321, keyword_argument; 321, 322; 321, 323; 322, identifier:event_filter; 323, attribute; 323, 324; 323, 325; 324, identifier:self; 325, identifier:_event_filter; 326, keyword_argument; 326, 327; 326, 328; 327, identifier:status_update_callback; 328, identifier:status_update_callback; 329, keyword_argument; 329, 330; 329, 331; 330, identifier:time_slice; 331, attribute; 331, 332; 331, 333; 332, identifier:self; 333, identifier:_time_slice; 334, keyword_argument; 334, 335; 334, 336; 335, identifier:use_time_slicer; 336, attribute; 336, 337; 336, 338; 337, identifier:self; 338, identifier:_use_time_slicer; 339, if_statement; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, identifier:self; 342, identifier:_quiet_mode; 343, block; 343, 344; 344, return_statement; 345, expression_statement; 345, 346; 346, call; 346, 347; 346, 352; 347, attribute; 347, 348; 347, 351; 348, attribute; 348, 349; 348, 350; 349, identifier:self; 350, identifier:_output_writer; 351, identifier:Write; 352, argument_list; 352, 353; 353, string:'Processing completed.\n'; 354, if_statement; 354, 355; 354, 356; 355, identifier:analysis_counter; 356, block; 356, 357; 356, 373; 356, 397; 356, 408; 357, expression_statement; 357, 358; 358, assignment; 358, 359; 358, 360; 359, identifier:table_view; 360, call; 360, 361; 360, 366; 361, attribute; 361, 362; 361, 365; 362, attribute; 362, 363; 362, 364; 363, identifier:views; 364, identifier:ViewsFactory; 365, identifier:GetTableView; 366, argument_list; 366, 367; 366, 370; 367, attribute; 367, 368; 367, 369; 368, identifier:self; 369, identifier:_views_format_type; 370, keyword_argument; 370, 371; 370, 372; 371, identifier:title; 372, string:'Analysis reports generated'; 373, for_statement; 373, 374; 373, 377; 373, 382; 374, pattern_list; 374, 375; 374, 376; 375, identifier:element; 376, identifier:count; 377, call; 377, 378; 377, 381; 378, attribute; 378, 379; 378, 380; 379, identifier:analysis_counter; 380, identifier:most_common; 381, argument_list; 382, block; 382, 383; 383, if_statement; 383, 384; 383, 387; 384, comparison_operator:!=; 384, 385; 384, 386; 385, identifier:element; 386, string:'total'; 387, block; 387, 388; 388, expression_statement; 388, 389; 389, call; 389, 390; 389, 393; 390, attribute; 390, 391; 390, 392; 391, identifier:table_view; 392, identifier:AddRow; 393, argument_list; 393, 394; 394, list:[element, count]; 394, 395; 394, 396; 395, identifier:element; 396, identifier:count; 397, expression_statement; 397, 398; 398, call; 398, 399; 398, 402; 399, attribute; 399, 400; 399, 401; 400, identifier:table_view; 401, identifier:AddRow; 402, argument_list; 402, 403; 403, list:['Total', analysis_counter['total']]; 403, 404; 403, 405; 404, string:'Total'; 405, subscript; 405, 406; 405, 407; 406, identifier:analysis_counter; 407, string:'total'; 408, expression_statement; 408, 409; 409, call; 409, 410; 409, 413; 410, attribute; 410, 411; 410, 412; 411, identifier:table_view; 412, identifier:Write; 413, argument_list; 413, 414; 414, attribute; 414, 415; 414, 416; 415, identifier:self; 416, identifier:_output_writer; 417, expression_statement; 417, 418; 418, assignment; 418, 419; 418, 420; 419, identifier:storage_reader; 420, call; 420, 421; 420, 426; 421, attribute; 421, 422; 421, 425; 422, attribute; 422, 423; 422, 424; 423, identifier:storage_factory; 424, identifier:StorageFactory; 425, identifier:CreateStorageReaderForFile; 426, argument_list; 426, 427; 427, attribute; 427, 428; 427, 429; 428, identifier:self; 429, identifier:_storage_file_path; 430, expression_statement; 430, 431; 431, call; 431, 432; 431, 435; 432, attribute; 432, 433; 432, 434; 433, identifier:self; 434, identifier:_PrintAnalysisReportsDetails; 435, argument_list; 435, 436; 436, identifier:storage_reader | def ProcessStorage(self):
"""Processes a plaso storage file.
Raises:
BadConfigOption: when a configuration parameter fails validation.
RuntimeError: if a non-recoverable situation is encountered.
"""
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))
# TODO: add single processing support.
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))
# TODO: add single processing support.
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; 13, 16; 14, expression_statement; 14, 15; 15, comment; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:states; 21, list_comprehension; 21, 22; 21, 31; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:mx; 26, identifier:nd; 27, identifier:take; 28, argument_list; 28, 29; 28, 30; 29, identifier:ds; 30, identifier:best_hyp_indices; 31, for_in_clause; 31, 32; 31, 33; 32, identifier:ds; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:states | def sort_state(self, best_hyp_indices: mx.nd.NDArray):
"""
Sorts states according to k-best order from last step in beam search.
"""
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, 30; 27, 46; 27, 67; 27, 68; 27, 78; 27, 95; 28, expression_statement; 28, 29; 29, comment; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:scores; 33, list_comprehension; 33, 34; 33, 41; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:scoring_function; 38, argument_list; 38, 39; 38, 40; 39, identifier:hypothesis; 40, identifier:reference; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:hypothesis; 43, subscript; 43, 44; 43, 45; 44, identifier:hypotheses; 45, string:'translations'; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:ranking; 49, call; 49, 50; 49, 51; 50, identifier:list; 51, argument_list; 51, 52; 52, subscript; 52, 53; 52, 62; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:np; 56, identifier:argsort; 57, argument_list; 57, 58; 57, 59; 58, identifier:scores; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:kind; 61, string:'mergesort'; 62, slice; 62, 63; 62, 64; 62, 65; 63, colon; 64, colon; 65, unary_operator:-; 65, 66; 66, integer:1; 67, comment; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:reranked_hypotheses; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:_sort_by_ranking; 75, argument_list; 75, 76; 75, 77; 76, identifier:hypotheses; 77, identifier:ranking; 78, if_statement; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:return_score; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:reranked_hypotheses; 87, string:'scores'; 88, list_comprehension; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:scores; 91, identifier:i; 92, for_in_clause; 92, 93; 92, 94; 93, identifier:i; 94, identifier:ranking; 95, return_statement; 95, 96; 96, identifier:reranked_hypotheses | def rerank(self, hypotheses: Dict[str, Any], reference: str) -> Dict[str, Any]:
"""
Reranks a set of hypotheses that belong to one single reference
translation. Uses stable sorting.
:param hypotheses: Nbest translations.
:param reference: A single string with the actual reference translation.
:return: Nbest translations sorted by reranking scores.
"""
scores = [self.scoring_function(hypothesis, reference) for hypothesis in hypotheses['translations']]
ranking = list(np.argsort(scores, kind='mergesort')[::-1]) # descending
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, 21; 18, 29; 18, 50; 18, 58; 18, 93; 18, 116; 18, 144; 18, 154; 19, expression_statement; 19, 20; 20, comment; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:load_time_start; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:time; 27, identifier:time; 28, argument_list; 29, with_statement; 29, 30; 29, 40; 30, with_clause; 30, 31; 31, with_item; 31, 32; 32, as_pattern; 32, 33; 32, 38; 33, call; 33, 34; 33, 35; 34, identifier:open; 35, argument_list; 35, 36; 35, 37; 36, identifier:path; 37, string:'rb'; 38, as_pattern_target; 38, 39; 39, identifier:inp; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:_lex; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:np; 47, identifier:load; 48, argument_list; 48, 49; 49, identifier:inp; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:loaded_k; 53, subscript; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:_lex; 56, identifier:shape; 57, integer:1; 58, if_statement; 58, 59; 58, 62; 58, 87; 59, comparison_operator:is; 59, 60; 59, 61; 60, identifier:k; 61, None; 62, block; 62, 63; 62, 71; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:top_k; 66, call; 66, 67; 66, 68; 67, identifier:min; 68, argument_list; 68, 69; 68, 70; 69, identifier:k; 70, identifier:loaded_k; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:>; 72, 73; 72, 74; 73, identifier:k; 74, identifier:loaded_k; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:logger; 80, identifier:warning; 81, argument_list; 81, 82; 81, 85; 81, 86; 82, concatenated_string; 82, 83; 82, 84; 83, string:"Can not load top-%d translations from lexicon that "; 84, string:"contains at most %d entries per source."; 85, identifier:k; 86, identifier:loaded_k; 87, else_clause; 87, 88; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:top_k; 92, identifier:loaded_k; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:lex; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:np; 101, identifier:zeros; 102, argument_list; 102, 103; 102, 111; 103, tuple; 103, 104; 103, 110; 104, call; 104, 105; 104, 106; 105, identifier:len; 106, argument_list; 106, 107; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:vocab_source; 110, identifier:top_k; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:dtype; 113, attribute; 113, 114; 113, 115; 114, identifier:_lex; 115, identifier:dtype; 116, for_statement; 116, 117; 116, 120; 116, 124; 117, pattern_list; 117, 118; 117, 119; 118, identifier:src_id; 119, identifier:trg_ids; 120, call; 120, 121; 120, 122; 121, identifier:enumerate; 122, argument_list; 122, 123; 123, identifier:_lex; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 134; 127, subscript; 127, 128; 127, 131; 127, 132; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:lex; 131, identifier:src_id; 132, slice; 132, 133; 133, colon; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:np; 137, identifier:sort; 138, argument_list; 138, 139; 139, subscript; 139, 140; 139, 141; 140, identifier:trg_ids; 141, slice; 141, 142; 141, 143; 142, colon; 143, identifier:top_k; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:load_time; 147, binary_operator:-; 147, 148; 147, 153; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:time; 151, identifier:time; 152, argument_list; 153, identifier:load_time_start; 154, expression_statement; 154, 155; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:logger; 158, identifier:info; 159, argument_list; 159, 160; 159, 161; 159, 162; 159, 163; 160, string:"Loaded top-%d lexicon from \"%s\" in %.4fs."; 161, identifier:top_k; 162, identifier:path; 163, identifier:load_time | def load(self, path: str, k: Optional[int] = None):
"""
Load lexicon from Numpy array file. The top-k target ids will be sorted by increasing target id.
:param path: Path to Numpy array file.
:param k: Optionally load less items than stored in path.
"""
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, 18; 15, 19; 15, 32; 15, 60; 16, expression_statement; 16, 17; 17, comment; 18, comment; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:unique_src_ids; 22, call; 22, 23; 22, 30; 23, attribute; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:np; 27, identifier:lib; 28, identifier:arraysetops; 29, identifier:unique; 30, argument_list; 30, 31; 31, identifier:src_ids; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:trg_ids; 35, call; 35, 36; 35, 43; 36, attribute; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:np; 40, identifier:lib; 41, identifier:arraysetops; 42, identifier:union1d; 43, argument_list; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:always_allow; 47, call; 47, 48; 47, 57; 48, attribute; 48, 49; 48, 56; 49, subscript; 49, 50; 49, 53; 49, 54; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:lex; 53, identifier:unique_src_ids; 54, slice; 54, 55; 55, colon; 56, identifier:reshape; 57, argument_list; 57, 58; 58, unary_operator:-; 58, 59; 59, integer:1; 60, return_statement; 60, 61; 61, identifier:trg_ids | def get_trg_ids(self, src_ids: np.ndarray) -> np.ndarray:
"""
Lookup possible target ids for input sequence of source ids.
:param src_ids: Sequence(s) of source ids (any shape).
:return: Possible target ids for source (unique sorted, always includes special symbols).
"""
# TODO: When MXNet adds support for set operations, we can migrate to avoid conversions to/from NumPy.
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, 9; 6, 26; 6, 43; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:tree_id; 12, call; 12, 13; 12, 14; 13, identifier:getattr; 14, argument_list; 14, 15; 14, 16; 14, 25; 15, identifier:obj; 16, attribute; 16, 17; 16, 24; 17, attribute; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:queryset; 22, identifier:model; 23, identifier:_mptt_meta; 24, identifier:tree_id_attr; 25, integer:0; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:left; 29, call; 29, 30; 29, 31; 30, identifier:getattr; 31, argument_list; 31, 32; 31, 33; 31, 42; 32, identifier:obj; 33, attribute; 33, 34; 33, 41; 34, attribute; 34, 35; 34, 40; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:queryset; 39, identifier:model; 40, identifier:_mptt_meta; 41, identifier:left_attr; 42, integer:0; 43, return_statement; 43, 44; 44, binary_operator:+; 44, 45; 44, 55; 45, call; 45, 46; 45, 53; 46, attribute; 46, 47; 46, 52; 47, call; 47, 48; 47, 49; 48, identifier:super; 49, argument_list; 49, 50; 49, 51; 50, identifier:MPTTModelChoiceIterator; 51, identifier:self; 52, identifier:choice; 53, argument_list; 53, 54; 54, identifier:obj; 55, tuple; 55, 56; 56, tuple; 56, 57; 56, 58; 57, identifier:tree_id; 58, identifier:left | def choice(self, obj):
"""
Overloads the choice method to add the position
of the object in the tree for future sorting.
"""
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, 9; 6, 10; 6, 66; 6, 115; 6, 170; 6, 217; 6, 264; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, if_statement; 10, 11; 10, 18; 10, 19; 10, 20; 11, boolean_operator:and; 11, 12; 11, 17; 12, comparison_operator:is; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:key; 15, identifier:wavelength; 16, None; 17, identifier:choices; 18, comment; 19, comment; 20, block; 20, 21; 20, 46; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:nearest_wl; 24, call; 24, 25; 24, 26; 25, identifier:min; 26, argument_list; 26, 27; 27, list_comprehension; 27, 28; 27, 37; 27, 40; 28, call; 28, 29; 28, 30; 29, identifier:_wl_dist; 30, argument_list; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:key; 33, identifier:wavelength; 34, attribute; 34, 35; 34, 36; 35, identifier:x; 36, identifier:wavelength; 37, for_in_clause; 37, 38; 37, 39; 38, identifier:x; 39, identifier:choices; 40, if_clause; 40, 41; 41, comparison_operator:is; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:x; 44, identifier:wavelength; 45, None; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:choices; 49, list_comprehension; 49, 50; 49, 51; 49, 54; 50, identifier:c; 51, for_in_clause; 51, 52; 51, 53; 52, identifier:c; 53, identifier:choices; 54, if_clause; 54, 55; 55, comparison_operator:==; 55, 56; 55, 65; 56, call; 56, 57; 56, 58; 57, identifier:_wl_dist; 58, argument_list; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:key; 61, identifier:wavelength; 62, attribute; 62, 63; 62, 64; 63, identifier:c; 64, identifier:wavelength; 65, identifier:nearest_wl; 66, if_statement; 66, 67; 66, 74; 67, boolean_operator:and; 67, 68; 67, 73; 68, comparison_operator:is; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:key; 71, identifier:modifiers; 72, None; 73, identifier:choices; 74, block; 74, 75; 74, 94; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:num_modifiers; 78, call; 78, 79; 78, 80; 79, identifier:min; 80, generator_expression; 80, 81; 80, 91; 81, call; 81, 82; 81, 83; 82, identifier:len; 83, argument_list; 83, 84; 84, boolean_operator:or; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:x; 87, identifier:modifiers; 88, call; 88, 89; 88, 90; 89, identifier:tuple; 90, argument_list; 91, for_in_clause; 91, 92; 91, 93; 92, identifier:x; 93, identifier:choices; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:choices; 97, list_comprehension; 97, 98; 97, 99; 97, 102; 98, identifier:c; 99, for_in_clause; 99, 100; 99, 101; 100, identifier:c; 101, identifier:choices; 102, if_clause; 102, 103; 103, comparison_operator:==; 103, 104; 103, 114; 104, call; 104, 105; 104, 106; 105, identifier:len; 106, argument_list; 106, 107; 107, boolean_operator:or; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:c; 110, identifier:modifiers; 111, call; 111, 112; 111, 113; 112, identifier:tuple; 113, argument_list; 114, identifier:num_modifiers; 115, if_statement; 115, 116; 115, 123; 116, boolean_operator:and; 116, 117; 116, 122; 117, comparison_operator:is; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:key; 120, identifier:calibration; 121, None; 122, identifier:choices; 123, block; 123, 124; 123, 138; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:best_cal; 127, list_comprehension; 127, 128; 127, 131; 127, 134; 128, attribute; 128, 129; 128, 130; 129, identifier:x; 130, identifier:calibration; 131, for_in_clause; 131, 132; 131, 133; 132, identifier:x; 133, identifier:choices; 134, if_clause; 134, 135; 135, attribute; 135, 136; 135, 137; 136, identifier:x; 137, identifier:calibration; 138, if_statement; 138, 139; 138, 140; 139, identifier:best_cal; 140, block; 140, 141; 140, 156; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:best_cal; 144, call; 144, 145; 144, 146; 145, identifier:min; 146, argument_list; 146, 147; 146, 148; 147, identifier:best_cal; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:key; 150, lambda; 150, 151; 150, 153; 151, lambda_parameters; 151, 152; 152, identifier:x; 153, subscript; 153, 154; 153, 155; 154, identifier:CALIBRATION_ORDER; 155, identifier:x; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:choices; 159, list_comprehension; 159, 160; 159, 161; 159, 164; 160, identifier:c; 161, for_in_clause; 161, 162; 161, 163; 162, identifier:c; 163, identifier:choices; 164, if_clause; 164, 165; 165, comparison_operator:==; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:c; 168, identifier:calibration; 169, identifier:best_cal; 170, if_statement; 170, 171; 170, 178; 171, boolean_operator:and; 171, 172; 171, 177; 172, comparison_operator:is; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:key; 175, identifier:resolution; 176, None; 177, identifier:choices; 178, block; 178, 179; 178, 193; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:low_res; 182, list_comprehension; 182, 183; 182, 186; 182, 189; 183, attribute; 183, 184; 183, 185; 184, identifier:x; 185, identifier:resolution; 186, for_in_clause; 186, 187; 186, 188; 187, identifier:x; 188, identifier:choices; 189, if_clause; 189, 190; 190, attribute; 190, 191; 190, 192; 191, identifier:x; 192, identifier:resolution; 193, if_statement; 193, 194; 193, 195; 194, identifier:low_res; 195, block; 195, 196; 195, 203; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:low_res; 199, call; 199, 200; 199, 201; 200, identifier:min; 201, argument_list; 201, 202; 202, identifier:low_res; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:choices; 206, list_comprehension; 206, 207; 206, 208; 206, 211; 207, identifier:c; 208, for_in_clause; 208, 209; 208, 210; 209, identifier:c; 210, identifier:choices; 211, if_clause; 211, 212; 212, comparison_operator:==; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:c; 215, identifier:resolution; 216, identifier:low_res; 217, if_statement; 217, 218; 217, 225; 218, boolean_operator:and; 218, 219; 218, 224; 219, comparison_operator:is; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:key; 222, identifier:level; 223, None; 224, identifier:choices; 225, block; 225, 226; 225, 240; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:low_level; 229, list_comprehension; 229, 230; 229, 233; 229, 236; 230, attribute; 230, 231; 230, 232; 231, identifier:x; 232, identifier:level; 233, for_in_clause; 233, 234; 233, 235; 234, identifier:x; 235, identifier:choices; 236, if_clause; 236, 237; 237, attribute; 237, 238; 237, 239; 238, identifier:x; 239, identifier:level; 240, if_statement; 240, 241; 240, 242; 241, identifier:low_level; 242, block; 242, 243; 242, 250; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:low_level; 246, call; 246, 247; 246, 248; 247, identifier:max; 248, argument_list; 248, 249; 249, identifier:low_level; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:choices; 253, list_comprehension; 253, 254; 253, 255; 253, 258; 254, identifier:c; 255, for_in_clause; 255, 256; 255, 257; 256, identifier:c; 257, identifier:choices; 258, if_clause; 258, 259; 259, comparison_operator:==; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:c; 262, identifier:level; 263, identifier:low_level; 264, return_statement; 264, 265; 265, identifier:choices | def get_best_dataset_key(key, choices):
"""Choose the "best" `DatasetID` from `choices` based on `key`.
The best key is chosen based on the follow criteria:
1. Central wavelength is nearest to the `key` wavelength if
specified.
2. Least modified dataset if `modifiers` is `None` in `key`.
Otherwise, the modifiers are ignored.
3. Highest calibration if `calibration` is `None` in `key`.
Calibration priority is chosen by `satpy.CALIBRATION_ORDER`.
4. Best resolution (smallest number) if `resolution` is `None`
in `key`. Otherwise, the resolution is ignored.
This function assumes `choices` has already been filtered to only
include datasets that match the provided `key`.
Args:
key (DatasetID): Query parameters to sort `choices` by.
choices (iterable): `DatasetID` objects to sort through to determine
the best dataset.
Returns: List of best `DatasetID`s from `choices`. If there is more
than one element this function could not choose between the
available datasets.
"""
# Choose the wavelength closest to the choice
if key.wavelength is not None and choices:
# find the dataset with a central wavelength nearest to the
# requested wavelength
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, 30; 27, 103; 27, 111; 27, 112; 27, 152; 27, 192; 27, 232; 27, 272; 27, 297; 27, 308; 28, expression_statement; 28, 29; 29, comment; 30, if_statement; 30, 31; 30, 38; 30, 39; 30, 40; 30, 53; 30, 77; 31, call; 31, 32; 31, 33; 32, identifier:isinstance; 33, argument_list; 33, 34; 33, 35; 34, identifier:key; 35, attribute; 35, 36; 35, 37; 36, identifier:numbers; 37, identifier:Number; 38, comment; 39, comment; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:key; 44, call; 44, 45; 44, 46; 45, identifier:DatasetID; 46, argument_list; 46, 47; 46, 50; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:wavelength; 49, identifier:key; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:modifiers; 52, None; 53, elif_clause; 53, 54; 53, 63; 53, 64; 54, call; 54, 55; 54, 56; 55, identifier:isinstance; 56, argument_list; 56, 57; 56, 58; 57, identifier:key; 58, tuple; 58, 59; 58, 60; 59, identifier:str; 60, attribute; 60, 61; 60, 62; 61, identifier:six; 62, identifier:text_type; 63, comment; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:key; 68, call; 68, 69; 68, 70; 69, identifier:DatasetID; 70, argument_list; 70, 71; 70, 74; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:name; 73, identifier:key; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:modifiers; 76, None; 77, elif_clause; 77, 78; 77, 84; 78, not_operator; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:isinstance; 81, argument_list; 81, 82; 81, 83; 82, identifier:key; 83, identifier:DatasetID; 84, block; 84, 85; 85, raise_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:ValueError; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 95; 90, attribute; 90, 91; 90, 94; 91, concatenated_string; 91, 92; 91, 93; 92, string:"Expected 'DatasetID', str, or number dict key, "; 93, string:"not {}"; 94, identifier:format; 95, argument_list; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:str; 98, argument_list; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:type; 101, argument_list; 101, 102; 102, identifier:key; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:res; 106, call; 106, 107; 106, 108; 107, identifier:filter_keys_by_dataset_id; 108, argument_list; 108, 109; 108, 110; 109, identifier:key; 110, identifier:key_container; 111, comment; 112, if_statement; 112, 113; 112, 116; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:resolution; 115, None; 116, block; 116, 117; 116, 132; 117, if_statement; 117, 118; 117, 126; 118, not_operator; 118, 119; 119, call; 119, 120; 119, 121; 120, identifier:isinstance; 121, argument_list; 121, 122; 121, 123; 122, identifier:resolution; 123, tuple; 123, 124; 123, 125; 124, identifier:list; 125, identifier:tuple; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:resolution; 130, tuple; 130, 131; 131, identifier:resolution; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:res; 135, list_comprehension; 135, 136; 135, 137; 135, 140; 136, identifier:k; 137, for_in_clause; 137, 138; 137, 139; 138, identifier:k; 139, identifier:res; 140, if_clause; 140, 141; 141, boolean_operator:and; 141, 142; 141, 147; 142, comparison_operator:is; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:k; 145, identifier:resolution; 146, None; 147, comparison_operator:in; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:k; 150, identifier:resolution; 151, identifier:resolution; 152, if_statement; 152, 153; 152, 156; 153, comparison_operator:is; 153, 154; 153, 155; 154, identifier:polarization; 155, None; 156, block; 156, 157; 156, 172; 157, if_statement; 157, 158; 157, 166; 158, not_operator; 158, 159; 159, call; 159, 160; 159, 161; 160, identifier:isinstance; 161, argument_list; 161, 162; 161, 163; 162, identifier:polarization; 163, tuple; 163, 164; 163, 165; 164, identifier:list; 165, identifier:tuple; 166, block; 166, 167; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:polarization; 170, tuple; 170, 171; 171, identifier:polarization; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:res; 175, list_comprehension; 175, 176; 175, 177; 175, 180; 176, identifier:k; 177, for_in_clause; 177, 178; 177, 179; 178, identifier:k; 179, identifier:res; 180, if_clause; 180, 181; 181, boolean_operator:and; 181, 182; 181, 187; 182, comparison_operator:is; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:k; 185, identifier:polarization; 186, None; 187, comparison_operator:in; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:k; 190, identifier:polarization; 191, identifier:polarization; 192, if_statement; 192, 193; 192, 196; 193, comparison_operator:is; 193, 194; 193, 195; 194, identifier:calibration; 195, None; 196, block; 196, 197; 196, 212; 197, if_statement; 197, 198; 197, 206; 198, not_operator; 198, 199; 199, call; 199, 200; 199, 201; 200, identifier:isinstance; 201, argument_list; 201, 202; 201, 203; 202, identifier:calibration; 203, tuple; 203, 204; 203, 205; 204, identifier:list; 205, identifier:tuple; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:calibration; 210, tuple; 210, 211; 211, identifier:calibration; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:res; 215, list_comprehension; 215, 216; 215, 217; 215, 220; 216, identifier:k; 217, for_in_clause; 217, 218; 217, 219; 218, identifier:k; 219, identifier:res; 220, if_clause; 220, 221; 221, boolean_operator:and; 221, 222; 221, 227; 222, comparison_operator:is; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:k; 225, identifier:calibration; 226, None; 227, comparison_operator:in; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:k; 230, identifier:calibration; 231, identifier:calibration; 232, if_statement; 232, 233; 232, 236; 233, comparison_operator:is; 233, 234; 233, 235; 234, identifier:level; 235, None; 236, block; 236, 237; 236, 252; 237, if_statement; 237, 238; 237, 246; 238, not_operator; 238, 239; 239, call; 239, 240; 239, 241; 240, identifier:isinstance; 241, argument_list; 241, 242; 241, 243; 242, identifier:level; 243, tuple; 243, 244; 243, 245; 244, identifier:list; 245, identifier:tuple; 246, block; 246, 247; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:level; 250, tuple; 250, 251; 251, identifier:level; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:res; 255, list_comprehension; 255, 256; 255, 257; 255, 260; 256, identifier:k; 257, for_in_clause; 257, 258; 257, 259; 258, identifier:k; 259, identifier:res; 260, if_clause; 260, 261; 261, boolean_operator:and; 261, 262; 261, 267; 262, comparison_operator:is; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:k; 265, identifier:level; 266, None; 267, comparison_operator:in; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:k; 270, identifier:level; 271, identifier:level; 272, if_statement; 272, 273; 272, 276; 273, comparison_operator:is; 273, 274; 273, 275; 274, identifier:modifiers; 275, None; 276, block; 276, 277; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:res; 280, list_comprehension; 280, 281; 280, 282; 280, 285; 281, identifier:k; 282, for_in_clause; 282, 283; 282, 284; 283, identifier:k; 284, identifier:res; 285, if_clause; 285, 286; 286, boolean_operator:and; 286, 287; 286, 292; 287, comparison_operator:is; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:k; 290, identifier:modifiers; 291, None; 292, comparison_operator:==; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:k; 295, identifier:modifiers; 296, identifier:modifiers; 297, if_statement; 297, 298; 297, 299; 298, identifier:best; 299, block; 299, 300; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:res; 303, call; 303, 304; 303, 305; 304, identifier:get_best_dataset_key; 305, argument_list; 305, 306; 305, 307; 306, identifier:key; 307, identifier:res; 308, if_statement; 308, 309; 308, 315; 308, 329; 308, 354; 308, 363; 308, 370; 309, boolean_operator:and; 309, 310; 309, 313; 310, comparison_operator:==; 310, 311; 310, 312; 311, identifier:num_results; 312, integer:1; 313, not_operator; 313, 314; 314, identifier:res; 315, block; 315, 316; 316, raise_statement; 316, 317; 317, call; 317, 318; 317, 319; 318, identifier:KeyError; 319, argument_list; 319, 320; 320, call; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, string:"No dataset matching '{}' found"; 323, identifier:format; 324, argument_list; 324, 325; 325, call; 325, 326; 325, 327; 326, identifier:str; 327, argument_list; 327, 328; 328, identifier:key; 329, elif_clause; 329, 330; 329, 340; 330, boolean_operator:and; 330, 331; 330, 334; 331, comparison_operator:==; 331, 332; 331, 333; 332, identifier:num_results; 333, integer:1; 334, comparison_operator:!=; 334, 335; 334, 339; 335, call; 335, 336; 335, 337; 336, identifier:len; 337, argument_list; 337, 338; 338, identifier:res; 339, integer:1; 340, block; 340, 341; 341, raise_statement; 341, 342; 342, call; 342, 343; 342, 344; 343, identifier:TooManyResults; 344, argument_list; 344, 345; 345, call; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, string:"No unique dataset matching {}"; 348, identifier:format; 349, argument_list; 349, 350; 350, call; 350, 351; 350, 352; 351, identifier:str; 352, argument_list; 352, 353; 353, identifier:key; 354, elif_clause; 354, 355; 354, 358; 355, comparison_operator:==; 355, 356; 355, 357; 356, identifier:num_results; 357, integer:1; 358, block; 358, 359; 359, return_statement; 359, 360; 360, subscript; 360, 361; 360, 362; 361, identifier:res; 362, integer:0; 363, elif_clause; 363, 364; 363, 367; 364, comparison_operator:==; 364, 365; 364, 366; 365, identifier:num_results; 366, integer:0; 367, block; 367, 368; 368, return_statement; 368, 369; 369, identifier:res; 370, else_clause; 370, 371; 371, block; 371, 372; 372, return_statement; 372, 373; 373, subscript; 373, 374; 373, 375; 374, identifier:res; 375, slice; 375, 376; 375, 377; 376, colon; 377, identifier:num_results | def get_key(key, key_container, num_results=1, best=True,
resolution=None, calibration=None, polarization=None,
level=None, modifiers=None):
"""Get the fully-specified key best matching the provided key.
Only the best match is returned if `best` is `True` (default). See
`get_best_dataset_key` for more information on how this is determined.
The `resolution` and other identifier keywords are provided as a
convenience to filter by multiple parameters at once without having
to filter by multiple `key` inputs.
Args:
key (DatasetID): DatasetID of query parameters to use for
searching. Any parameter that is `None`
is considered a wild card and any match is
accepted.
key_container (dict or set): Container of DatasetID objects that
uses hashing to quickly access items.
num_results (int): Number of results to return. Use `0` for all
matching results. If `1` then the single matching
key is returned instead of a list of length 1.
(default: 1)
best (bool): Sort results to get "best" result first
(default: True). See `get_best_dataset_key` for details.
resolution (float, int, or list): Resolution of the dataset in
dataset units (typically
meters). This can also be a
list of these numbers.
calibration (str or list): Dataset calibration
(ex.'reflectance'). This can also be a
list of these strings.
polarization (str or list): Dataset polarization
(ex.'V'). This can also be a
list of these strings.
level (number or list): Dataset level (ex. 100). This can also be a
list of these numbers.
modifiers (list): Modifiers applied to the dataset. Unlike
resolution and calibration this is the exact
desired list of modifiers for one dataset, not
a list of possible modifiers.
Returns (list or DatasetID): Matching key(s)
Raises: KeyError if no matching results or if more than one result is
found when `num_results` is `1`.
"""
if isinstance(key, numbers.Number):
# we want this ID to act as a query so we set modifiers to None
# meaning "we don't care how many modifiers it has".
key = DatasetID(wavelength=key, modifiers=None)
elif isinstance(key, (str, six.text_type)):
# ID should act as a query (see wl comment above)
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)
# further filter by other parameters
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, 23; 20, 24; 20, 49; 20, 50; 20, 56; 20, 69; 20, 75; 20, 122; 20, 140; 20, 144; 20, 190; 20, 194; 20, 203; 20, 207; 20, 331; 20, 338; 20, 339; 21, expression_statement; 21, 22; 22, comment; 23, comment; 24, if_statement; 24, 25; 24, 28; 24, 34; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:reader; 27, None; 28, block; 28, 29; 29, raise_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:ValueError; 32, argument_list; 32, 33; 33, string:"'reader' keyword argument is required."; 34, elif_clause; 34, 35; 34, 43; 35, not_operator; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:isinstance; 38, argument_list; 38, 39; 38, 40; 39, identifier:reader; 40, tuple; 40, 41; 40, 42; 41, identifier:list; 42, identifier:tuple; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:reader; 47, list:[reader]; 47, 48; 48, identifier:reader; 49, comment; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:reader; 53, subscript; 53, 54; 53, 55; 54, identifier:reader; 55, integer:0; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:reader_configs; 59, subscript; 59, 60; 59, 68; 60, call; 60, 61; 60, 62; 61, identifier:list; 62, argument_list; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:configs_for_reader; 65, argument_list; 65, 66; 65, 67; 66, identifier:reader; 67, identifier:ppp_config_dir; 68, integer:0; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:reader_kwargs; 72, boolean_operator:or; 72, 73; 72, 74; 73, identifier:reader_kwargs; 74, dictionary; 75, try_statement; 75, 76; 75, 86; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:reader_instance; 80, call; 80, 81; 80, 82; 81, identifier:load_reader; 82, argument_list; 82, 83; 82, 84; 83, identifier:reader_configs; 84, dictionary_splat; 84, 85; 85, identifier:reader_kwargs; 86, except_clause; 86, 87; 86, 96; 87, as_pattern; 87, 88; 87, 94; 88, tuple; 88, 89; 88, 90; 88, 91; 89, identifier:KeyError; 90, identifier:IOError; 91, attribute; 91, 92; 91, 93; 92, identifier:yaml; 93, identifier:YAMLError; 94, as_pattern_target; 94, 95; 95, identifier:err; 96, block; 96, 97; 96, 108; 96, 118; 96, 119; 96, 120; 96, 121; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:LOG; 101, identifier:info; 102, argument_list; 102, 103; 102, 104; 103, string:'Cannot use %s'; 104, call; 104, 105; 104, 106; 105, identifier:str; 106, argument_list; 106, 107; 107, identifier:reader_configs; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:LOG; 112, identifier:debug; 113, argument_list; 113, 114; 114, call; 114, 115; 114, 116; 115, identifier:str; 116, argument_list; 116, 117; 117, identifier:err; 118, comment; 119, comment; 120, comment; 121, raise_statement; 122, if_statement; 122, 123; 122, 126; 123, comparison_operator:is; 123, 124; 123, 125; 124, identifier:group_keys; 125, None; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:group_keys; 130, call; 130, 131; 130, 136; 131, attribute; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:reader_instance; 134, identifier:info; 135, identifier:get; 136, argument_list; 136, 137; 136, 138; 137, string:'group_keys'; 138, tuple; 138, 139; 139, string:'start_time'; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:file_keys; 143, list:[]; 144, for_statement; 144, 145; 144, 148; 144, 153; 145, pattern_list; 145, 146; 145, 147; 146, identifier:filetype; 147, identifier:filetype_info; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:reader_instance; 151, identifier:sorted_filetype_items; 152, argument_list; 153, block; 153, 154; 154, for_statement; 154, 155; 154, 158; 154, 165; 155, pattern_list; 155, 156; 155, 157; 156, identifier:f; 157, identifier:file_info; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:reader_instance; 161, identifier:filename_items_for_filetype; 162, argument_list; 162, 163; 162, 164; 163, identifier:files_to_sort; 164, identifier:filetype_info; 165, block; 165, 166; 165, 181; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:group_key; 169, call; 169, 170; 169, 171; 170, identifier:tuple; 171, generator_expression; 171, 172; 171, 178; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:file_info; 175, identifier:get; 176, argument_list; 176, 177; 177, identifier:k; 178, for_in_clause; 178, 179; 178, 180; 179, identifier:k; 180, identifier:group_keys; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:file_keys; 185, identifier:append; 186, argument_list; 186, 187; 187, tuple; 187, 188; 187, 189; 188, identifier:group_key; 189, identifier:f; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:prev_key; 193, None; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:threshold; 197, call; 197, 198; 197, 199; 198, identifier:timedelta; 199, argument_list; 199, 200; 200, keyword_argument; 200, 201; 200, 202; 201, identifier:seconds; 202, identifier:time_threshold; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:file_groups; 206, dictionary; 207, for_statement; 207, 208; 207, 211; 207, 215; 207, 216; 208, pattern_list; 208, 209; 208, 210; 209, identifier:gk; 210, identifier:f; 211, call; 211, 212; 211, 213; 212, identifier:sorted; 213, argument_list; 213, 214; 214, identifier:file_keys; 215, comment; 216, block; 216, 217; 216, 265; 216, 266; 216, 267; 216, 268; 216, 300; 216, 301; 217, if_statement; 217, 218; 217, 221; 217, 230; 217, 253; 218, comparison_operator:is; 218, 219; 218, 220; 219, identifier:prev_key; 220, None; 221, block; 221, 222; 221, 226; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:is_new_group; 225, True; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:prev_key; 229, identifier:gk; 230, elif_clause; 230, 231; 230, 238; 230, 239; 231, call; 231, 232; 231, 233; 232, identifier:isinstance; 233, argument_list; 233, 234; 233, 237; 234, subscript; 234, 235; 234, 236; 235, identifier:gk; 236, integer:0; 237, identifier:datetime; 238, comment; 239, block; 239, 240; 240, expression_statement; 240, 241; 241, assignment; 241, 242; 241, 243; 242, identifier:is_new_group; 243, comparison_operator:>; 243, 244; 243, 252; 244, parenthesized_expression; 244, 245; 245, binary_operator:-; 245, 246; 245, 249; 246, subscript; 246, 247; 246, 248; 247, identifier:gk; 248, integer:0; 249, subscript; 249, 250; 249, 251; 250, identifier:prev_key; 251, integer:0; 252, identifier:threshold; 253, else_clause; 253, 254; 254, block; 254, 255; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:is_new_group; 258, comparison_operator:!=; 258, 259; 258, 262; 259, subscript; 259, 260; 259, 261; 260, identifier:gk; 261, integer:0; 262, subscript; 262, 263; 262, 264; 263, identifier:prev_key; 264, integer:0; 265, comment; 266, comment; 267, comment; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:vals_not_equal; 271, generator_expression; 271, 272; 271, 275; 271, 292; 272, comparison_operator:!=; 272, 273; 272, 274; 273, identifier:this_val; 274, identifier:prev_val; 275, for_in_clause; 275, 276; 275, 279; 276, pattern_list; 276, 277; 276, 278; 277, identifier:this_val; 278, identifier:prev_val; 279, call; 279, 280; 279, 281; 280, identifier:zip; 281, argument_list; 281, 282; 281, 287; 282, subscript; 282, 283; 282, 284; 283, identifier:gk; 284, slice; 284, 285; 284, 286; 285, integer:1; 286, colon; 287, subscript; 287, 288; 287, 289; 288, identifier:prev_key; 289, slice; 289, 290; 289, 291; 290, integer:1; 291, colon; 292, if_clause; 292, 293; 293, boolean_operator:and; 293, 294; 293, 297; 294, comparison_operator:is; 294, 295; 294, 296; 295, identifier:this_val; 296, None; 297, comparison_operator:is; 297, 298; 297, 299; 298, identifier:prev_val; 299, None; 300, comment; 301, if_statement; 301, 302; 301, 308; 301, 320; 302, boolean_operator:or; 302, 303; 302, 304; 303, identifier:is_new_group; 304, call; 304, 305; 304, 306; 305, identifier:any; 306, argument_list; 306, 307; 307, identifier:vals_not_equal; 308, block; 308, 309; 308, 316; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 314; 311, subscript; 311, 312; 311, 313; 312, identifier:file_groups; 313, identifier:gk; 314, list:[f]; 314, 315; 315, identifier:f; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 319; 318, identifier:prev_key; 319, identifier:gk; 320, else_clause; 320, 321; 321, block; 321, 322; 322, expression_statement; 322, 323; 323, call; 323, 324; 323, 329; 324, attribute; 324, 325; 324, 328; 325, subscript; 325, 326; 325, 327; 326, identifier:file_groups; 327, identifier:prev_key; 328, identifier:append; 329, argument_list; 329, 330; 330, identifier:f; 331, expression_statement; 331, 332; 332, assignment; 332, 333; 332, 334; 333, identifier:sorted_group_keys; 334, call; 334, 335; 334, 336; 335, identifier:sorted; 336, argument_list; 336, 337; 337, identifier:file_groups; 338, comment; 339, return_statement; 339, 340; 340, list_comprehension; 340, 341; 340, 347; 341, dictionary; 341, 342; 342, pair; 342, 343; 342, 344; 343, identifier:reader; 344, subscript; 344, 345; 344, 346; 345, identifier:file_groups; 346, identifier:group_key; 347, for_in_clause; 347, 348; 347, 349; 348, identifier:group_key; 349, 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):
"""Group series of files by file pattern information.
By default this will group files by their filename ``start_time``
assuming it exists in the pattern. By passing the individual
dictionaries returned by this function to the Scene classes'
``filenames``, a series `Scene` objects can be easily created.
.. versionadded:: 0.12
Args:
files_to_sort (iterable): File paths to sort in to group
reader (str): Reader whose file patterns should be used to sort files.
This
time_threshold (int): Number of seconds used to consider time elements
in a group as being equal. For example, if the 'start_time' item
is used to group files then any time within `time_threshold`
seconds of the first file's 'start_time' will be seen as occurring
at the same time.
group_keys (list or tuple): File pattern information to use to group
files. Keys are sorted in order and only the first key is used when
comparing datetime elements with `time_threshold` (see above). This
means it is recommended that datetime values should only come from
the first key in ``group_keys``. Otherwise, there is a good chance
that files will not be grouped properly (datetimes being barely
unequal). Defaults to a reader's ``group_keys`` configuration (set
in YAML), otherwise ``('start_time',)``.
ppp_config_dir (str): Root usser configuration directory for Satpy.
This will be deprecated in the future, but is here for consistency
with other Satpy features.
reader_kwargs (dict): Additional keyword arguments to pass to reader
creation.
Returns:
List of dictionaries mapping 'reader' to a list of filenames.
Each of these dictionaries can be passed as ``filenames`` to
a `Scene` object.
"""
# FUTURE: Find the best reader for each filename using `find_files_and_readers`
if reader is None:
raise ValueError("'reader' keyword argument is required.")
elif not isinstance(reader, (list, tuple)):
reader = [reader]
# FUTURE: Handle multiple readers
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))
# if reader and (isinstance(reader, str) or len(reader) == 1):
# # if it is a single reader then give a more usable error
# raise
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):
# use first element of key as time identifier (if datetime type)
if prev_key is None:
is_new_group = True
prev_key = gk
elif isinstance(gk[0], datetime):
# datetimes within threshold difference are "the same time"
is_new_group = (gk[0] - prev_key[0]) > threshold
else:
is_new_group = gk[0] != prev_key[0]
# compare keys for those that are found for both the key and
# this is a generator and is not computed until the if statement below
# when we know that `prev_key` is not None
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 this is a new group based on the first element
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)
# passable to Scene as 'filenames'
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, 8; 5, 12; 5, 27; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:processed_types; 11, list:[]; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:file_type_items; 15, call; 15, 16; 15, 17; 16, identifier:deque; 17, argument_list; 17, 18; 18, call; 18, 19; 18, 26; 19, attribute; 19, 20; 19, 25; 20, subscript; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:config; 24, string:'file_types'; 25, identifier:items; 26, argument_list; 27, while_statement; 27, 28; 27, 32; 28, call; 28, 29; 28, 30; 29, identifier:len; 30, argument_list; 30, 31; 31, identifier:file_type_items; 32, block; 32, 33; 32, 43; 32, 52; 32, 83; 32, 90; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, pattern_list; 35, 36; 35, 37; 36, identifier:filetype; 37, identifier:filetype_info; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:file_type_items; 41, identifier:popleft; 42, argument_list; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:requirements; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:filetype_info; 49, identifier:get; 50, argument_list; 50, 51; 51, string:'requires'; 52, if_statement; 52, 53; 52, 56; 52, 57; 53, comparison_operator:is; 53, 54; 53, 55; 54, identifier:requirements; 55, None; 56, comment; 57, block; 57, 58; 57, 70; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:missing; 61, list_comprehension; 61, 62; 61, 63; 61, 66; 62, identifier:req; 63, for_in_clause; 63, 64; 63, 65; 64, identifier:req; 65, identifier:requirements; 66, if_clause; 66, 67; 67, comparison_operator:not; 67, 68; 67, 69; 68, identifier:req; 69, identifier:processed_types; 70, if_statement; 70, 71; 70, 72; 71, identifier:missing; 72, block; 72, 73; 72, 82; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:file_type_items; 77, identifier:append; 78, argument_list; 78, 79; 79, tuple; 79, 80; 79, 81; 80, identifier:filetype; 81, identifier:filetype_info; 82, continue_statement; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:processed_types; 87, identifier:append; 88, argument_list; 88, 89; 89, identifier:filetype; 90, expression_statement; 90, 91; 91, yield; 91, 92; 92, expression_list; 92, 93; 92, 94; 93, identifier:filetype; 94, identifier:filetype_info | def sorted_filetype_items(self):
"""Sort the instance's filetypes in using order."""
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:
# requirements have not been processed yet -> wait
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, 8; 5, 14; 5, 35; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:hasher; 11, call; 11, 12; 11, 13; 12, identifier:sha1; 13, argument_list; 14, for_statement; 14, 15; 14, 16; 14, 20; 15, identifier:h; 16, call; 16, 17; 16, 18; 17, identifier:sorted; 18, argument_list; 18, 19; 19, identifier:hashes; 20, block; 20, 21; 20, 28; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:h; 24, call; 24, 25; 24, 26; 25, identifier:ensure_binary; 26, argument_list; 26, 27; 27, identifier:h; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:hasher; 32, identifier:update; 33, argument_list; 33, 34; 34, identifier:h; 35, return_statement; 35, 36; 36, conditional_expression:if; 36, 37; 36, 42; 36, 43; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:hasher; 40, identifier:hexdigest; 41, argument_list; 42, identifier:PY3; 43, call; 43, 44; 43, 51; 44, attribute; 44, 45; 44, 50; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:hasher; 48, identifier:hexdigest; 49, argument_list; 50, identifier:decode; 51, argument_list; 51, 52; 52, string:'utf-8' | def combine_hashes(hashes):
"""A simple helper function to combine other hashes. Sorts the hashes before rolling them in."""
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, 34; 31, 61; 31, 69; 31, 110; 31, 111; 31, 112; 31, 113; 31, 114; 31, 115; 31, 116; 31, 117; 31, 118; 31, 133; 32, expression_statement; 32, 33; 33, comment; 34, function_definition; 34, 35; 34, 36; 34, 37; 35, function_name:formulate_help; 36, parameters; 37, block; 37, 38; 38, if_statement; 38, 39; 38, 40; 38, 52; 39, identifier:classpath; 40, block; 40, 41; 41, return_statement; 41, 42; 42, parenthesized_expression; 42, 43; 43, call; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, concatenated_string; 45, 46; 45, 47; 46, string:'Target address spec for overriding the classpath of the {} jvm tool which is, '; 47, string:'by default: {}'; 48, identifier:format; 49, argument_list; 49, 50; 49, 51; 50, identifier:key; 51, identifier:classpath; 52, else_clause; 52, 53; 53, block; 53, 54; 54, return_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, string:'Target address spec for specifying the classpath of the {} jvm tool.'; 58, identifier:format; 59, argument_list; 59, 60; 60, identifier:key; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:help; 64, boolean_operator:or; 64, 65; 64, 66; 65, identifier:help; 66, call; 66, 67; 66, 68; 67, identifier:formulate_help; 68, argument_list; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:register; 72, argument_list; 72, 73; 72, 79; 72, 82; 72, 85; 72, 98; 72, 101; 72, 104; 72, 107; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, string:'--{}'; 76, identifier:format; 77, argument_list; 77, 78; 78, identifier:key; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:advanced; 81, True; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:type; 84, identifier:target_option; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:default; 87, conditional_expression:if; 87, 88; 87, 94; 87, 97; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, string:'//:{}'; 91, identifier:format; 92, argument_list; 92, 93; 93, identifier:key; 94, comparison_operator:is; 94, 95; 94, 96; 95, identifier:classpath_spec; 96, None; 97, identifier:classpath_spec; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:help; 100, identifier:help; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:fingerprint; 103, identifier:fingerprint; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:removal_version; 106, identifier:removal_version; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:removal_hint; 109, identifier:removal_hint; 110, comment; 111, comment; 112, comment; 113, comment; 114, comment; 115, comment; 116, comment; 117, comment; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:jvm_tool; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:cls; 124, identifier:JvmTool; 125, argument_list; 125, 126; 125, 129; 125, 130; 125, 131; 125, 132; 126, attribute; 126, 127; 126, 128; 127, identifier:register; 128, identifier:scope; 129, identifier:key; 130, identifier:classpath; 131, identifier:main; 132, identifier:custom_rules; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:JvmToolMixin; 138, identifier:_jvm_tools; 139, identifier:append; 140, argument_list; 140, 141; 141, 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):
"""Registers a jvm tool under `key` for lazy classpath resolution.
Classpaths can be retrieved in `execute` scope via `tool_classpath_from_products`.
NB: If the tool's `main` class name is supplied the tool classpath will be shaded.
:param register: A function that can register options with the option system.
:param unicode key: The key the tool configuration should be registered under.
:param unicode classpath_spec: The tool classpath target address spec that can be used to
override this tool's classpath; by default, `//:[key]`.
:param unicode main: The fully qualified class name of the tool's main class if shading of the
tool classpath is desired.
:param list custom_rules: An optional list of `Shader.Rule`s to apply before the automatically
generated binary jar shading rules. This is useful for excluding
classes shared between the tool and the code it runs over. The
canonical example is the `org.junit.Test` annotation read by junit
runner tools from user code. In this sort of case the shared code must
have a uniform name between the tool and the user code and so the
shared code must be excluded from shading.
:param bool fingerprint: Indicates whether to include the jvm tool in the task's fingerprint.
Note that unlike for other options, fingerprinting is enabled for tools
by default.
:param list classpath: A list of one or more `JarDependency` objects that form this tool's
default classpath. If the classpath is optional, supply an empty list;
otherwise the default classpath of `None` indicates the `classpath_spec`
must point to a target defined in a BUILD file that provides the tool
classpath.
:param unicode help: An optional custom help string; otherwise a reasonable one is generated.
:param string removal_version: A semver at which this tool will be removed.
:param unicode removal_hint: A hint on how to migrate away from this tool.
"""
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)
# TODO(John Sirois): Move towards requiring tool specs point to jvm_binary targets.
# These already have a main and are a natural place to house any custom shading rules. That
# would eliminate the need to pass main and custom_rules here.
# It is awkward that jars can no longer be inlined as dependencies - this will require 2 targets
# for every tool - the jvm_binary, and a jar_library for its dependencies to point to. It may
# be worth creating a JarLibrary subclass - say JarBinary, or else mixing in a Binary interface
# to JarLibrary to endow it with main and shade_rules attributes to allow for single-target
# definition of resolvable jvm binaries.
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, 9; 6, 24; 6, 42; 6, 43; 6, 72; 6, 87; 6, 105; 6, 119; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:baseurl_to_urls; 12, dictionary_comprehension; 12, 13; 12, 21; 13, pair; 13, 14; 13, 20; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:_baseurl; 18, argument_list; 18, 19; 19, identifier:url; 20, identifier:url; 21, for_in_clause; 21, 22; 21, 23; 22, identifier:url; 23, identifier:urls; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:pingtimes; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_pinger; 32, identifier:pings; 33, argument_list; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:list; 36, argument_list; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:baseurl_to_urls; 40, identifier:keys; 41, argument_list; 42, comment; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:_log; 49, identifier:debug; 50, argument_list; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, string:'Artifact cache server ping times: {}'; 54, identifier:format; 55, argument_list; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, string:', '; 59, identifier:join; 60, argument_list; 60, 61; 61, list_comprehension; 61, 62; 61, 69; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, string:'{}: {:.6f} secs'; 65, identifier:format; 66, argument_list; 66, 67; 67, list_splat; 67, 68; 68, identifier:p; 69, for_in_clause; 69, 70; 69, 71; 70, identifier:p; 71, identifier:pingtimes; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:sorted_pingtimes; 75, call; 75, 76; 75, 77; 76, identifier:sorted; 77, argument_list; 77, 78; 77, 79; 78, identifier:pingtimes; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:key; 81, lambda; 81, 82; 81, 84; 82, lambda_parameters; 82, 83; 83, identifier:x; 84, subscript; 84, 85; 84, 86; 85, identifier:x; 86, integer:1; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:available_urls; 90, list_comprehension; 90, 91; 90, 94; 90, 99; 91, subscript; 91, 92; 91, 93; 92, identifier:baseurl_to_urls; 93, identifier:baseurl; 94, for_in_clause; 94, 95; 94, 98; 95, pattern_list; 95, 96; 95, 97; 96, identifier:baseurl; 97, identifier:pingtime; 98, identifier:sorted_pingtimes; 99, if_clause; 99, 100; 100, comparison_operator:<; 100, 101; 100, 102; 101, identifier:pingtime; 102, attribute; 102, 103; 102, 104; 103, identifier:Pinger; 104, identifier:UNREACHABLE; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 112; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:_log; 111, identifier:debug; 112, argument_list; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, string:'Available cache servers: {0}'; 116, identifier:format; 117, argument_list; 117, 118; 118, identifier:available_urls; 119, return_statement; 119, 120; 120, identifier:available_urls | def get_available_urls(self, urls):
"""Return reachable urls sorted by their ping times."""
baseurl_to_urls = {self._baseurl(url): url for url in urls}
pingtimes = self._pinger.pings(list(baseurl_to_urls.keys())) # List of pairs (host, time in ms).
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, 9; 6, 26; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:scope_infos; 12, list_comprehension; 12, 13; 12, 18; 13, subscript; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_scope_to_info; 17, identifier:s; 18, for_in_clause; 18, 19; 18, 20; 19, identifier:s; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_expand_tasks; 24, argument_list; 24, 25; 25, identifier:scopes; 26, if_statement; 26, 27; 26, 28; 27, identifier:scope_infos; 28, block; 28, 29; 29, for_statement; 29, 30; 29, 31; 29, 37; 30, identifier:scope_info; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_expand_subsystems; 35, argument_list; 35, 36; 36, identifier:scope_infos; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, yield; 39, 40; 40, identifier:scope_info | def iterate(self, scopes):
"""Yields ScopeInfo instances for the specified scopes, plus relevant related scopes.
Relevant scopes are:
- All tasks in a requested goal.
- All subsystems tied to a request scope.
Yields in a sensible order: Sorted by scope, but with subsystems tied to a request scope
following that scope, e.g.,
goal1
goal1.task11
subsys.goal1.task11
goal1.task12
goal2.task21
...
"""
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, 9; 6, 16; 6, 69; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:expanded_scopes; 12, call; 12, 13; 12, 14; 13, identifier:set; 14, argument_list; 14, 15; 15, identifier:scopes; 16, for_statement; 16, 17; 16, 20; 16, 27; 17, pattern_list; 17, 18; 17, 19; 18, identifier:scope; 19, identifier:info; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_scope_to_info; 25, identifier:items; 26, argument_list; 27, block; 27, 28; 28, if_statement; 28, 29; 28, 36; 29, comparison_operator:==; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:info; 32, identifier:category; 33, attribute; 33, 34; 33, 35; 34, identifier:ScopeInfo; 35, identifier:TASK; 36, block; 36, 37; 36, 44; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:outer; 40, call; 40, 41; 40, 42; 41, identifier:enclosing_scope; 42, argument_list; 42, 43; 43, identifier:scope; 44, while_statement; 44, 45; 44, 48; 45, comparison_operator:!=; 45, 46; 45, 47; 46, identifier:outer; 47, identifier:GLOBAL_SCOPE; 48, block; 48, 49; 48, 62; 49, if_statement; 49, 50; 49, 53; 50, comparison_operator:in; 50, 51; 50, 52; 51, identifier:outer; 52, identifier:expanded_scopes; 53, block; 53, 54; 53, 61; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:expanded_scopes; 58, identifier:add; 59, argument_list; 59, 60; 60, identifier:scope; 61, break_statement; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:outer; 65, call; 65, 66; 65, 67; 66, identifier:enclosing_scope; 67, argument_list; 67, 68; 68, identifier:outer; 69, return_statement; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:sorted; 72, argument_list; 72, 73; 73, identifier:expanded_scopes | def _expand_tasks(self, scopes):
"""Add all tasks in any requested goals.
Returns the requested scopes, plus the added tasks, sorted by scope name.
"""
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; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, return_statement; 8, 9; 9, list_comprehension; 9, 10; 9, 30; 10, dictionary; 10, 11; 10, 16; 10, 21; 11, pair; 11, 12; 11, 13; 12, string:'label'; 13, subscript; 13, 14; 13, 15; 14, identifier:x; 15, integer:0; 16, pair; 16, 17; 16, 18; 17, string:'timing'; 18, subscript; 18, 19; 18, 20; 19, identifier:x; 20, integer:1; 21, pair; 21, 22; 21, 23; 22, string:'is_tool'; 23, comparison_operator:in; 23, 24; 23, 27; 24, subscript; 24, 25; 24, 26; 25, identifier:x; 26, integer:0; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_tool_labels; 30, for_in_clause; 30, 31; 30, 32; 31, identifier:x; 32, call; 32, 33; 32, 34; 33, identifier:sorted; 34, argument_list; 34, 35; 34, 42; 34, 50; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:_timings_by_path; 40, identifier:items; 41, argument_list; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:key; 44, lambda; 44, 45; 44, 47; 45, lambda_parameters; 45, 46; 46, identifier:x; 47, subscript; 47, 48; 47, 49; 48, identifier:x; 49, integer:1; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:reverse; 52, True | def get_all(self):
"""Returns all the timings, sorted in decreasing order.
Each value is a dict: { path: <path>, timing: <timing in seconds> }
"""
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; 4, 7; 5, expression_statement; 5, 6; 6, comment; 7, return_statement; 7, 8; 8, list_comprehension; 8, 9; 8, 10; 8, 24; 9, identifier:goal; 10, for_in_clause; 10, 11; 10, 14; 11, pattern_list; 11, 12; 11, 13; 12, identifier:_; 13, identifier:goal; 14, call; 14, 15; 14, 16; 15, identifier:sorted; 16, argument_list; 16, 17; 17, call; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:Goal; 21, identifier:_goal_by_name; 22, identifier:items; 23, argument_list; 24, if_clause; 24, 25; 25, attribute; 25, 26; 25, 27; 26, identifier:goal; 27, identifier:active | def all():
"""Returns all active registered goals, sorted alphabetically by name.
:API: public
"""
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, 8; 5, 16; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:best_url; 11, subscript; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:parsed_urls; 15, integer:0; 16, try_statement; 16, 17; 16, 21; 16, 63; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, yield; 19, 20; 20, identifier:best_url; 21, except_clause; 21, 22; 21, 23; 22, identifier:Exception; 23, block; 23, 24; 23, 32; 23, 33; 23, 62; 24, expression_statement; 24, 25; 25, augmented_assignment:+=; 25, 26; 25, 31; 26, subscript; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:unsuccessful_calls; 30, identifier:best_url; 31, integer:1; 32, comment; 33, if_statement; 33, 34; 33, 43; 34, comparison_operator:>; 34, 35; 34, 40; 35, subscript; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:unsuccessful_calls; 39, identifier:best_url; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:max_failures; 43, block; 43, 44; 43, 54; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:parsed_urls; 50, identifier:rotate; 51, argument_list; 51, 52; 52, unary_operator:-; 52, 53; 53, integer:1; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 61; 56, subscript; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:unsuccessful_calls; 60, identifier:best_url; 61, integer:0; 62, raise_statement; 63, else_clause; 63, 64; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 72; 67, subscript; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:unsuccessful_calls; 71, identifier:best_url; 72, integer:0 | def select_best_url(self):
"""Select `best` url.
Since urls are pre-sorted w.r.t. their ping times, we simply return the first element
from the list. And we always return the same url unless we observe greater than max
allowed number of consecutive failures. In this case, we would return the next `best`
url, and append the previous best one to the end of list (essentially rotate to the left
by one element).
"""
best_url = self.parsed_urls[0]
try:
yield best_url
except Exception:
self.unsuccessful_calls[best_url] += 1
# Not thread-safe but pool used by cache is based on subprocesses, therefore no race.
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, 9; 6, 16; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:target_set; 12, call; 12, 13; 12, 14; 13, identifier:set; 14, argument_list; 14, 15; 15, identifier:targets; 16, return_statement; 16, 17; 17, list_comprehension; 17, 18; 17, 19; 17, 28; 18, identifier:t; 19, for_in_clause; 19, 20; 19, 21; 20, identifier:t; 21, call; 21, 22; 21, 23; 22, identifier:reversed; 23, argument_list; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:sort_targets; 26, argument_list; 26, 27; 27, identifier:targets; 28, if_clause; 28, 29; 29, comparison_operator:in; 29, 30; 29, 31; 30, identifier:t; 31, identifier:target_set | def _topological_sort(self, targets):
"""Topologically order a list of 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, 8; 5, 9; 5, 15; 5, 21; 5, 56; 5, 75; 5, 76; 5, 89; 6, expression_statement; 6, 7; 7, comment; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:keys; 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:metrics; 18, call; 18, 19; 18, 20; 19, identifier:set; 20, argument_list; 21, for_statement; 21, 22; 21, 23; 21, 26; 22, identifier:sample; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:sortmerna; 26, block; 26, 27; 27, for_statement; 27, 28; 27, 29; 27, 34; 28, identifier:key; 29, subscript; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:sortmerna; 33, identifier:sample; 34, block; 34, 35; 35, if_statement; 35, 36; 35, 48; 36, boolean_operator:and; 36, 37; 36, 44; 37, not_operator; 37, 38; 38, comparison_operator:in; 38, 39; 38, 40; 39, identifier:key; 40, list:["total", "rRNA", "non_rRNA"]; 40, 41; 40, 42; 40, 43; 41, string:"total"; 42, string:"rRNA"; 43, string:"non_rRNA"; 44, not_operator; 44, 45; 45, comparison_operator:in; 45, 46; 45, 47; 46, string:"_pct"; 47, identifier:key; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:metrics; 53, identifier:add; 54, argument_list; 54, 55; 55, identifier:key; 56, for_statement; 56, 57; 56, 58; 56, 59; 57, identifier:key; 58, identifier:metrics; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:keys; 64, identifier:key; 65, dictionary; 65, 66; 66, pair; 66, 67; 66, 68; 67, string:'name'; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:key; 71, identifier:replace; 72, argument_list; 72, 73; 72, 74; 73, string:"_count"; 74, string:""; 75, comment; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:pconfig; 79, dictionary; 79, 80; 79, 83; 79, 86; 80, pair; 80, 81; 80, 82; 81, string:'id'; 82, string:'sortmerna-detailed-plot'; 83, pair; 83, 84; 83, 85; 84, string:'title'; 85, string:'SortMeRNA: Hit Counts'; 86, pair; 86, 87; 86, 88; 87, string:'ylab'; 88, string:'Reads'; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:add_section; 94, argument_list; 94, 95; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:plot; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:bargraph; 100, identifier:plot; 101, argument_list; 101, 102; 101, 105; 101, 106; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:sortmerna; 105, identifier:keys; 106, identifier:pconfig | def sortmerna_detailed_barplot (self):
""" Make the HighCharts HTML to plot the sortmerna rates """
# Specify the order of the different possible categories
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","") }
# Config for the plot
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, 9; 6, 17; 6, 35; 6, 45; 6, 70; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:default_allowed; 12, call; 12, 13; 12, 14; 13, identifier:set; 14, argument_list; 14, 15; 15, list:["X"]; 15, 16; 16, string:"X"; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:allowed_chroms; 20, call; 20, 21; 20, 22; 21, identifier:set; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 32; 24, attribute; 24, 25; 24, 31; 25, call; 25, 26; 25, 27; 26, identifier:getattr; 27, argument_list; 27, 28; 27, 29; 27, 30; 28, identifier:config; 29, string:"goleft_indexcov_config"; 30, dictionary; 31, identifier:get; 32, argument_list; 32, 33; 32, 34; 33, string:"chromosomes"; 34, list:[]; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:chrom_clean; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:chrom; 41, identifier:replace; 42, argument_list; 42, 43; 42, 44; 43, string:"chr"; 44, string:""; 45, try_statement; 45, 46; 45, 54; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:chrom_clean; 50, call; 50, 51; 50, 52; 51, identifier:int; 52, argument_list; 52, 53; 53, identifier:chrom_clean; 54, except_clause; 54, 55; 54, 56; 55, identifier:ValueError; 56, block; 56, 57; 57, if_statement; 57, 58; 57, 65; 58, boolean_operator:and; 58, 59; 58, 62; 59, comparison_operator:not; 59, 60; 59, 61; 60, identifier:chrom_clean; 61, identifier:default_allowed; 62, comparison_operator:not; 62, 63; 62, 64; 63, identifier:chrom_clean; 64, identifier:allowed_chroms; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:chrom_clean; 69, None; 70, if_statement; 70, 71; 70, 72; 70, 84; 71, identifier:allowed_chroms; 72, block; 72, 73; 73, if_statement; 73, 74; 73, 81; 74, boolean_operator:or; 74, 75; 74, 78; 75, comparison_operator:in; 75, 76; 75, 77; 76, identifier:chrom; 77, identifier:allowed_chroms; 78, comparison_operator:in; 78, 79; 78, 80; 79, identifier:chrom_clean; 80, identifier:allowed_chroms; 81, block; 81, 82; 82, return_statement; 82, 83; 83, identifier:chrom_clean; 84, elif_clause; 84, 85; 84, 94; 85, boolean_operator:or; 85, 86; 85, 91; 86, call; 86, 87; 86, 88; 87, identifier:isinstance; 88, argument_list; 88, 89; 88, 90; 89, identifier:chrom_clean; 90, identifier:int; 91, comparison_operator:in; 91, 92; 91, 93; 92, identifier:chrom_clean; 93, identifier:default_allowed; 94, block; 94, 95; 95, return_statement; 95, 96; 96, identifier:chrom_clean | def _short_chrom(self, chrom):
"""Plot standard chromosomes + X, sorted numerically.
Allows specification from a list of chromosomes via config
for non-standard genomes.
"""
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, 8; 5, 15; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:values; 11, call; 11, 12; 11, 13; 12, identifier:vals_sorted_by_key; 13, argument_list; 13, 14; 14, identifier:mapping; 15, for_statement; 15, 16; 15, 17; 15, 18; 16, identifier:obj; 17, identifier:values; 18, block; 18, 19; 18, 23; 18, 49; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:mapping; 22, False; 23, try_statement; 23, 24; 23, 29; 23, 33; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, attribute; 26, 27; 26, 28; 27, identifier:obj; 28, identifier:items; 29, except_clause; 29, 30; 29, 31; 30, identifier:AttributeError; 31, block; 31, 32; 32, pass_statement; 33, else_clause; 33, 34; 34, block; 34, 35; 34, 39; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:mapping; 38, True; 39, for_statement; 39, 40; 39, 41; 39, 45; 40, identifier:subobj; 41, call; 41, 42; 41, 43; 42, identifier:deepvalues; 43, argument_list; 43, 44; 44, identifier:obj; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, yield; 47, 48; 48, identifier:subobj; 49, if_statement; 49, 50; 49, 52; 50, not_operator; 50, 51; 51, identifier:mapping; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, yield; 54, 55; 55, identifier:obj | def deepvalues(mapping):
"""Iterates over nested mapping, depth-first, in sorted order by key."""
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; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, return_statement; 8, 9; 9, list_comprehension; 9, 10; 9, 19; 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 values(self):
"""Return a list of all the message's header values.
These will be sorted in the order they appeared in the original
message, or were added to the message, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
"""
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; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, return_statement; 8, 9; 9, list_comprehension; 9, 10; 9, 21; 10, tuple; 10, 11; 10, 12; 11, identifier:k; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:policy; 17, identifier:header_fetch_parse; 18, argument_list; 18, 19; 18, 20; 19, identifier:k; 20, identifier:v; 21, for_in_clause; 21, 22; 21, 25; 22, pattern_list; 22, 23; 22, 24; 23, identifier:k; 24, identifier:v; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_headers | def items(self):
"""Get all the message's header fields and values.
These will be sorted in the order they appeared in the original
message, or were added to the message, and may contain duplicates.
Any fields deleted and re-inserted are always appended to the header
list.
"""
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, 12; 9, 16; 9, 24; 9, 56; 9, 62; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:values; 15, list:[]; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:name; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:name; 22, identifier:lower; 23, argument_list; 24, for_statement; 24, 25; 24, 28; 24, 31; 25, pattern_list; 25, 26; 25, 27; 26, identifier:k; 27, identifier:v; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:_headers; 31, block; 31, 32; 32, if_statement; 32, 33; 32, 40; 33, comparison_operator:==; 33, 34; 33, 39; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:k; 37, identifier:lower; 38, argument_list; 39, identifier:name; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:values; 45, identifier:append; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:policy; 52, identifier:header_fetch_parse; 53, argument_list; 53, 54; 53, 55; 54, identifier:k; 55, identifier:v; 56, if_statement; 56, 57; 56, 59; 57, not_operator; 57, 58; 58, identifier:values; 59, block; 59, 60; 60, return_statement; 60, 61; 61, identifier:failobj; 62, return_statement; 62, 63; 63, identifier:values | def get_all(self, name, failobj=None):
"""Return a list of all the values for the named field.
These will be sorted in the order they appeared in the original
message, and may contain duplicates. Any fields deleted and
re-inserted are always appended to the header list.
If no such fields exist, failobj is returned (defaults to 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, 11; 8, 12; 8, 21; 9, expression_statement; 9, 10; 10, comment; 11, comment; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:job; 17, identifier:fileStore; 18, identifier:logToMaster; 19, argument_list; 19, 20; 20, string:"Starting the merge sort"; 21, return_statement; 21, 22; 22, call; 22, 23; 22, 39; 23, attribute; 23, 24; 23, 38; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:job; 27, identifier:addChildJobFn; 28, argument_list; 28, 29; 28, 30; 28, 31; 28, 32; 28, 35; 29, identifier:down; 30, identifier:input_file_id; 31, identifier:n; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:down_checkpoints; 34, identifier:down_checkpoints; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:memory; 37, string:'600M'; 38, identifier:rv; 39, argument_list | def setup(job, input_file_id, n, down_checkpoints):
"""Sets up the sort.
Returns the FileID of the sorted file
"""
# Write the input file to the file store
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, 11; 8, 12; 8, 26; 8, 37; 9, expression_statement; 9, 10; 10, comment; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:input_file; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:job; 19, identifier:fileStore; 20, identifier:readGlobalFile; 21, argument_list; 21, 22; 21, 23; 22, identifier:input_file_id; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:cache; 25, False; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:length; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:os; 33, identifier:path; 34, identifier:getsize; 35, argument_list; 35, 36; 36, identifier:input_file; 37, if_statement; 37, 38; 37, 41; 37, 42; 37, 197; 38, comparison_operator:>; 38, 39; 38, 40; 39, identifier:length; 40, identifier:n; 41, comment; 42, block; 42, 43; 42, 61; 42, 62; 42, 71; 42, 81; 42, 103; 42, 113; 42, 135; 42, 136; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:job; 48, identifier:fileStore; 49, identifier:logToMaster; 50, argument_list; 50, 51; 50, 56; 51, binary_operator:%; 51, 52; 51, 53; 52, string:"Splitting file: %s of size: %s"; 53, tuple; 53, 54; 53, 55; 54, identifier:input_file_id; 55, identifier:length; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:level; 58, attribute; 58, 59; 58, 60; 59, identifier:logging; 60, identifier:CRITICAL; 61, comment; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:mid_point; 65, call; 65, 66; 65, 67; 66, identifier:get_midpoint; 67, argument_list; 67, 68; 67, 69; 67, 70; 68, identifier:input_file; 69, integer:0; 70, identifier:length; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:t1; 74, call; 74, 75; 74, 80; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:job; 78, identifier:fileStore; 79, identifier:getLocalTempFile; 80, argument_list; 81, with_statement; 81, 82; 81, 92; 82, with_clause; 82, 83; 83, with_item; 83, 84; 84, as_pattern; 84, 85; 84, 90; 85, call; 85, 86; 85, 87; 86, identifier:open; 87, argument_list; 87, 88; 87, 89; 88, identifier:t1; 89, string:'w'; 90, as_pattern_target; 90, 91; 91, identifier:fH; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 96; 95, identifier:copy_subrange_of_file; 96, argument_list; 96, 97; 96, 98; 96, 99; 96, 102; 97, identifier:input_file; 98, integer:0; 99, binary_operator:+; 99, 100; 99, 101; 100, identifier:mid_point; 101, integer:1; 102, identifier:fH; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:t2; 106, call; 106, 107; 106, 112; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:job; 110, identifier:fileStore; 111, identifier:getLocalTempFile; 112, argument_list; 113, with_statement; 113, 114; 113, 124; 114, with_clause; 114, 115; 115, with_item; 115, 116; 116, as_pattern; 116, 117; 116, 122; 117, call; 117, 118; 117, 119; 118, identifier:open; 119, argument_list; 119, 120; 119, 121; 120, identifier:t2; 121, string:'w'; 122, as_pattern_target; 122, 123; 123, identifier:fH; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:copy_subrange_of_file; 128, argument_list; 128, 129; 128, 130; 128, 133; 128, 134; 129, identifier:input_file; 130, binary_operator:+; 130, 131; 130, 132; 131, identifier:mid_point; 132, integer:1; 133, identifier:length; 134, identifier:fH; 135, comment; 136, return_statement; 136, 137; 137, call; 137, 138; 137, 196; 138, attribute; 138, 139; 138, 195; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:job; 142, identifier:addFollowOnJobFn; 143, argument_list; 143, 144; 143, 145; 143, 170; 144, identifier:up; 145, call; 145, 146; 145, 169; 146, attribute; 146, 147; 146, 168; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:job; 150, identifier:addChildJobFn; 151, argument_list; 151, 152; 151, 153; 151, 161; 151, 162; 151, 165; 152, identifier:down; 153, call; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:job; 157, identifier:fileStore; 158, identifier:writeGlobalFile; 159, argument_list; 159, 160; 160, identifier:t1; 161, identifier:n; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:down_checkpoints; 164, identifier:down_checkpoints; 165, keyword_argument; 165, 166; 165, 167; 166, identifier:memory; 167, string:'600M'; 168, identifier:rv; 169, argument_list; 170, call; 170, 171; 170, 194; 171, attribute; 171, 172; 171, 193; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:job; 175, identifier:addChildJobFn; 176, argument_list; 176, 177; 176, 178; 176, 186; 176, 187; 176, 190; 177, identifier:down; 178, call; 178, 179; 178, 184; 179, attribute; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:job; 182, identifier:fileStore; 183, identifier:writeGlobalFile; 184, argument_list; 184, 185; 185, identifier:t2; 186, identifier:n; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:down_checkpoints; 189, identifier:down_checkpoints; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:memory; 192, string:'600M'; 193, identifier:rv; 194, argument_list; 195, identifier:rv; 196, argument_list; 197, else_clause; 197, 198; 197, 199; 198, comment; 199, block; 199, 200; 199, 218; 199, 219; 199, 229; 199, 235; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 207; 202, attribute; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:job; 205, identifier:fileStore; 206, identifier:logToMaster; 207, argument_list; 207, 208; 207, 213; 208, binary_operator:%; 208, 209; 208, 210; 209, string:"Sorting file: %s of size: %s"; 210, tuple; 210, 211; 210, 212; 211, identifier:input_file_id; 212, identifier:length; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:level; 215, attribute; 215, 216; 215, 217; 216, identifier:logging; 217, identifier:CRITICAL; 218, comment; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:output_file; 222, call; 222, 223; 222, 228; 223, attribute; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:job; 226, identifier:fileStore; 227, identifier:getLocalTempFile; 228, argument_list; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 232; 231, identifier:sort; 232, argument_list; 232, 233; 232, 234; 233, identifier:input_file; 234, identifier:output_file; 235, return_statement; 235, 236; 236, call; 236, 237; 236, 242; 237, attribute; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:job; 240, identifier:fileStore; 241, identifier:writeGlobalFile; 242, argument_list; 242, 243; 243, identifier:output_file | def down(job, input_file_id, n, down_checkpoints):
"""Input is a file and a range into that file to sort and an output location in which
to write the sorted file.
If the range is larger than a threshold N the range is divided recursively and
a follow on job is then created which merges back the results. Otherwise,
the file is sorted and placed in the output.
"""
# Read the file
input_file = job.fileStore.readGlobalFile(input_file_id, cache=False)
length = os.path.getsize(input_file)
if length > n:
# We will subdivide the file
job.fileStore.logToMaster("Splitting file: %s of size: %s"
% (input_file_id, length), level=logging.CRITICAL)
# Split the file into two copies
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)
# Call the down function recursively
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:
# We can sort this bit of the file
job.fileStore.logToMaster("Sorting file: %s of size: %s"
% (input_file_id, length), level=logging.CRITICAL)
# Sort the copy and write back to the fileStore
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, 9; 6, 17; 6, 25; 6, 31; 6, 37; 6, 45; 6, 56; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:filehandle; 12, call; 12, 13; 12, 14; 13, identifier:open; 14, argument_list; 14, 15; 14, 16; 15, identifier:in_file; 16, string:'r'; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:lines; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:filehandle; 23, identifier:readlines; 24, argument_list; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:filehandle; 29, identifier:close; 30, argument_list; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:lines; 35, identifier:sort; 36, argument_list; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:filehandle; 40, call; 40, 41; 40, 42; 41, identifier:open; 42, argument_list; 42, 43; 42, 44; 43, identifier:out_file; 44, string:'w'; 45, for_statement; 45, 46; 45, 47; 45, 48; 46, identifier:line; 47, identifier:lines; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:filehandle; 53, identifier:write; 54, argument_list; 54, 55; 55, identifier:line; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:filehandle; 60, identifier:close; 61, argument_list | def sort(in_file, out_file):
"""Sorts the given 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, 10; 7, 18; 7, 57; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:line2; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:filehandle_2; 16, identifier:readline; 17, argument_list; 18, for_statement; 18, 19; 18, 20; 18, 25; 19, identifier:line1; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:filehandle_1; 23, identifier:readlines; 24, argument_list; 25, block; 25, 26; 25, 50; 26, while_statement; 26, 27; 26, 34; 27, boolean_operator:and; 27, 28; 27, 31; 28, comparison_operator:!=; 28, 29; 28, 30; 29, identifier:line2; 30, string:''; 31, comparison_operator:<=; 31, 32; 31, 33; 32, identifier:line2; 33, identifier:line1; 34, block; 34, 35; 34, 42; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:output_filehandle; 39, identifier:write; 40, argument_list; 40, 41; 41, identifier:line2; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:line2; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:filehandle_2; 48, identifier:readline; 49, argument_list; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:output_filehandle; 54, identifier:write; 55, argument_list; 55, 56; 56, identifier:line1; 57, while_statement; 57, 58; 57, 61; 58, comparison_operator:!=; 58, 59; 58, 60; 59, identifier:line2; 60, string:''; 61, block; 61, 62; 61, 69; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:output_filehandle; 66, identifier:write; 67, argument_list; 67, 68; 68, identifier:line2; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:line2; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:filehandle_2; 75, identifier:readline; 76, argument_list | def merge(filehandle_1, filehandle_2, output_filehandle):
"""Merges together two files maintaining sorted order.
"""
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, 10; 7, 18; 8, expression_statement; 8, 9; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:title; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:title; 16, identifier:lower; 17, argument_list; 18, if_statement; 18, 19; 18, 24; 18, 73; 19, comparison_operator:!=; 19, 20; 19, 21; 20, identifier:title; 21, attribute; 21, 22; 21, 23; 22, identifier:options; 23, identifier:sortCategory; 24, block; 24, 25; 24, 71; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:s; 28, binary_operator:%; 28, 29; 28, 30; 29, string:"| %*s%*s%*s%*s%*s "; 30, tuple; 30, 31; 30, 38; 30, 39; 30, 46; 30, 47; 30, 54; 30, 55; 30, 62; 30, 63; 30, 70; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:columnWidths; 34, identifier:getWidth; 35, argument_list; 35, 36; 35, 37; 36, identifier:title; 37, string:"min"; 38, string:"min"; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:columnWidths; 42, identifier:getWidth; 43, argument_list; 43, 44; 43, 45; 44, identifier:title; 45, string:"med"; 46, string:"med"; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:columnWidths; 50, identifier:getWidth; 51, argument_list; 51, 52; 51, 53; 52, identifier:title; 53, string:"ave"; 54, string:"ave"; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:columnWidths; 58, identifier:getWidth; 59, argument_list; 59, 60; 59, 61; 60, identifier:title; 61, string:"max"; 62, string:"max"; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:columnWidths; 66, identifier:getWidth; 67, argument_list; 67, 68; 67, 69; 68, identifier:title; 69, string:"total"; 70, string:"total"; 71, return_statement; 71, 72; 72, identifier:s; 73, else_clause; 73, 74; 74, block; 74, 75; 74, 79; 74, 157; 74, 161; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:s; 78, string:"| "; 79, for_statement; 79, 80; 79, 83; 79, 129; 80, pattern_list; 80, 81; 80, 82; 81, identifier:field; 82, identifier:width; 83, 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"))]; 83, 84; 83, 93; 83, 102; 83, 111; 83, 120; 84, tuple; 84, 85; 84, 86; 85, string:"min"; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:columnWidths; 89, identifier:getWidth; 90, argument_list; 90, 91; 90, 92; 91, identifier:title; 92, string:"min"; 93, tuple; 93, 94; 93, 95; 94, string:"med"; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:columnWidths; 98, identifier:getWidth; 99, argument_list; 99, 100; 99, 101; 100, identifier:title; 101, string:"med"; 102, tuple; 102, 103; 102, 104; 103, string:"ave"; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:columnWidths; 107, identifier:getWidth; 108, argument_list; 108, 109; 108, 110; 109, identifier:title; 110, string:"ave"; 111, tuple; 111, 112; 111, 113; 112, string:"max"; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:columnWidths; 116, identifier:getWidth; 117, argument_list; 117, 118; 117, 119; 118, identifier:title; 119, string:"max"; 120, tuple; 120, 121; 120, 122; 121, string:"total"; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:columnWidths; 125, identifier:getWidth; 126, argument_list; 126, 127; 126, 128; 127, identifier:title; 128, string:"total"; 129, block; 129, 130; 130, if_statement; 130, 131; 130, 136; 130, 147; 131, comparison_operator:==; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:options; 134, identifier:sortField; 135, identifier:field; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, augmented_assignment:+=; 138, 139; 138, 140; 139, identifier:s; 140, binary_operator:%; 140, 141; 140, 142; 141, string:"%*s*"; 142, tuple; 142, 143; 142, 146; 143, binary_operator:-; 143, 144; 143, 145; 144, identifier:width; 145, integer:1; 146, identifier:field; 147, else_clause; 147, 148; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, augmented_assignment:+=; 150, 151; 150, 152; 151, identifier:s; 152, binary_operator:%; 152, 153; 152, 154; 153, string:"%*s"; 154, tuple; 154, 155; 154, 156; 155, identifier:width; 156, identifier:field; 157, expression_statement; 157, 158; 158, augmented_assignment:+=; 158, 159; 158, 160; 159, identifier:s; 160, string:" "; 161, return_statement; 161, 162; 162, identifier:s | def decorateSubHeader(title, columnWidths, options):
""" Add a marker to the correct field if the TITLE is sorted on.
"""
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, 9; 6, 28; 6, 36; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:longforms; 12, dictionary; 12, 13; 12, 16; 12, 19; 12, 22; 12, 25; 13, pair; 13, 14; 13, 15; 14, string:"med"; 15, string:"median"; 16, pair; 16, 17; 16, 18; 17, string:"ave"; 18, string:"average"; 19, pair; 19, 20; 19, 21; 20, string:"min"; 21, string:"min"; 22, pair; 22, 23; 22, 24; 23, string:"total"; 24, string:"total"; 25, pair; 25, 26; 25, 27; 26, string:"max"; 27, string:"max"; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:sortField; 31, subscript; 31, 32; 31, 33; 32, identifier:longforms; 33, attribute; 33, 34; 33, 35; 34, identifier:options; 35, identifier:sortField; 36, if_statement; 36, 37; 36, 61; 36, 88; 36, 113; 37, parenthesized_expression; 37, 38; 38, boolean_operator:or; 38, 39; 38, 56; 39, boolean_operator:or; 39, 40; 39, 51; 40, boolean_operator:or; 40, 41; 40, 46; 41, comparison_operator:==; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:options; 44, identifier:sortCategory; 45, string:"time"; 46, comparison_operator:==; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:options; 49, identifier:sortCategory; 50, string:"clock"; 51, comparison_operator:==; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:options; 54, identifier:sortCategory; 55, string:"wait"; 56, comparison_operator:==; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:options; 59, identifier:sortCategory; 60, string:"memory"; 61, block; 61, 62; 62, return_statement; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:sorted; 65, argument_list; 65, 66; 65, 67; 65, 83; 66, identifier:jobTypes; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:key; 69, lambda; 69, 70; 69, 72; 70, lambda_parameters; 70, 71; 71, identifier:tag; 72, call; 72, 73; 72, 74; 73, identifier:getattr; 74, argument_list; 74, 75; 74, 76; 75, identifier:tag; 76, binary_operator:%; 76, 77; 76, 78; 77, string:"%s_%s"; 78, tuple; 78, 79; 78, 80; 79, identifier:sortField; 80, attribute; 80, 81; 80, 82; 81, identifier:options; 82, identifier:sortCategory; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:reverse; 85, attribute; 85, 86; 85, 87; 86, identifier:options; 87, identifier:sortReverse; 88, elif_clause; 88, 89; 88, 94; 89, comparison_operator:==; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:options; 92, identifier:sortCategory; 93, string:"alpha"; 94, block; 94, 95; 95, return_statement; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:sorted; 98, argument_list; 98, 99; 98, 100; 98, 108; 99, identifier:jobTypes; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:key; 102, lambda; 102, 103; 102, 105; 103, lambda_parameters; 103, 104; 104, identifier:tag; 105, attribute; 105, 106; 105, 107; 106, identifier:tag; 107, identifier:name; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:reverse; 110, attribute; 110, 111; 110, 112; 111, identifier:options; 112, identifier:sortReverse; 113, elif_clause; 113, 114; 113, 119; 114, comparison_operator:==; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:options; 117, identifier:sortCategory; 118, string:"count"; 119, block; 119, 120; 120, return_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:sorted; 123, argument_list; 123, 124; 123, 125; 123, 133; 124, identifier:jobTypes; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:key; 127, lambda; 127, 128; 127, 130; 128, lambda_parameters; 128, 129; 129, identifier:tag; 130, attribute; 130, 131; 130, 132; 131, identifier:tag; 132, identifier:total_number; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:reverse; 135, attribute; 135, 136; 135, 137; 136, identifier:options; 137, identifier:sortReverse | def sortJobs(jobTypes, options):
""" Return a jobTypes all sorted.
"""
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, 9; 6, 10; 6, 20; 6, 28; 6, 41; 6, 56; 6, 64; 6, 75; 6, 87; 6, 107; 7, expression_statement; 7, 8; 8, comment; 9, comment; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:tau_y; 13, subscript; 13, 14; 13, 17; 13, 19; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:tau_matrix; 17, slice; 17, 18; 18, colon; 19, identifier:y; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 25; 22, subscript; 22, 23; 22, 24; 23, identifier:tau_y; 24, identifier:y; 25, attribute; 25, 26; 25, 27; 26, identifier:np; 27, identifier:NaN; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:temp; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:np; 34, identifier:empty; 35, argument_list; 35, 36; 36, list:[self.n_nodes, 3]; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:n_nodes; 40, integer:3; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 48; 43, subscript; 43, 44; 43, 45; 43, 47; 44, identifier:temp; 45, slice; 45, 46; 46, colon; 47, integer:0; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:np; 51, identifier:arange; 52, argument_list; 52, 53; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:n_nodes; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 63; 58, subscript; 58, 59; 58, 60; 58, 62; 59, identifier:temp; 60, slice; 60, 61; 61, colon; 62, integer:1; 63, identifier:tau_y; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 71; 66, subscript; 66, 67; 66, 68; 66, 70; 67, identifier:temp; 68, slice; 68, 69; 69, colon; 70, integer:2; 71, call; 71, 72; 71, 73; 72, identifier:abs; 73, argument_list; 73, 74; 74, identifier:tau_y; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 85; 77, subscript; 77, 78; 77, 79; 78, identifier:temp; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:np; 82, identifier:isnan; 83, argument_list; 83, 84; 84, identifier:temp; 85, unary_operator:-; 85, 86; 86, integer:10; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:tau_sorted; 90, subscript; 90, 91; 90, 92; 91, identifier:temp; 92, subscript; 92, 93; 92, 102; 93, call; 93, 94; 93, 101; 94, attribute; 94, 95; 94, 100; 95, subscript; 95, 96; 95, 97; 95, 99; 96, identifier:temp; 97, slice; 97, 98; 98, colon; 99, integer:2; 100, identifier:argsort; 101, argument_list; 102, slice; 102, 103; 102, 104; 102, 105; 103, colon; 104, colon; 105, unary_operator:-; 105, 106; 106, integer:1; 107, return_statement; 107, 108; 108, identifier:tau_sorted | def _sort_tau_by_y(self, y):
"""Sort tau matrix by dependece with variable y.
Args:
:param y: index of variable of intrest
:type y: int
"""
# first column is the variable of interest
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; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, return_statement; 8, 9; 9, call; 9, 10; 9, 11; 10, identifier:sorted; 11, argument_list; 11, 12; 11, 13; 12, identifier:edges; 13, keyword_argument; 13, 14; 13, 15; 14, identifier:key; 15, lambda; 15, 16; 15, 18; 16, lambda_parameters; 16, 17; 17, identifier:x; 18, tuple; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:x; 21, identifier:L; 22, attribute; 22, 23; 22, 24; 23, identifier:x; 24, identifier:R | def sort_edge(edges):
"""Sort iterable of edges first by left node indices then right.
Args:
edges(list[Edge]): List of edges to be sorted.
Returns:
list[Edge]: Sorted list by left and right node indices.
"""
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, 28; 25, 40; 25, 54; 25, 113; 25, 114; 25, 123; 25, 152; 25, 153; 25, 169; 25, 182; 25, 183; 25, 187; 25, 209; 25, 218; 25, 253; 25, 268; 25, 332; 25, 336; 25, 346; 25, 356; 25, 366; 26, expression_statement; 26, 27; 27, comment; 28, if_statement; 28, 29; 28, 32; 29, boolean_operator:and; 29, 30; 29, 31; 30, identifier:file; 31, identifier:model_code; 32, block; 32, 33; 33, raise_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:ValueError; 36, argument_list; 36, 37; 37, concatenated_string; 37, 38; 37, 39; 38, string:"Specify stan model with `file` or `model_code`, "; 39, string:"not both."; 40, if_statement; 40, 41; 40, 48; 41, boolean_operator:and; 41, 42; 41, 45; 42, comparison_operator:is; 42, 43; 42, 44; 43, identifier:file; 44, None; 45, comparison_operator:is; 45, 46; 45, 47; 46, identifier:model_code; 47, None; 48, block; 48, 49; 49, raise_statement; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:ValueError; 52, argument_list; 52, 53; 53, string:"Model file missing and empty model_code."; 54, if_statement; 54, 55; 54, 58; 55, comparison_operator:is; 55, 56; 55, 57; 56, identifier:file; 57, None; 58, block; 58, 59; 59, if_statement; 59, 60; 59, 65; 59, 103; 60, call; 60, 61; 60, 62; 61, identifier:isinstance; 62, argument_list; 62, 63; 62, 64; 63, identifier:file; 64, identifier:string_types; 65, block; 65, 66; 66, try_statement; 66, 67; 66, 93; 67, block; 67, 68; 68, with_statement; 68, 69; 68, 84; 69, with_clause; 69, 70; 70, with_item; 70, 71; 71, as_pattern; 71, 72; 71, 82; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:io; 75, identifier:open; 76, argument_list; 76, 77; 76, 78; 76, 79; 77, identifier:file; 78, string:'rt'; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:encoding; 81, identifier:charset; 82, as_pattern_target; 82, 83; 83, identifier:f; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:model_code; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:f; 91, identifier:read; 92, argument_list; 93, except_clause; 93, 94; 94, block; 94, 95; 94, 102; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:logger; 99, identifier:critical; 100, argument_list; 100, 101; 101, string:"Unable to read file specified by `file`."; 102, raise_statement; 103, else_clause; 103, 104; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:model_code; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:file; 111, identifier:read; 112, argument_list; 113, comment; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:model_code_bytes; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:model_code; 120, identifier:encode; 121, argument_list; 121, 122; 122, string:'utf-8'; 123, if_statement; 123, 124; 123, 127; 123, 140; 124, comparison_operator:is; 124, 125; 124, 126; 125, identifier:include_paths; 126, None; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:include_paths; 131, list:[os.path.abspath('.')]; 131, 132; 132, call; 132, 133; 132, 138; 133, attribute; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:os; 136, identifier:path; 137, identifier:abspath; 138, argument_list; 138, 139; 139, string:'.'; 140, elif_clause; 140, 141; 140, 146; 141, call; 141, 142; 141, 143; 142, identifier:isinstance; 143, argument_list; 143, 144; 143, 145; 144, identifier:include_paths; 145, identifier:string_types; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:include_paths; 150, list:[include_paths]; 150, 151; 151, identifier:include_paths; 152, comment; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:include_paths; 156, list_comprehension; 156, 157; 156, 166; 157, call; 157, 158; 157, 163; 158, attribute; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:os; 161, identifier:path; 162, identifier:join; 163, argument_list; 163, 164; 163, 165; 164, identifier:path; 165, string:""; 166, for_in_clause; 166, 167; 166, 168; 167, identifier:path; 168, identifier:include_paths; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:include_paths_bytes; 172, list_comprehension; 172, 173; 172, 179; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:path; 176, identifier:encode; 177, argument_list; 177, 178; 178, string:'utf-8'; 179, for_in_clause; 179, 180; 179, 181; 180, identifier:path; 181, identifier:include_paths; 182, comment; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:allow_undefined; 186, False; 187, if_statement; 187, 188; 187, 189; 187, 190; 188, identifier:obfuscate_model_name; 189, comment; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:model_name; 194, parenthesized_expression; 194, 195; 195, binary_operator:+; 195, 196; 195, 199; 196, binary_operator:+; 196, 197; 196, 198; 197, identifier:model_name; 198, string:'_'; 199, call; 199, 200; 199, 208; 200, attribute; 200, 201; 200, 207; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:hashlib; 204, identifier:md5; 205, argument_list; 205, 206; 206, identifier:model_code_bytes; 207, identifier:hexdigest; 208, argument_list; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:model_name_bytes; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:model_name; 215, identifier:encode; 216, argument_list; 216, 217; 217, string:'ascii'; 218, if_statement; 218, 219; 218, 225; 218, 226; 218, 231; 219, not_operator; 219, 220; 220, call; 220, 221; 220, 222; 221, identifier:isinstance; 222, argument_list; 222, 223; 222, 224; 223, identifier:file; 224, identifier:string_types; 225, comment; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:filename_bytes; 230, string:b'unknown file name'; 231, else_clause; 231, 232; 231, 233; 232, comment; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:filename_bytes; 237, call; 237, 238; 237, 251; 238, attribute; 238, 239; 238, 250; 239, subscript; 239, 240; 239, 248; 240, call; 240, 241; 240, 246; 241, attribute; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:os; 244, identifier:path; 245, identifier:split; 246, argument_list; 246, 247; 247, identifier:file; 248, unary_operator:-; 248, 249; 249, integer:1; 250, identifier:encode; 251, argument_list; 251, 252; 252, string:'utf-8'; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:result; 256, call; 256, 257; 256, 262; 257, attribute; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:pystan; 260, identifier:_api; 261, identifier:stanc; 262, argument_list; 262, 263; 262, 264; 262, 265; 262, 266; 262, 267; 263, identifier:model_code_bytes; 264, identifier:model_name_bytes; 265, identifier:allow_undefined; 266, identifier:filename_bytes; 267, identifier:include_paths_bytes; 268, if_statement; 268, 269; 268, 275; 268, 276; 268, 312; 269, comparison_operator:==; 269, 270; 269, 273; 270, subscript; 270, 271; 270, 272; 271, identifier:result; 272, string:'status'; 273, unary_operator:-; 273, 274; 274, integer:1; 275, comment; 276, block; 276, 277; 276, 283; 276, 297; 276, 307; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:msg; 280, subscript; 280, 281; 280, 282; 281, identifier:result; 282, string:'msg'; 283, if_statement; 283, 284; 283, 285; 283, 286; 284, identifier:PY2; 285, comment; 286, block; 286, 287; 287, expression_statement; 287, 288; 288, assignment; 288, 289; 288, 290; 289, identifier:msg; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:msg; 293, identifier:encode; 294, argument_list; 294, 295; 294, 296; 295, string:'ascii'; 296, string:'replace'; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:error_msg; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, string:"Failed to parse Stan model '{}'. Error message:\n{}"; 303, identifier:format; 304, argument_list; 304, 305; 304, 306; 305, identifier:model_name; 306, identifier:msg; 307, raise_statement; 307, 308; 308, call; 308, 309; 308, 310; 309, identifier:ValueError; 310, argument_list; 310, 311; 311, identifier:error_msg; 312, elif_clause; 312, 313; 312, 318; 312, 319; 313, comparison_operator:==; 313, 314; 313, 317; 314, subscript; 314, 315; 314, 316; 315, identifier:result; 316, string:'status'; 317, integer:0; 318, comment; 319, block; 319, 320; 320, expression_statement; 320, 321; 321, call; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, identifier:logger; 324, identifier:debug; 325, argument_list; 325, 326; 326, call; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, string:"Successfully parsed Stan model '{}'."; 329, identifier:format; 330, argument_list; 330, 331; 331, identifier:model_name; 332, delete_statement; 332, 333; 333, subscript; 333, 334; 333, 335; 334, identifier:result; 335, string:'msg'; 336, expression_statement; 336, 337; 337, call; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:result; 340, identifier:update; 341, argument_list; 341, 342; 342, dictionary; 342, 343; 343, pair; 343, 344; 343, 345; 344, string:'model_name'; 345, identifier:model_name; 346, expression_statement; 346, 347; 347, call; 347, 348; 347, 351; 348, attribute; 348, 349; 348, 350; 349, identifier:result; 350, identifier:update; 351, argument_list; 351, 352; 352, dictionary; 352, 353; 353, pair; 353, 354; 353, 355; 354, string:'model_code'; 355, identifier:model_code; 356, expression_statement; 356, 357; 357, call; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, identifier:result; 360, identifier:update; 361, argument_list; 361, 362; 362, dictionary; 362, 363; 363, pair; 363, 364; 363, 365; 364, string:'include_paths'; 365, identifier:include_paths; 366, return_statement; 366, 367; 367, 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):
"""Translate Stan model specification into C++ code.
Parameters
----------
file : {string, file}, optional
If filename, the string passed as an argument is expected to
be a filename containing the Stan model specification.
If file, the object passed must have a 'read' method (file-like
object) that is called to fetch the Stan model specification.
charset : string, 'utf-8' by default
If bytes or files are provided, this charset is used to decode.
model_code : string, optional
A string containing the Stan model specification. Alternatively,
the model may be provided with the parameter `file`.
model_name: string, 'anon_model' by default
A string naming the model. If none is provided 'anon_model' is
the default. However, if `file` is a filename, then the filename
will be used to provide a name.
include_paths: list of strings, optional
Paths for #include files defined in Stan code.
verbose : boolean, False by default
Indicates whether intermediate output should be piped to the
console. This output may be useful for debugging.
obfuscate_model_name : boolean, True by default
If False the model name in the generated C++ code will not be made
unique by the insertion of randomly generated characters.
Generally it is recommended that this parameter be left as True.
Returns
-------
stanc_ret : dict
A dictionary with the following keys: model_name, model_code,
cpp_code, and status. Status indicates the success of the translation
from Stan code into C++ code (success = 0, error = -1).
Notes
-----
C++ reserved words and Stan reserved words may not be used for
variable names; see the Stan User's Guide for a complete list.
The `#include` method follows a C/C++ syntax `#include foo/my_gp_funs.stan`.
The method needs to be at the start of the row, no whitespace is allowed.
After the included file no whitespace or comments are allowed.
`pystan.experimental`(PyStan 2.18) has a `fix_include`-function to clean the `#include`
statements from the `model_code`.
Example:
`from pystan.experimental import fix_include`
`model_code = fix_include(model_code)`
See also
--------
StanModel : Class representing a compiled Stan model
stan : Fit a model using Stan
References
----------
The Stan Development Team (2013) *Stan Modeling Language User's
Guide and Reference Manual*. <http://mc-stan.org/>.
Examples
--------
>>> stanmodelcode = '''
... data {
... int<lower=0> N;
... real y[N];
... }
...
... parameters {
... real mu;
... }
...
... model {
... mu ~ normal(0, 10);
... y ~ normal(mu, 1);
... }
... '''
>>> r = stanc(model_code=stanmodelcode, model_name = "normal1")
>>> sorted(r.keys())
['cppcode', 'model_code', 'model_cppname', 'model_name', 'status']
>>> r['model_name']
'normal1'
"""
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()
# bytes, going into C++ code
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]
# add trailing /
include_paths = [os.path.join(path, "") for path in include_paths]
include_paths_bytes = [path.encode('utf-8') for path in include_paths]
# set to False
allow_undefined = False
if obfuscate_model_name:
# Make the model name depend on the code.
model_name = (
model_name + '_' +
hashlib.md5(model_code_bytes).hexdigest())
model_name_bytes = model_name.encode('ascii')
if not isinstance(file, string_types):
# use default 'unknown file name'
filename_bytes = b'unknown file name'
else:
# use only the filename, used only for debug printing
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: # EXCEPTION_RC is -1
msg = result['msg']
if PY2:
# fix problem with unicode in error message in 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: # SUCCESS_RC is 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, 19; 16, 23; 16, 32; 16, 69; 17, expression_statement; 17, 18; 18, comment; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:options_by_distance; 22, dictionary; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:input_threshold; 26, binary_operator://; 26, 27; 26, 31; 27, call; 27, 28; 27, 29; 28, identifier:len; 29, argument_list; 29, 30; 30, identifier:input_; 31, integer:2; 32, for_statement; 32, 33; 32, 34; 32, 35; 33, identifier:option; 34, identifier:options; 35, block; 35, 36; 35, 44; 35, 58; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:distance; 39, call; 39, 40; 39, 41; 40, identifier:lexical_distance; 41, argument_list; 41, 42; 41, 43; 42, identifier:input_; 43, identifier:option; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:threshold; 47, call; 47, 48; 47, 49; 48, identifier:max; 49, argument_list; 49, 50; 49, 51; 49, 57; 50, identifier:input_threshold; 51, binary_operator://; 51, 52; 51, 56; 52, call; 52, 53; 52, 54; 53, identifier:len; 54, argument_list; 54, 55; 55, identifier:option; 56, integer:2; 57, integer:1; 58, if_statement; 58, 59; 58, 62; 59, comparison_operator:<=; 59, 60; 59, 61; 60, identifier:distance; 61, identifier:threshold; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:options_by_distance; 67, identifier:option; 68, identifier:distance; 69, return_statement; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:sorted; 72, argument_list; 72, 73; 72, 74; 73, identifier:options_by_distance; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:key; 76, attribute; 76, 77; 76, 78; 77, identifier:options_by_distance; 78, identifier:get | def suggestion_list(input_: str, options: Collection[str]):
"""Get list with suggestions for a given input.
Given an invalid input string and list of valid options, returns a filtered list
of valid options sorted based on their similarity with the input.
"""
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, 17; 14, 24; 14, 40; 14, 54; 14, 55; 14, 62; 14, 77; 14, 100; 14, 235; 15, expression_statement; 15, 16; 16, comment; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:==; 18, 19; 18, 20; 19, identifier:a_str; 20, identifier:b_str; 21, block; 21, 22; 22, return_statement; 22, 23; 23, integer:0; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 29; 26, pattern_list; 26, 27; 26, 28; 27, identifier:a; 28, identifier:b; 29, expression_list; 29, 30; 29, 35; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:a_str; 33, identifier:lower; 34, argument_list; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:b_str; 38, identifier:lower; 39, argument_list; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 45; 42, pattern_list; 42, 43; 42, 44; 43, identifier:a_len; 44, identifier:b_len; 45, expression_list; 45, 46; 45, 50; 46, call; 46, 47; 46, 48; 47, identifier:len; 48, argument_list; 48, 49; 49, identifier:a; 50, call; 50, 51; 50, 52; 51, identifier:len; 52, argument_list; 52, 53; 53, identifier:b; 54, comment; 55, if_statement; 55, 56; 55, 59; 56, comparison_operator:==; 56, 57; 56, 58; 57, identifier:a; 58, identifier:b; 59, block; 59, 60; 60, return_statement; 60, 61; 61, integer:1; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:d; 65, list:[[j for j in range(0, b_len + 1)]]; 65, 66; 66, list_comprehension; 66, 67; 66, 68; 67, identifier:j; 68, for_in_clause; 68, 69; 68, 70; 69, identifier:j; 70, call; 70, 71; 70, 72; 71, identifier:range; 72, argument_list; 72, 73; 72, 74; 73, integer:0; 74, binary_operator:+; 74, 75; 74, 76; 75, identifier:b_len; 76, integer:1; 77, for_statement; 77, 78; 77, 79; 77, 86; 78, identifier:i; 79, call; 79, 80; 79, 81; 80, identifier:range; 81, argument_list; 81, 82; 81, 83; 82, integer:1; 83, binary_operator:+; 83, 84; 83, 85; 84, identifier:a_len; 85, integer:1; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:d; 91, identifier:append; 92, argument_list; 92, 93; 93, binary_operator:+; 93, 94; 93, 96; 94, list:[i]; 94, 95; 95, identifier:i; 96, binary_operator:*; 96, 97; 96, 99; 97, list:[0]; 97, 98; 98, integer:0; 99, identifier:b_len; 100, for_statement; 100, 101; 100, 102; 100, 109; 101, identifier:i; 102, call; 102, 103; 102, 104; 103, identifier:range; 104, argument_list; 104, 105; 104, 106; 105, integer:1; 106, binary_operator:+; 106, 107; 106, 108; 107, identifier:a_len; 108, integer:1; 109, block; 109, 110; 110, for_statement; 110, 111; 110, 112; 110, 119; 111, identifier:j; 112, call; 112, 113; 112, 114; 113, identifier:range; 114, argument_list; 114, 115; 114, 116; 115, integer:1; 116, binary_operator:+; 116, 117; 116, 118; 117, identifier:b_len; 118, integer:1; 119, block; 119, 120; 119, 137; 119, 176; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:cost; 123, conditional_expression:if; 123, 124; 123, 125; 123, 136; 124, integer:0; 125, comparison_operator:==; 125, 126; 125, 131; 126, subscript; 126, 127; 126, 128; 127, identifier:a; 128, binary_operator:-; 128, 129; 128, 130; 129, identifier:i; 130, integer:1; 131, subscript; 131, 132; 131, 133; 132, identifier:b; 133, binary_operator:-; 133, 134; 133, 135; 134, identifier:j; 135, integer:1; 136, integer:1; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 144; 139, subscript; 139, 140; 139, 143; 140, subscript; 140, 141; 140, 142; 141, identifier:d; 142, identifier:i; 143, identifier:j; 144, call; 144, 145; 144, 146; 145, identifier:min; 146, argument_list; 146, 147; 146, 156; 146, 165; 147, binary_operator:+; 147, 148; 147, 155; 148, subscript; 148, 149; 148, 154; 149, subscript; 149, 150; 149, 151; 150, identifier:d; 151, binary_operator:-; 151, 152; 151, 153; 152, identifier:i; 153, integer:1; 154, identifier:j; 155, integer:1; 156, binary_operator:+; 156, 157; 156, 164; 157, subscript; 157, 158; 157, 161; 158, subscript; 158, 159; 158, 160; 159, identifier:d; 160, identifier:i; 161, binary_operator:-; 161, 162; 161, 163; 162, identifier:j; 163, integer:1; 164, integer:1; 165, binary_operator:+; 165, 166; 165, 175; 166, subscript; 166, 167; 166, 172; 167, subscript; 167, 168; 167, 169; 168, identifier:d; 169, binary_operator:-; 169, 170; 169, 171; 170, identifier:i; 171, integer:1; 172, binary_operator:-; 172, 173; 172, 174; 173, identifier:j; 174, integer:1; 175, identifier:cost; 176, if_statement; 176, 177; 176, 208; 177, boolean_operator:and; 177, 178; 177, 197; 178, boolean_operator:and; 178, 179; 178, 186; 179, boolean_operator:and; 179, 180; 179, 183; 180, comparison_operator:>; 180, 181; 180, 182; 181, identifier:i; 182, integer:1; 183, comparison_operator:>; 183, 184; 183, 185; 184, identifier:j; 185, integer:1; 186, comparison_operator:==; 186, 187; 186, 192; 187, subscript; 187, 188; 187, 189; 188, identifier:a; 189, binary_operator:-; 189, 190; 189, 191; 190, identifier:i; 191, integer:1; 192, subscript; 192, 193; 192, 194; 193, identifier:b; 194, binary_operator:-; 194, 195; 194, 196; 195, identifier:j; 196, integer:2; 197, comparison_operator:==; 197, 198; 197, 203; 198, subscript; 198, 199; 198, 200; 199, identifier:a; 200, binary_operator:-; 200, 201; 200, 202; 201, identifier:i; 202, integer:2; 203, subscript; 203, 204; 203, 205; 204, identifier:b; 205, binary_operator:-; 205, 206; 205, 207; 206, identifier:j; 207, integer:1; 208, block; 208, 209; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 216; 211, subscript; 211, 212; 211, 215; 212, subscript; 212, 213; 212, 214; 213, identifier:d; 214, identifier:i; 215, identifier:j; 216, call; 216, 217; 216, 218; 217, identifier:min; 218, argument_list; 218, 219; 218, 224; 219, subscript; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:d; 222, identifier:i; 223, identifier:j; 224, binary_operator:+; 224, 225; 224, 234; 225, subscript; 225, 226; 225, 231; 226, subscript; 226, 227; 226, 228; 227, identifier:d; 228, binary_operator:-; 228, 229; 228, 230; 229, identifier:i; 230, integer:2; 231, binary_operator:-; 231, 232; 231, 233; 232, identifier:j; 233, integer:2; 234, identifier:cost; 235, return_statement; 235, 236; 236, subscript; 236, 237; 236, 240; 237, subscript; 237, 238; 237, 239; 238, identifier:d; 239, identifier:a_len; 240, identifier:b_len | def lexical_distance(a_str: str, b_str: str) -> int:
"""Computes the lexical distance between strings A and B.
The "distance" between two strings is given by counting the minimum number of edits
needed to transform string A into string B. An edit can be an insertion, deletion,
or substitution of a single character, or a swap of two adjacent characters.
This distance can be useful for detecting typos in input or sorting.
"""
if a_str == b_str:
return 0
a, b = a_str.lower(), b_str.lower()
a_len, b_len = len(a), len(b)
# Any case change counts as a single edit
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, 25; 22, 130; 22, 131; 23, expression_statement; 23, 24; 24, comment; 25, if_statement; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:is_abstract_type; 28, argument_list; 28, 29; 29, identifier:type_; 30, block; 30, 31; 30, 39; 30, 43; 30, 58; 30, 108; 30, 109; 30, 125; 30, 126; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:type_; 34, call; 34, 35; 34, 36; 35, identifier:cast; 36, argument_list; 36, 37; 36, 38; 37, identifier:GraphQLAbstractType; 38, identifier:type_; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:suggested_object_types; 42, list:[]; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 44, 54; 45, identifier:interface_usage_count; 46, type; 46, 47; 47, generic_type; 47, 48; 47, 49; 48, identifier:Dict; 49, type_parameter; 49, 50; 49, 52; 50, type; 50, 51; 51, identifier:str; 52, type; 52, 53; 53, identifier:int; 54, call; 54, 55; 54, 56; 55, identifier:defaultdict; 56, argument_list; 56, 57; 57, identifier:int; 58, for_statement; 58, 59; 58, 60; 58, 66; 59, identifier:possible_type; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:schema; 63, identifier:get_possible_types; 64, argument_list; 64, 65; 65, identifier:type_; 66, block; 66, 67; 66, 75; 66, 76; 66, 85; 67, if_statement; 67, 68; 67, 73; 68, comparison_operator:not; 68, 69; 68, 70; 69, identifier:field_name; 70, attribute; 70, 71; 70, 72; 71, identifier:possible_type; 72, identifier:fields; 73, block; 73, 74; 74, continue_statement; 75, comment; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:suggested_object_types; 80, identifier:append; 81, argument_list; 81, 82; 82, attribute; 82, 83; 82, 84; 83, identifier:possible_type; 84, identifier:name; 85, for_statement; 85, 86; 85, 87; 85, 90; 86, identifier:possible_interface; 87, attribute; 87, 88; 87, 89; 88, identifier:possible_type; 89, identifier:interfaces; 90, block; 90, 91; 90, 99; 90, 100; 91, if_statement; 91, 92; 91, 97; 92, comparison_operator:not; 92, 93; 92, 94; 93, identifier:field_name; 94, attribute; 94, 95; 94, 96; 95, identifier:possible_interface; 96, identifier:fields; 97, block; 97, 98; 98, continue_statement; 99, comment; 100, expression_statement; 100, 101; 101, augmented_assignment:+=; 101, 102; 101, 107; 102, subscript; 102, 103; 102, 104; 103, identifier:interface_usage_count; 104, attribute; 104, 105; 104, 106; 105, identifier:possible_interface; 106, identifier:name; 107, integer:1; 108, comment; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:suggested_interface_types; 112, call; 112, 113; 112, 114; 113, identifier:sorted; 114, argument_list; 114, 115; 114, 116; 115, identifier:interface_usage_count; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:key; 118, lambda; 118, 119; 118, 121; 119, lambda_parameters; 119, 120; 120, identifier:k; 121, unary_operator:-; 121, 122; 122, subscript; 122, 123; 122, 124; 123, identifier:interface_usage_count; 124, identifier:k; 125, comment; 126, return_statement; 126, 127; 127, binary_operator:+; 127, 128; 127, 129; 128, identifier:suggested_interface_types; 129, identifier:suggested_object_types; 130, comment; 131, return_statement; 131, 132; 132, list:[] | def get_suggested_type_names(
schema: GraphQLSchema, type_: GraphQLOutputType, field_name: str
) -> List[str]:
"""
Get a list of suggested type names.
Go through all of the implementations of type, as well as the interfaces
that they implement. If any of those types include the provided field,
suggest them, sorted by how often the type is referenced, starting with
Interfaces.
"""
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
# This object type defines this field.
suggested_object_types.append(possible_type.name)
for possible_interface in possible_type.interfaces:
if field_name not in possible_interface.fields:
continue
# This interface type defines this field.
interface_usage_count[possible_interface.name] += 1
# Suggest interface types based on how common they are.
suggested_interface_types = sorted(
interface_usage_count, key=lambda k: -interface_usage_count[k]
)
# Suggest both interface and object types.
return suggested_interface_types + suggested_object_types
# Otherwise, must be an Object type, which does not have possible fields.
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, 11; 8, 17; 8, 24; 8, 59; 8, 90; 9, expression_statement; 9, 10; 10, comment; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:instances; 14, call; 14, 15; 14, 16; 15, identifier:OrderedDict; 16, argument_list; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:preferred_order; 20, list:['wordpress', 'joomla', 'drupal']; 20, 21; 20, 22; 20, 23; 21, string:'wordpress'; 22, string:'joomla'; 23, string:'drupal'; 24, for_statement; 24, 25; 24, 26; 24, 27; 25, identifier:cms_name; 26, identifier:preferred_order; 27, block; 27, 28; 28, for_statement; 28, 29; 28, 30; 28, 31; 29, identifier:plugin; 30, identifier:plugins; 31, block; 31, 32; 31, 42; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:plugin_name; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:plugin; 39, identifier:__name__; 40, identifier:lower; 41, argument_list; 42, if_statement; 42, 43; 42, 46; 43, comparison_operator:==; 43, 44; 43, 45; 44, identifier:cms_name; 45, identifier:plugin_name; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 52; 49, subscript; 49, 50; 49, 51; 50, identifier:instances; 51, identifier:plugin_name; 52, call; 52, 53; 52, 54; 53, identifier:instance_get; 54, argument_list; 54, 55; 54, 56; 54, 57; 54, 58; 55, identifier:plugin; 56, identifier:opts; 57, identifier:url_file_input; 58, identifier:out; 59, for_statement; 59, 60; 59, 61; 59, 62; 60, identifier:plugin; 61, identifier:plugins; 62, block; 62, 63; 62, 73; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:plugin_name; 66, call; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:plugin; 70, identifier:__name__; 71, identifier:lower; 72, argument_list; 73, if_statement; 73, 74; 73, 77; 74, comparison_operator:not; 74, 75; 74, 76; 75, identifier:plugin_name; 76, identifier:preferred_order; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, subscript; 80, 81; 80, 82; 81, identifier:instances; 82, identifier:plugin_name; 83, call; 83, 84; 83, 85; 84, identifier:instance_get; 85, argument_list; 85, 86; 85, 87; 85, 88; 85, 89; 86, identifier:plugin; 87, identifier:opts; 88, identifier:url_file_input; 89, identifier:out; 90, return_statement; 90, 91; 91, identifier:instances | def instances_get(opts, plugins, url_file_input, out):
"""
Creates and returns an ordered dictionary containing instances for all available
scanning plugins, sort of ordered by popularity.
@param opts: options as returned by self._options.
@param plugins: plugins as returned by plugins_util.plugins_base_get.
@param url_file_input: boolean value which indicates whether we are
scanning an individual URL or a file. This is used to determine
kwargs required.
@param out: self.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, 8; 5, 12; 5, 31; 6, expression_statement; 6, 7; 7, comment; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:signed_headers; 11, list:[]; 12, for_statement; 12, 13; 12, 14; 12, 15; 13, identifier:header; 14, identifier:headers; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:signed_headers; 20, identifier:append; 21, argument_list; 21, 22; 22, call; 22, 23; 22, 30; 23, attribute; 23, 24; 23, 29; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:header; 27, identifier:lower; 28, argument_list; 29, identifier:strip; 30, argument_list; 31, return_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:sorted; 34, argument_list; 34, 35; 35, identifier:signed_headers | def get_signed_headers(headers):
"""
Get signed headers.
:param headers: input dictionary to be sorted.
"""
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, 9; 6, 18; 6, 32; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:_key_func; 12, lambda; 12, 13; 12, 15; 13, lambda_parameters; 13, 14; 14, identifier:node; 15, attribute; 15, 16; 15, 17; 16, identifier:node; 17, identifier:fromlineno; 18, function_definition; 18, 19; 18, 20; 18, 22; 19, function_name:sort_locals; 20, parameters; 20, 21; 21, identifier:my_list; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:my_list; 27, identifier:sort; 28, argument_list; 28, 29; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:key; 31, identifier:_key_func; 32, for_statement; 32, 33; 32, 36; 32, 39; 33, tuple_pattern; 33, 34; 33, 35; 34, identifier:name; 35, identifier:asname; 36, attribute; 36, 37; 36, 38; 37, identifier:node; 38, identifier:names; 39, block; 39, 40; 40, if_statement; 40, 41; 40, 44; 40, 94; 41, comparison_operator:==; 41, 42; 41, 43; 42, identifier:name; 43, string:"*"; 44, block; 44, 45; 44, 61; 45, try_statement; 45, 46; 45, 55; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:imported; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:node; 53, identifier:do_import_module; 54, argument_list; 55, except_clause; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:exceptions; 58, identifier:AstroidBuildingError; 59, block; 59, 60; 60, continue_statement; 61, for_statement; 61, 62; 61, 63; 61, 68; 62, identifier:name; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:imported; 66, identifier:public_names; 67, argument_list; 68, block; 68, 69; 68, 79; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:node; 74, identifier:parent; 75, identifier:set_local; 76, argument_list; 76, 77; 76, 78; 77, identifier:name; 78, identifier:node; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:sort_locals; 82, argument_list; 82, 83; 83, subscript; 83, 84; 83, 93; 84, attribute; 84, 85; 84, 92; 85, call; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:node; 89, identifier:parent; 90, identifier:scope; 91, argument_list; 92, identifier:locals; 93, identifier:name; 94, else_clause; 94, 95; 95, block; 95, 96; 95, 108; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 103; 98, attribute; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:node; 101, identifier:parent; 102, identifier:set_local; 103, argument_list; 103, 104; 103, 107; 104, boolean_operator:or; 104, 105; 104, 106; 105, identifier:asname; 106, identifier:name; 107, identifier:node; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:sort_locals; 111, argument_list; 111, 112; 112, subscript; 112, 113; 112, 122; 113, attribute; 113, 114; 113, 121; 114, call; 114, 115; 114, 120; 115, attribute; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:node; 118, identifier:parent; 119, identifier:scope; 120, argument_list; 121, identifier:locals; 122, boolean_operator:or; 122, 123; 122, 124; 123, identifier:asname; 124, identifier:name | def add_from_names_to_locals(self, node):
"""Store imported names to the locals
Resort the locals if coming from a delayed 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, 9; 6, 17; 6, 23; 6, 29; 6, 74; 6, 75; 7, expression_statement; 7, 8; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:myroot; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:root; 16, argument_list; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:mylineno; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:fromlineno; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:nearest; 26, expression_list; 26, 27; 26, 28; 27, None; 28, integer:0; 29, for_statement; 29, 30; 29, 31; 29, 32; 30, identifier:node; 31, identifier:nodes; 32, block; 32, 33; 32, 47; 32, 53; 32, 61; 33, assert_statement; 33, 34; 33, 41; 34, comparison_operator:is; 34, 35; 34, 40; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:node; 38, identifier:root; 39, argument_list; 40, identifier:myroot; 41, parenthesized_expression; 41, 42; 42, binary_operator:%; 42, 43; 42, 44; 43, string:"nodes %s and %s are not from the same module"; 44, tuple; 44, 45; 44, 46; 45, identifier:self; 46, identifier:node; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:lineno; 50, attribute; 50, 51; 50, 52; 51, identifier:node; 52, identifier:fromlineno; 53, if_statement; 53, 54; 53, 59; 54, comparison_operator:>; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:node; 57, identifier:fromlineno; 58, identifier:mylineno; 59, block; 59, 60; 60, break_statement; 61, if_statement; 61, 62; 61, 67; 62, comparison_operator:>; 62, 63; 62, 64; 63, identifier:lineno; 64, subscript; 64, 65; 64, 66; 65, identifier:nearest; 66, integer:1; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:nearest; 71, expression_list; 71, 72; 71, 73; 72, identifier:node; 73, identifier:lineno; 74, comment; 75, return_statement; 75, 76; 76, subscript; 76, 77; 76, 78; 77, identifier:nearest; 78, integer:0 | def nearest(self, nodes):
"""Get the node closest to this one from the given list of nodes.
:param nodes: The list of nodes to search. All of these nodes must
belong to the same module as this one. The list should be
sorted by the line number of the nodes, smallest first.
:type nodes: iterable(NodeNG)
:returns: The node closest to this one in the source code,
or None if one could not be found.
:rtype: NodeNG or None
"""
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
# FIXME: raise an exception if nearest is None ?
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, 11; 8, 33; 8, 48; 9, expression_statement; 9, 10; 10, comment; 11, try_statement; 11, 12; 11, 24; 12, block; 12, 13; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:types; 16, call; 16, 17; 16, 18; 17, identifier:set; 18, argument_list; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:_object_type; 21, argument_list; 21, 22; 21, 23; 22, identifier:node; 23, identifier:context; 24, except_clause; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:exceptions; 27, identifier:InferenceError; 28, block; 28, 29; 29, return_statement; 29, 30; 30, attribute; 30, 31; 30, 32; 31, identifier:util; 32, identifier:Uninferable; 33, if_statement; 33, 34; 33, 43; 34, boolean_operator:or; 34, 35; 34, 41; 35, comparison_operator:>; 35, 36; 35, 40; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, identifier:types; 40, integer:1; 41, not_operator; 41, 42; 42, identifier:types; 43, block; 43, 44; 44, return_statement; 44, 45; 45, attribute; 45, 46; 45, 47; 46, identifier:util; 47, identifier:Uninferable; 48, return_statement; 48, 49; 49, subscript; 49, 50; 49, 54; 50, call; 50, 51; 50, 52; 51, identifier:list; 52, argument_list; 52, 53; 53, identifier:types; 54, integer:0 | def object_type(node, context=None):
"""Obtain the type of the given node
This is used to implement the ``type`` builtin, which means that it's
used for inferring type calls, as well as used in a couple of other places
in the inference.
The node will be inferred first, so this function can support all
sorts of objects, as long as they support inference.
"""
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; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, return_statement; 8, 9; 9, call; 9, 10; 9, 11; 10, identifier:sorted; 11, argument_list; 11, 12; 11, 18; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:_get_by_type; 16, argument_list; 16, 17; 17, identifier:DefFacts; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:key; 20, lambda; 20, 21; 20, 23; 21, lambda_parameters; 21, 22; 22, identifier:d; 23, attribute; 23, 24; 23, 25; 24, identifier:d; 25, identifier:order | def get_deffacts(self):
"""Return the existing deffacts sorted by the internal order"""
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; 6, 9; 7, expression_statement; 7, 8; 8, comment; 9, return_statement; 9, 10; 10, call; 10, 11; 10, 35; 11, attribute; 11, 12; 11, 34; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:json; 15, identifier:dumps; 16, argument_list; 16, 17; 16, 18; 16, 23; 16, 26; 16, 31; 17, identifier:data; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:separators; 20, tuple; 20, 21; 20, 22; 21, string:','; 22, string:':'; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:sort_keys; 25, True; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:cls; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:json_encoder; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:ensure_ascii; 33, False; 34, identifier:encode; 35, argument_list; 35, 36; 36, string:'utf8' | def json_dumps(self, data):
"""
Standardized json.dumps function with separators and sorted keys set
Args:
data (dict or list): data to be dumped
Returns:
string: json
"""
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, 17; 14, 18; 14, 34; 14, 43; 14, 44; 14, 45; 14, 49; 14, 111; 14, 150; 15, expression_statement; 15, 16; 16, comment; 17, comment; 18, try_statement; 18, 19; 18, 26; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:approximant; 23, subscript; 23, 24; 23, 25; 24, identifier:static_params; 25, string:'approximant'; 26, except_clause; 26, 27; 26, 28; 27, identifier:KeyError; 28, block; 28, 29; 29, raise_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:ValueError; 32, argument_list; 32, 33; 33, string:"no approximant provided in the static args"; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:generator_function; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:generator; 40, identifier:select_waveform_generator; 41, argument_list; 41, 42; 42, identifier:approximant; 43, comment; 44, comment; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:delta_f; 48, None; 49, for_statement; 49, 50; 49, 51; 49, 56; 50, identifier:d; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:data; 54, identifier:values; 55, argument_list; 56, block; 56, 57; 57, if_statement; 57, 58; 57, 61; 57, 80; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:delta_f; 60, None; 61, block; 61, 62; 61, 68; 61, 74; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:delta_f; 65, attribute; 65, 66; 65, 67; 66, identifier:d; 67, identifier:delta_f; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:delta_t; 71, attribute; 71, 72; 71, 73; 72, identifier:d; 73, identifier:delta_t; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:start_time; 77, attribute; 77, 78; 77, 79; 78, identifier:d; 79, identifier:start_time; 80, else_clause; 80, 81; 81, block; 81, 82; 82, if_statement; 82, 83; 82, 103; 83, not_operator; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:all; 86, argument_list; 86, 87; 87, list:[d.delta_f == delta_f, d.delta_t == delta_t,
d.start_time == start_time]; 87, 88; 87, 93; 87, 98; 88, comparison_operator:==; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:d; 91, identifier:delta_f; 92, identifier:delta_f; 93, comparison_operator:==; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:d; 96, identifier:delta_t; 97, identifier:delta_t; 98, comparison_operator:==; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:d; 101, identifier:start_time; 102, identifier:start_time; 103, block; 103, 104; 104, raise_statement; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:ValueError; 107, argument_list; 107, 108; 108, concatenated_string; 108, 109; 108, 110; 109, string:"data must all have the same delta_t, "; 110, string:"delta_f, and start_time"; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:waveform_generator; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:generator; 117, identifier:FDomainDetFrameGenerator; 118, argument_list; 118, 119; 118, 120; 118, 123; 118, 126; 118, 136; 118, 139; 118, 142; 118, 145; 118, 148; 119, identifier:generator_function; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:epoch; 122, identifier:start_time; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:variable_args; 125, identifier:variable_params; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:detectors; 128, call; 128, 129; 128, 130; 129, identifier:list; 130, argument_list; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:data; 134, identifier:keys; 135, argument_list; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:delta_f; 138, identifier:delta_f; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:delta_t; 141, identifier:delta_t; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:recalib; 144, identifier:recalibration; 145, keyword_argument; 145, 146; 145, 147; 146, identifier:gates; 147, identifier:gates; 148, dictionary_splat; 148, 149; 149, identifier:static_params; 150, return_statement; 150, 151; 151, identifier:waveform_generator | def create_waveform_generator(variable_params, data,
recalibration=None, gates=None,
**static_params):
"""Creates a waveform generator for use with a model.
Parameters
----------
variable_params : list of str
The names of the parameters varied.
data : dict
Dictionary mapping detector names to either a
:py:class:`<pycbc.types.TimeSeries TimeSeries>` or
:py:class:`<pycbc.types.FrequencySeries FrequencySeries>`.
recalibration : dict, optional
Dictionary mapping detector names to
:py:class:`<pycbc.calibration.Recalibrate>` instances for
recalibrating data.
gates : dict of tuples, optional
Dictionary of detectors -> tuples of specifying gate times. The
sort of thing returned by :py:func:`pycbc.gate.gates_from_cli`.
Returns
-------
pycbc.waveform.FDomainDetFrameGenerator
A waveform generator for frequency domain generation.
"""
# figure out what generator to use based on the approximant
try:
approximant = static_params['approximant']
except KeyError:
raise ValueError("no approximant provided in the static args")
generator_function = generator.select_waveform_generator(approximant)
# get data parameters; we'll just use one of the data to get the
# values, then check that all the others are the same
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, 20; 17, 34; 17, 35; 17, 43; 17, 51; 17, 52; 17, 63; 17, 74; 17, 105; 17, 106; 17, 120; 17, 144; 17, 145; 17, 150; 17, 166; 17, 174; 17, 184; 17, 213; 17, 220; 18, expression_statement; 18, 19; 19, comment; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 25; 22, pattern_list; 22, 23; 22, 24; 23, identifier:keys; 24, identifier:values; 25, call; 25, 26; 25, 27; 26, identifier:zip; 27, argument_list; 27, 28; 28, list_splat; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:dict_; 32, identifier:items; 33, argument_list; 34, comment; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:keys; 38, call; 38, 39; 38, 40; 39, identifier:map; 40, argument_list; 40, 41; 40, 42; 41, identifier:key_format; 42, identifier:keys; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:values; 46, call; 46, 47; 46, 48; 47, identifier:map; 48, argument_list; 48, 49; 48, 50; 49, identifier:val_format; 50, identifier:values; 51, comment; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:nckey; 55, call; 55, 56; 55, 57; 56, identifier:max; 57, argument_list; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:map; 60, argument_list; 60, 61; 60, 62; 61, identifier:len; 62, identifier:keys; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:ncval; 66, call; 66, 67; 66, 68; 67, identifier:max; 68, argument_list; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:map; 71, argument_list; 71, 72; 71, 73; 72, identifier:len; 73, identifier:values; 74, if_statement; 74, 75; 74, 76; 75, identifier:header; 76, block; 76, 77; 76, 83; 76, 94; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 82; 79, pattern_list; 79, 80; 79, 81; 80, identifier:khead; 81, identifier:vhead; 82, identifier:header; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:nckey; 86, call; 86, 87; 86, 88; 87, identifier:max; 88, argument_list; 88, 89; 88, 90; 89, identifier:nckey; 90, call; 90, 91; 90, 92; 91, identifier:len; 92, argument_list; 92, 93; 93, identifier:khead; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:ncval; 97, call; 97, 98; 97, 99; 98, identifier:max; 99, argument_list; 99, 100; 99, 101; 100, identifier:ncval; 101, call; 101, 102; 101, 103; 102, identifier:len; 103, argument_list; 103, 104; 104, identifier:vhead; 105, comment; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:divider; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, string:"{} {}"; 112, identifier:format; 113, argument_list; 113, 114; 113, 117; 114, binary_operator:*; 114, 115; 114, 116; 115, string:'='; 116, identifier:nckey; 117, binary_operator:*; 117, 118; 117, 119; 118, string:'='; 119, identifier:ncval; 120, function_definition; 120, 121; 120, 122; 120, 125; 121, function_name:row; 122, parameters; 122, 123; 122, 124; 123, identifier:key; 124, identifier:val; 125, block; 125, 126; 125, 136; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:fmt; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, string:'{{0:{0}s}} {{1}}'; 132, identifier:format; 133, argument_list; 133, 134; 133, 135; 134, identifier:nckey; 135, identifier:ncval; 136, return_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:fmt; 140, identifier:format; 141, argument_list; 141, 142; 141, 143; 142, identifier:key; 143, identifier:val; 144, comment; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:lines; 148, list:[divider]; 148, 149; 149, identifier:divider; 150, if_statement; 150, 151; 150, 152; 151, identifier:header; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:lines; 157, identifier:extend; 158, argument_list; 158, 159; 159, tuple; 159, 160; 159, 165; 160, call; 160, 161; 160, 162; 161, identifier:row; 162, argument_list; 162, 163; 163, list_splat; 163, 164; 164, identifier:header; 165, identifier:divider; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:params; 169, call; 169, 170; 169, 171; 170, identifier:zip; 171, argument_list; 171, 172; 171, 173; 172, identifier:keys; 173, identifier:values; 174, if_statement; 174, 175; 174, 176; 175, identifier:sort; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:params; 180, call; 180, 181; 180, 182; 181, identifier:sorted; 182, argument_list; 182, 183; 183, identifier:params; 184, for_statement; 184, 185; 184, 188; 184, 189; 185, pattern_list; 185, 186; 185, 187; 186, identifier:key; 187, identifier:val; 188, identifier:params; 189, block; 189, 190; 189, 200; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:fmt; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, string:'{{0:{0}s}} {{1}}'; 196, identifier:format; 197, argument_list; 197, 198; 197, 199; 198, identifier:nckey; 199, identifier:ncval; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:lines; 204, identifier:append; 205, argument_list; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:fmt; 209, identifier:format; 210, argument_list; 210, 211; 210, 212; 211, identifier:key; 212, identifier:val; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:lines; 217, identifier:append; 218, argument_list; 218, 219; 219, identifier:divider; 220, return_statement; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, string:'\n'; 224, identifier:join; 225, argument_list; 225, 226; 226, identifier:lines | def rst_dict_table(dict_, key_format=str, val_format=str, header=None,
sort=True):
"""Returns an RST-formatted table of keys and values from a `dict`
Parameters
----------
dict_ : dict
data to display in table
key_format : callable
callable function with which to format keys
val_format : callable
callable function with which to format values
header : None, tuple of str
a 2-tuple of header for the two columns, or `None` to exclude
a header line (default)
sort : bool, optional
Sort the dictionary keys alphabetically when writing the table.
Examples
--------
>>> a = {'key1': 'value1', 'key2': 'value2'}
>>> print(rst_dict_table(a))
==== ======
key1 value1
key2 value2
==== ======
>>> print(rst_dict_table(a, key_format='``{}``'.format,
... val_format=':class:`{}`'.format,
... header=('Key', 'Value'))
======== ===============
Key Value
======== ===============
``key1`` :class:`value1`
``key2`` :class:`value2`
======== ===============
"""
keys, values = zip(*dict_.items())
# apply formatting
keys = map(key_format, keys)
values = map(val_format, values)
# work out longest elements in each column
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))
# build table header line
divider = "{} {}".format('='*nckey, '='*ncval)
def row(key, val):
fmt = '{{0:{0}s}} {{1}}'.format(nckey, ncval)
return fmt.format(key, val)
# build table of lines
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, 11; 8, 15; 8, 55; 9, expression_statement; 9, 10; 10, comment; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:trans; 14, list:[]; 15, for_statement; 15, 16; 15, 17; 15, 23; 16, identifier:subsection; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:cp; 20, identifier:get_subsections; 21, argument_list; 21, 22; 22, identifier:section; 23, block; 23, 24; 23, 35; 23, 48; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:name; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:cp; 30, identifier:get_opt_tag; 31, argument_list; 31, 32; 31, 33; 31, 34; 32, identifier:section; 33, string:"name"; 34, identifier:subsection; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:t; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:transforms; 42, identifier:name; 43, identifier:from_config; 44, argument_list; 44, 45; 44, 46; 44, 47; 45, identifier:cp; 46, identifier:section; 47, identifier:subsection; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:trans; 52, identifier:append; 53, argument_list; 53, 54; 54, identifier:t; 55, return_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:order_transforms; 58, argument_list; 58, 59; 59, identifier:trans | def read_transforms_from_config(cp, section="transforms"):
"""Returns a list of PyCBC transform instances for a section in the
given configuration file.
If the transforms are nested (i.e., the output of one transform is the
input of another), the returned list will be sorted by the order of the
nests.
Parameters
----------
cp : WorflowConfigParser
An open config file to read.
section : {"transforms", string}
Prefix on section names from which to retrieve the transforms.
Returns
-------
list
A list of the parsed 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, 14; 11, 42; 11, 43; 11, 53; 11, 63; 11, 75; 12, expression_statement; 12, 13; 13, comment; 14, if_statement; 14, 15; 14, 24; 14, 31; 15, boolean_operator:and; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:parameters; 18, None; 19, comparison_operator:is; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:opts; 22, identifier:parameters; 23, None; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:parameters; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:variable_args; 31, elif_clause; 31, 32; 31, 35; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:parameters; 34, None; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:parameters; 39, attribute; 39, 40; 39, 41; 40, identifier:opts; 41, identifier:parameters; 42, comment; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 48; 45, pattern_list; 45, 46; 45, 47; 46, identifier:_; 47, identifier:extra_actions; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:extra_args_parser; 52, argument_list; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:extra_args; 56, list_comprehension; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:act; 59, identifier:dest; 60, for_in_clause; 60, 61; 60, 62; 61, identifier:act; 62, identifier:extra_actions; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:kwargs; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:_get_optional_args; 70, argument_list; 70, 71; 70, 72; 70, 73; 71, identifier:extra_args; 72, identifier:opts; 73, dictionary_splat; 73, 74; 74, identifier:kwargs; 75, return_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:read_samples; 80, argument_list; 80, 81; 80, 82; 81, identifier:parameters; 82, dictionary_splat; 82, 83; 83, identifier:kwargs | def samples_from_cli(self, opts, parameters=None, **kwargs):
"""Reads samples from the given command-line options.
Parameters
----------
opts : argparse Namespace
The options with the settings to use for loading samples (the sort
of thing returned by ``ArgumentParser().parse_args``).
parameters : (list of) str, optional
A list of the parameters to load. If none provided, will try to
get the parameters to load from ``opts.parameters``.
\**kwargs :
All other keyword arguments are passed to ``read_samples``. These
will override any options with the same name.
Returns
-------
FieldArray :
Array of the loaded samples.
"""
if parameters is None and opts.parameters is None:
parameters = self.variable_args
elif parameters is None:
parameters = opts.parameters
# parse optional arguments
_, 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, 8; 5, 9; 5, 16; 5, 23; 5, 24; 5, 37; 5, 48; 5, 49; 5, 63; 5, 64; 5, 65; 5, 150; 5, 151; 5, 152; 5, 156; 5, 160; 5, 164; 5, 171; 5, 208; 5, 209; 5, 226; 5, 227; 5, 279; 6, expression_statement; 6, 7; 7, comment; 8, comment; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:gates; 12, call; 12, 13; 12, 14; 13, identifier:gates_from_cli; 14, argument_list; 14, 15; 15, identifier:opts; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:psd_gates; 19, call; 19, 20; 19, 21; 20, identifier:psd_gates_from_cli; 21, argument_list; 21, 22; 22, identifier:opts; 23, comment; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:instruments; 27, conditional_expression:if; 27, 28; 27, 31; 27, 36; 28, attribute; 28, 29; 28, 30; 29, identifier:opts; 30, identifier:instruments; 31, comparison_operator:is; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:opts; 34, identifier:instruments; 35, None; 36, list:[]; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:strain_dict; 40, call; 40, 41; 40, 42; 41, identifier:strain_from_cli_multi_ifos; 42, argument_list; 42, 43; 42, 44; 42, 45; 43, identifier:opts; 44, identifier:instruments; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:precision; 47, string:"double"; 48, comment; 49, if_statement; 49, 50; 49, 54; 50, not_operator; 50, 51; 51, attribute; 51, 52; 51, 53; 52, identifier:opts; 53, identifier:gate_overwhitened; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:strain_dict; 58, call; 58, 59; 58, 60; 59, identifier:apply_gates_to_td; 60, argument_list; 60, 61; 60, 62; 61, identifier:strain_dict; 62, identifier:gates; 63, comment; 64, comment; 65, if_statement; 65, 66; 65, 73; 65, 130; 65, 144; 66, boolean_operator:and; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:opts; 69, identifier:psd_start_time; 70, attribute; 70, 71; 70, 72; 71, identifier:opts; 72, identifier:psd_end_time; 73, block; 73, 74; 73, 83; 73, 87; 73, 95; 73, 103; 73, 114; 73, 115; 73, 122; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:logging; 78, identifier:info; 79, argument_list; 79, 80; 80, concatenated_string; 80, 81; 80, 82; 81, string:"Will generate a different time series for PSD "; 82, string:"estimation"; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:psd_opts; 86, identifier:opts; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:psd_opts; 91, identifier:gps_start_time; 92, attribute; 92, 93; 92, 94; 93, identifier:psd_opts; 94, identifier:psd_start_time; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:psd_opts; 99, identifier:gps_end_time; 100, attribute; 100, 101; 100, 102; 101, identifier:psd_opts; 102, identifier:psd_end_time; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:psd_strain_dict; 106, call; 106, 107; 106, 108; 107, identifier:strain_from_cli_multi_ifos; 108, argument_list; 108, 109; 108, 110; 108, 111; 109, identifier:psd_opts; 110, identifier:instruments; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:precision; 113, string:"double"; 114, comment; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:logging; 119, identifier:info; 120, argument_list; 120, 121; 121, string:"Applying gates to PSD data"; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:psd_strain_dict; 125, call; 125, 126; 125, 127; 126, identifier:apply_gates_to_td; 127, argument_list; 127, 128; 127, 129; 128, identifier:psd_strain_dict; 129, identifier:psd_gates; 130, elif_clause; 130, 131; 130, 138; 131, boolean_operator:or; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:opts; 134, identifier:psd_start_time; 135, attribute; 135, 136; 135, 137; 136, identifier:opts; 137, identifier:psd_end_time; 138, block; 138, 139; 139, raise_statement; 139, 140; 140, call; 140, 141; 140, 142; 141, identifier:ValueError; 142, argument_list; 142, 143; 143, string:"Must give --psd-start-time and --psd-end-time"; 144, else_clause; 144, 145; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:psd_strain_dict; 149, identifier:strain_dict; 150, comment; 151, comment; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:stilde_dict; 155, dictionary; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:length_dict; 159, dictionary; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:delta_f_dict; 163, dictionary; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:low_frequency_cutoff_dict; 167, call; 167, 168; 167, 169; 168, identifier:low_frequency_cutoff_from_cli; 169, argument_list; 169, 170; 170, identifier:opts; 171, for_statement; 171, 172; 171, 173; 171, 174; 172, identifier:ifo; 173, identifier:instruments; 174, block; 174, 175; 174, 187; 174, 198; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 180; 177, subscript; 177, 178; 177, 179; 178, identifier:stilde_dict; 179, identifier:ifo; 180, call; 180, 181; 180, 186; 181, attribute; 181, 182; 181, 185; 182, subscript; 182, 183; 182, 184; 183, identifier:strain_dict; 184, identifier:ifo; 185, identifier:to_frequencyseries; 186, argument_list; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 192; 189, subscript; 189, 190; 189, 191; 190, identifier:length_dict; 191, identifier:ifo; 192, call; 192, 193; 192, 194; 193, identifier:len; 194, argument_list; 194, 195; 195, subscript; 195, 196; 195, 197; 196, identifier:stilde_dict; 197, identifier:ifo; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 200, subscript; 200, 201; 200, 202; 201, identifier:delta_f_dict; 202, identifier:ifo; 203, attribute; 203, 204; 203, 207; 204, subscript; 204, 205; 204, 206; 205, identifier:stilde_dict; 206, identifier:ifo; 207, identifier:delta_f; 208, comment; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:psd_dict; 212, call; 212, 213; 212, 214; 213, identifier:psd_from_cli_multi_ifos; 214, argument_list; 214, 215; 214, 216; 214, 217; 214, 218; 214, 219; 214, 220; 214, 223; 215, identifier:opts; 216, identifier:length_dict; 217, identifier:delta_f_dict; 218, identifier:low_frequency_cutoff_dict; 219, identifier:instruments; 220, keyword_argument; 220, 221; 220, 222; 221, identifier:strain_dict; 222, identifier:psd_strain_dict; 223, keyword_argument; 223, 224; 223, 225; 224, identifier:precision; 225, string:"double"; 226, comment; 227, if_statement; 227, 228; 227, 237; 228, boolean_operator:and; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:opts; 231, identifier:gate_overwhitened; 232, comparison_operator:is; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:opts; 235, identifier:gate; 236, None; 237, block; 237, 238; 237, 245; 237, 246; 237, 258; 237, 266; 237, 267; 238, expression_statement; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:logging; 242, identifier:info; 243, argument_list; 243, 244; 244, string:"Applying gates to overwhitened data"; 245, comment; 246, for_statement; 246, 247; 246, 248; 246, 249; 247, identifier:ifo; 248, identifier:gates; 249, block; 249, 250; 250, expression_statement; 250, 251; 251, augmented_assignment:/=; 251, 252; 251, 255; 252, subscript; 252, 253; 252, 254; 253, identifier:stilde_dict; 254, identifier:ifo; 255, subscript; 255, 256; 255, 257; 256, identifier:psd_dict; 257, identifier:ifo; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:stilde_dict; 261, call; 261, 262; 261, 263; 262, identifier:apply_gates_to_fd; 263, argument_list; 263, 264; 263, 265; 264, identifier:stilde_dict; 265, identifier:gates; 266, comment; 267, for_statement; 267, 268; 267, 269; 267, 270; 268, identifier:ifo; 269, identifier:gates; 270, block; 270, 271; 271, expression_statement; 271, 272; 272, augmented_assignment:*=; 272, 273; 272, 276; 273, subscript; 273, 274; 273, 275; 274, identifier:stilde_dict; 275, identifier:ifo; 276, subscript; 276, 277; 276, 278; 277, identifier:psd_dict; 278, identifier:ifo; 279, return_statement; 279, 280; 280, expression_list; 280, 281; 280, 282; 280, 283; 281, identifier:strain_dict; 282, identifier:stilde_dict; 283, identifier:psd_dict | def data_from_cli(opts):
"""Loads the data needed for a model from the given
command-line options. Gates specifed on the command line are also applied.
Parameters
----------
opts : ArgumentParser parsed args
Argument options parsed from a command line string (the sort of thing
returned by `parser.parse_args`).
Returns
-------
strain_dict : dict
Dictionary of instruments -> `TimeSeries` strain.
stilde_dict : dict
Dictionary of instruments -> `FrequencySeries` strain.
psd_dict : dict
Dictionary of instruments -> `FrequencySeries` psds.
"""
# get gates to apply
gates = gates_from_cli(opts)
psd_gates = psd_gates_from_cli(opts)
# get strain time series
instruments = opts.instruments if opts.instruments is not None else []
strain_dict = strain_from_cli_multi_ifos(opts, instruments,
precision="double")
# apply gates if not waiting to overwhiten
if not opts.gate_overwhitened:
strain_dict = apply_gates_to_td(strain_dict, gates)
# get strain time series to use for PSD estimation
# if user has not given the PSD time options then use same data as analysis
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")
# apply any gates
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
# FFT strain and save each of the length of the FFT, delta_f, and
# low frequency cutoff to a 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
# get PSD as frequency series
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")
# apply any gates to overwhitened data, if desired
if opts.gate_overwhitened and opts.gate is not None:
logging.info("Applying gates to overwhitened data")
# overwhiten the data
for ifo in gates:
stilde_dict[ifo] /= psd_dict[ifo]
stilde_dict = apply_gates_to_fd(stilde_dict, gates)
# unwhiten the data for the model
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; 15, 18; 16, expression_statement; 16, 17; 17, comment; 18, try_statement; 18, 19; 18, 38; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:numpy; 25, identifier:recarray; 26, identifier:sort; 27, argument_list; 27, 28; 27, 29; 27, 32; 27, 35; 28, identifier:self; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:axis; 31, identifier:axis; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:kind; 34, identifier:kind; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:order; 37, identifier:order; 38, except_clause; 38, 39; 38, 40; 39, identifier:ValueError; 40, block; 40, 41; 40, 53; 41, if_statement; 41, 42; 41, 47; 42, call; 42, 43; 42, 44; 43, identifier:isinstance; 44, argument_list; 44, 45; 44, 46; 45, identifier:order; 46, identifier:list; 47, block; 47, 48; 48, raise_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:ValueError; 51, argument_list; 51, 52; 52, string:"Cannot process more than one order field"; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 59; 55, subscript; 55, 56; 55, 57; 56, identifier:self; 57, slice; 57, 58; 58, colon; 59, subscript; 59, 60; 59, 61; 60, identifier:self; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:numpy; 64, identifier:argsort; 65, argument_list; 65, 66; 66, subscript; 66, 67; 66, 68; 67, identifier:self; 68, identifier:order | def sort(self, axis=-1, kind='quicksort', order=None):
"""Sort an array, in-place.
This function extends the standard numpy record array in-place sort
to allow the basic use of Field array virtual fields. Only a single
field is currently supported when referencing a virtual field.
Parameters
----------
axis : int, optional
Axis along which to sort. Default is -1, which means sort along the
last axis.
kind : {'quicksort', 'mergesort', 'heapsort'}, optional
Sorting algorithm. Default is 'quicksort'.
order : list, optional
When `a` is an array with fields defined, this argument specifies
which fields to compare first, second, etc. Not all fields need be
specified.
"""
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, 12; 9, 30; 9, 49; 10, expression_statement; 10, 11; 11, comment; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:containers; 15, call; 15, 16; 15, 17; 16, identifier:sorted; 17, argument_list; 17, 18; 17, 19; 18, identifier:containers; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:key; 21, lambda; 21, 22; 21, 24; 22, lambda_parameters; 22, 23; 23, identifier:c; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:c; 27, identifier:get; 28, argument_list; 28, 29; 29, string:'name'; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:task_definition; 33, dictionary; 33, 34; 33, 39; 33, 42; 34, pair; 34, 35; 34, 36; 35, string:'family'; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:family; 39, pair; 39, 40; 39, 41; 40, string:'containerDefinitions'; 41, identifier:containers; 42, pair; 42, 43; 42, 44; 43, string:'volumes'; 44, boolean_operator:or; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:volumes; 48, list:[]; 49, if_statement; 49, 50; 49, 51; 49, 65; 50, identifier:verbose; 51, block; 51, 52; 52, return_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:json; 56, identifier:dumps; 57, argument_list; 57, 58; 57, 59; 57, 62; 58, identifier:task_definition; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:indent; 61, integer:4; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:sort_keys; 64, True; 65, else_clause; 65, 66; 66, block; 66, 67; 67, return_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:json; 71, identifier:dumps; 72, argument_list; 72, 73; 73, identifier:task_definition | def emit_containers(self, containers, verbose=True):
"""
Emits the task definition and sorts containers by name
:param containers: List of the container definitions
:type containers: list of dict
:param verbose: Print out newlines and indented JSON
:type verbose: bool
:returns: The text output
:rtype: str
"""
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, 8; 5, 14; 5, 50; 6, expression_statement; 6, 7; 7, comment; 8, import_from_statement; 8, 9; 8, 12; 9, dotted_name; 9, 10; 9, 11; 10, identifier:knack; 11, identifier:help; 12, dotted_name; 12, 13; 13, identifier:REQUIRED_TAG; 14, function_definition; 14, 15; 14, 16; 14, 18; 15, function_name:_get_weight; 16, parameters; 16, 17; 17, identifier:val; 18, block; 18, 19; 18, 21; 18, 25; 18, 44; 19, expression_statement; 19, 20; 20, comment; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:priority; 24, string:''; 25, if_statement; 25, 26; 25, 38; 26, boolean_operator:and; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:val; 29, identifier:display_meta; 30, call; 30, 31; 30, 36; 31, attribute; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:val; 34, identifier:display_meta; 35, identifier:startswith; 36, argument_list; 36, 37; 37, identifier:REQUIRED_TAG; 38, block; 38, 39; 38, 43; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:priority; 42, string:' '; 43, comment; 44, return_statement; 44, 45; 45, binary_operator:+; 45, 46; 45, 47; 46, identifier:priority; 47, attribute; 47, 48; 47, 49; 48, identifier:val; 49, identifier:text; 50, return_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:sorted; 53, argument_list; 53, 54; 53, 55; 54, identifier:completions_gen; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:key; 57, identifier:_get_weight | def sort_completions(completions_gen):
""" sorts the completions """
from knack.help import REQUIRED_TAG
def _get_weight(val):
""" weights the completions with required things first the lexicographically"""
priority = ''
if val.display_meta and val.display_meta.startswith(REQUIRED_TAG):
priority = ' ' # a space has the lowest ordinance
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, 16; 13, 25; 13, 31; 14, expression_statement; 14, 15; 15, comment; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:content; 19, call; 19, 20; 19, 21; 20, identifier:a_list; 21, argument_list; 21, 22; 21, 23; 21, 24; 22, identifier:label; 23, identifier:kwargs; 24, identifier:attributes; 25, if_statement; 25, 26; 25, 28; 26, not_operator; 26, 27; 27, identifier:content; 28, block; 28, 29; 29, return_statement; 29, 30; 30, string:''; 31, return_statement; 31, 32; 32, binary_operator:%; 32, 33; 32, 34; 33, string:' [%s]'; 34, identifier:content | def attr_list(label=None, kwargs=None, attributes=None):
"""Return assembled DOT attribute list string.
Sorts ``kwargs`` and ``attributes`` if they are plain dicts (to avoid
unpredictable order from hash randomization in Python 3 versions).
>>> attr_list()
''
>>> attr_list('spam spam', kwargs={'eggs': 'eggs', 'ham': 'ham ham'})
' [label="spam spam" eggs=eggs ham="ham ham"]'
>>> attr_list(kwargs={'spam': None, 'eggs': ''})
' [eggs=""]'
"""
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, 13; 10, 32; 11, expression_statement; 11, 12; 12, comment; 13, if_statement; 13, 14; 13, 20; 14, comparison_operator:is; 14, 15; 14, 19; 15, call; 15, 16; 15, 17; 16, identifier:type; 17, argument_list; 17, 18; 18, identifier:mapping; 19, identifier:dict; 20, block; 20, 21; 21, return_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:iter; 24, argument_list; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:sorted; 27, argument_list; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:_iteritems; 30, argument_list; 30, 31; 31, identifier:mapping; 32, return_statement; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:_iteritems; 35, argument_list; 35, 36; 36, identifier:mapping | def mapping_items(mapping, _iteritems=_compat.iteritems):
"""Return an iterator over the ``mapping`` items, sort if it's a plain dict.
>>> list(mapping_items({'spam': 0, 'ham': 1, 'eggs': 2}))
[('eggs', 2), ('ham', 1), ('spam', 0)]
>>> from collections import OrderedDict
>>> list(mapping_items(OrderedDict(enumerate(['spam', 'ham', 'eggs']))))
[(0, 'spam'), (1, 'ham'), (2, 'eggs')]
"""
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, 338; 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, 228; 212, 326; 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, comment; 228, block; 228, 229; 228, 250; 228, 296; 228, 297; 228, 298; 228, 307; 229, if_statement; 229, 230; 229, 235; 229, 242; 230, comparison_operator:!=; 230, 231; 230, 234; 231, subscript; 231, 232; 231, 233; 232, identifier:input_shape; 233, integer:0; 234, string:'None'; 235, block; 235, 236; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:N; 239, subscript; 239, 240; 239, 241; 240, identifier:input_shape; 241, integer:0; 242, else_clause; 242, 243; 243, block; 243, 244; 243, 249; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 247; 246, identifier:N; 247, unary_operator:-; 247, 248; 248, integer:1; 249, comment; 250, if_statement; 250, 251; 250, 268; 250, 288; 251, call; 251, 252; 251, 253; 252, identifier:all; 253, generator_expression; 253, 254; 253, 261; 254, call; 254, 255; 254, 256; 255, identifier:isinstance; 256, argument_list; 256, 257; 256, 258; 257, identifier:i; 258, attribute; 258, 259; 258, 260; 259, identifier:numbers; 260, identifier:Integral; 261, for_in_clause; 261, 262; 261, 263; 262, identifier:i; 263, subscript; 263, 264; 263, 265; 264, identifier:input_shape; 265, slice; 265, 266; 265, 267; 266, integer:1; 267, colon; 268, block; 268, 269; 268, 273; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:C; 272, integer:1; 273, for_statement; 273, 274; 273, 275; 273, 280; 274, identifier:i; 275, subscript; 275, 276; 275, 277; 276, identifier:input_shape; 277, slice; 277, 278; 277, 279; 278, integer:1; 279, colon; 280, block; 280, 281; 281, expression_statement; 281, 282; 282, augmented_assignment:*=; 282, 283; 282, 284; 283, identifier:C; 284, call; 284, 285; 284, 286; 285, identifier:int; 286, argument_list; 286, 287; 287, identifier:i; 288, else_clause; 288, 289; 289, block; 289, 290; 289, 295; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:C; 293, unary_operator:-; 293, 294; 294, integer:1; 295, comment; 296, comment; 297, comment; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 301; 300, identifier:buffer_name; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:scope; 304, identifier:get_unique_variable_name; 305, argument_list; 305, 306; 306, string:'buffer'; 307, expression_statement; 307, 308; 308, call; 308, 309; 308, 310; 309, identifier:apply_reshape; 310, argument_list; 310, 311; 310, 312; 310, 319; 310, 320; 310, 321; 311, identifier:scope; 312, attribute; 312, 313; 312, 318; 313, subscript; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:operator; 316, identifier:inputs; 317, integer:0; 318, identifier:full_name; 319, identifier:buffer_name; 320, identifier:container; 321, keyword_argument; 321, 322; 321, 323; 322, identifier:desired_shape; 323, list:[N, C]; 323, 324; 323, 325; 324, identifier:N; 325, identifier:C; 326, else_clause; 326, 327; 327, block; 327, 328; 328, expression_statement; 328, 329; 329, assignment; 329, 330; 329, 331; 330, identifier:buffer_name; 331, attribute; 331, 332; 331, 337; 332, subscript; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:operator; 335, identifier:inputs; 336, integer:0; 337, identifier:full_name; 338, expression_statement; 338, 339; 339, call; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, identifier:container; 342, identifier:add_node; 343, argument_list; 343, 344; 343, 345; 343, 346; 343, 353; 343, 356; 344, string:'ZipMap'; 345, identifier:buffer_name; 346, attribute; 346, 347; 346, 352; 347, subscript; 347, 348; 347, 351; 348, attribute; 348, 349; 348, 350; 349, identifier:operator; 350, identifier:outputs; 351, integer:0; 352, identifier:full_name; 353, keyword_argument; 353, 354; 353, 355; 354, identifier:op_domain; 355, string:'ai.onnx.ml'; 356, dictionary_splat; 356, 357; 357, 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:
# Calculate the shape attribute of ONNX Reshape
if input_shape[0] != 'None':
N = input_shape[0]
else:
N = -1 # -1 means that this dimension is automatically determined in runtime and unknown in conversion time
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 # -1 means that this dimension is automatically determined in runtime and unknown in conversion time
# ZipMap in ONNX only accepts [C] and [N, C] inputs. In cases of [N, C, 1, 1], we reshape the probability tensor
# into [N, C] before feeding it into ZipMap.
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; 5, 8; 6, expression_statement; 6, 7; 7, comment; 8, if_statement; 8, 9; 8, 17; 8, 145; 8, 191; 9, boolean_operator:and; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:node_grouping; 13, not_operator; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:node_order; 17, block; 17, 18; 18, if_statement; 18, 19; 18, 24; 18, 61; 19, comparison_operator:==; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:group_order; 23, string:"alphabetically"; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:nodes; 30, list_comprehension; 30, 31; 30, 32; 31, identifier:n; 32, for_in_clause; 32, 33; 32, 36; 33, pattern_list; 33, 34; 33, 35; 34, identifier:n; 35, identifier:d; 36, call; 36, 37; 36, 38; 37, identifier:sorted; 38, argument_list; 38, 39; 38, 49; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:graph; 44, identifier:nodes; 45, argument_list; 45, 46; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:data; 48, True; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:key; 51, lambda; 51, 52; 51, 54; 52, lambda_parameters; 52, 53; 53, identifier:x; 54, subscript; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:x; 57, integer:1; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:node_grouping; 61, elif_clause; 61, 62; 61, 67; 62, comparison_operator:==; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:group_order; 66, string:"default"; 67, block; 67, 68; 67, 91; 67, 101; 67, 105; 67, 139; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:grp; 71, list_comprehension; 71, 72; 71, 77; 72, subscript; 72, 73; 72, 74; 73, identifier:d; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:node_grouping; 77, for_in_clause; 77, 78; 77, 81; 78, pattern_list; 78, 79; 78, 80; 79, identifier:_; 80, identifier:d; 81, call; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:graph; 86, identifier:nodes; 87, argument_list; 87, 88; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:data; 90, True; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:grp_name; 94, call; 94, 95; 94, 96; 95, identifier:list; 96, argument_list; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:unique_everseen; 99, argument_list; 99, 100; 100, identifier:grp; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:nodes; 104, list:[]; 105, for_statement; 105, 106; 105, 107; 105, 108; 106, identifier:key; 107, identifier:grp_name; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:nodes; 113, identifier:extend; 114, argument_list; 114, 115; 115, list_comprehension; 115, 116; 115, 117; 115, 131; 116, identifier:n; 117, for_in_clause; 117, 118; 117, 121; 118, pattern_list; 118, 119; 118, 120; 119, identifier:n; 120, identifier:d; 121, call; 121, 122; 121, 127; 122, attribute; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:graph; 126, identifier:nodes; 127, argument_list; 127, 128; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:data; 130, True; 131, if_clause; 131, 132; 132, comparison_operator:in; 132, 133; 132, 134; 133, identifier:key; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:d; 137, identifier:values; 138, argument_list; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:nodes; 144, identifier:nodes; 145, elif_clause; 145, 146; 145, 154; 146, boolean_operator:and; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:node_order; 150, not_operator; 150, 151; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:node_grouping; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:nodes; 160, list_comprehension; 160, 161; 160, 162; 161, identifier:n; 162, for_in_clause; 162, 163; 162, 166; 163, pattern_list; 163, 164; 163, 165; 164, identifier:n; 165, identifier:_; 166, call; 166, 167; 166, 168; 167, identifier:sorted; 168, argument_list; 168, 169; 168, 179; 169, call; 169, 170; 169, 175; 170, attribute; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:graph; 174, identifier:nodes; 175, argument_list; 175, 176; 176, keyword_argument; 176, 177; 176, 178; 177, identifier:data; 178, True; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:key; 181, lambda; 181, 182; 181, 184; 182, lambda_parameters; 182, 183; 183, identifier:x; 184, subscript; 184, 185; 184, 188; 185, subscript; 185, 186; 185, 187; 186, identifier:x; 187, integer:1; 188, attribute; 188, 189; 188, 190; 189, identifier:self; 190, identifier:node_order; 191, elif_clause; 191, 192; 191, 199; 192, boolean_operator:and; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:self; 195, identifier:node_grouping; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:node_order; 199, block; 199, 200; 200, if_statement; 200, 201; 200, 206; 200, 251; 201, comparison_operator:==; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:self; 204, identifier:group_order; 205, string:"alphabetically"; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:self; 211, identifier:nodes; 212, list_comprehension; 212, 213; 212, 214; 213, identifier:n; 214, for_in_clause; 214, 215; 214, 218; 215, pattern_list; 215, 216; 215, 217; 216, identifier:n; 217, identifier:d; 218, call; 218, 219; 218, 220; 219, identifier:sorted; 220, argument_list; 220, 221; 220, 231; 221, call; 221, 222; 221, 227; 222, attribute; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:graph; 226, identifier:nodes; 227, argument_list; 227, 228; 228, keyword_argument; 228, 229; 228, 230; 229, identifier:data; 230, True; 231, keyword_argument; 231, 232; 231, 233; 232, identifier:key; 233, lambda; 233, 234; 233, 236; 234, lambda_parameters; 234, 235; 235, identifier:x; 236, tuple; 236, 237; 236, 244; 237, subscript; 237, 238; 237, 241; 238, subscript; 238, 239; 238, 240; 239, identifier:x; 240, integer:1; 241, attribute; 241, 242; 241, 243; 242, identifier:self; 243, identifier:node_grouping; 244, subscript; 244, 245; 244, 248; 245, subscript; 245, 246; 245, 247; 246, identifier:x; 247, integer:1; 248, attribute; 248, 249; 248, 250; 249, identifier:self; 250, identifier:node_order; 251, elif_clause; 251, 252; 251, 257; 252, comparison_operator:==; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:self; 255, identifier:group_order; 256, string:"default"; 257, block; 257, 258; 257, 281; 257, 291; 257, 295; 257, 344; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:grp; 261, list_comprehension; 261, 262; 261, 267; 262, subscript; 262, 263; 262, 264; 263, identifier:d; 264, attribute; 264, 265; 264, 266; 265, identifier:self; 266, identifier:node_grouping; 267, for_in_clause; 267, 268; 267, 271; 268, pattern_list; 268, 269; 268, 270; 269, identifier:_; 270, identifier:d; 271, call; 271, 272; 271, 277; 272, attribute; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:self; 275, identifier:graph; 276, identifier:nodes; 277, argument_list; 277, 278; 278, keyword_argument; 278, 279; 278, 280; 279, identifier:data; 280, True; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:grp_name; 284, call; 284, 285; 284, 286; 285, identifier:list; 286, argument_list; 286, 287; 287, call; 287, 288; 287, 289; 288, identifier:unique_everseen; 289, argument_list; 289, 290; 290, identifier:grp; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:nodes; 294, list:[]; 295, for_statement; 295, 296; 295, 297; 295, 298; 296, identifier:key; 297, identifier:grp_name; 298, block; 298, 299; 299, expression_statement; 299, 300; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:nodes; 303, identifier:extend; 304, argument_list; 304, 305; 305, list_comprehension; 305, 306; 305, 307; 305, 336; 306, identifier:n; 307, for_in_clause; 307, 308; 307, 311; 308, pattern_list; 308, 309; 308, 310; 309, identifier:n; 310, identifier:d; 311, call; 311, 312; 311, 313; 312, identifier:sorted; 313, argument_list; 313, 314; 313, 324; 314, call; 314, 315; 314, 320; 315, attribute; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:self; 318, identifier:graph; 319, identifier:nodes; 320, argument_list; 320, 321; 321, keyword_argument; 321, 322; 321, 323; 322, identifier:data; 323, True; 324, keyword_argument; 324, 325; 324, 326; 325, identifier:key; 326, lambda; 326, 327; 326, 329; 327, lambda_parameters; 327, 328; 328, identifier:x; 329, subscript; 329, 330; 329, 333; 330, subscript; 330, 331; 330, 332; 331, identifier:x; 332, integer:1; 333, attribute; 333, 334; 333, 335; 334, identifier:self; 335, identifier:node_order; 336, if_clause; 336, 337; 337, comparison_operator:in; 337, 338; 337, 339; 338, identifier:key; 339, call; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, identifier:d; 342, identifier:values; 343, argument_list; 344, expression_statement; 344, 345; 345, assignment; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:self; 348, identifier:nodes; 349, identifier:nodes | def group_and_sort_nodes(self):
"""
Groups and then sorts the nodes according to the criteria passed into
the Plot constructor.
"""
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