sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:qteReplaceAppletInLayout; 3, parameters; 3, 4; 3, 5; 3, 11; 3, 18; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:newApplet; 7, type; 7, 8; 8, tuple; 8, 9; 8, 10; 9, identifier:QtmacsApplet; 10, identifier:str; 11, typed_default_parameter; 11, 12; 11, 13; 11, 17; 12, identifier:oldApplet; 13, type; 13, 14; 14, tuple; 14, 15; 14, 16; 15, identifier:QtmacsApplet; 16, identifier:str; 17, None; 18, typed_default_parameter; 18, 19; 18, 20; 18, 22; 19, identifier:windowObj; 20, type; 20, 21; 21, identifier:QtmacsWindow; 22, None; 23, block; 23, 24; 23, 46; 23, 68; 23, 103; 23, 124; 23, 143; 23, 165; 23, 171; 23, 185; 23, 197; 23, 228; 23, 237; 23, 245; 23, 253; 23, 260; 24, if_statement; 24, 25; 24, 30; 24, 40; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 29; 28, identifier:oldApplet; 29, identifier:str; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:oldAppObj; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:qteGetAppletHandle; 38, argument_list; 38, 39; 39, identifier:oldApplet; 40, else_clause; 40, 41; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:oldAppObj; 45, identifier:oldApplet; 46, if_statement; 46, 47; 46, 52; 46, 62; 47, call; 47, 48; 47, 49; 48, identifier:isinstance; 49, argument_list; 49, 50; 49, 51; 50, identifier:newApplet; 51, identifier:str; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:newAppObj; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:qteGetAppletHandle; 60, argument_list; 60, 61; 61, identifier:newApplet; 62, else_clause; 62, 63; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:newAppObj; 67, identifier:newApplet; 68, if_statement; 68, 69; 68, 72; 69, comparison_operator:is; 69, 70; 69, 71; 70, identifier:windowObj; 71, None; 72, block; 72, 73; 72, 81; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:windowObj; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:qteActiveWindow; 80, argument_list; 81, if_statement; 81, 82; 81, 85; 82, comparison_operator:is; 82, 83; 82, 84; 83, identifier:windowObj; 84, None; 85, block; 85, 86; 85, 90; 85, 102; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:msg; 89, string:'Cannot determine the currently active window.'; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 97; 92, attribute; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:qteLogger; 96, identifier:warning; 97, argument_list; 97, 98; 97, 99; 98, identifier:msg; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:stack_info; 101, True; 102, return_statement; 103, if_statement; 103, 104; 103, 113; 104, comparison_operator:==; 104, 105; 104, 112; 105, call; 105, 106; 105, 111; 106, attribute; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:windowObj; 109, identifier:qteAppletSplitter; 110, identifier:count; 111, argument_list; 112, integer:0; 113, block; 113, 114; 113, 123; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 121; 116, attribute; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:windowObj; 119, identifier:qteAppletSplitter; 120, identifier:qteAddWidget; 121, argument_list; 121, 122; 122, identifier:newAppObj; 123, return_statement; 124, if_statement; 124, 125; 124, 128; 125, comparison_operator:is; 125, 126; 125, 127; 126, identifier:oldAppObj; 127, None; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:oldAppObj; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:qteNextApplet; 136, argument_list; 136, 137; 136, 140; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:numSkip; 139, integer:0; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:windowObj; 142, identifier:windowObj; 143, if_statement; 143, 144; 143, 147; 144, comparison_operator:is; 144, 145; 144, 146; 145, identifier:oldAppObj; 146, None; 147, block; 147, 148; 147, 152; 147, 164; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:msg; 151, string:'Applet to replace does not exist.'; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:qteLogger; 158, identifier:error; 159, argument_list; 159, 160; 159, 161; 160, identifier:msg; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:stack_info; 163, True; 164, return_statement; 165, if_statement; 165, 166; 165, 169; 166, comparison_operator:is; 166, 167; 166, 168; 167, identifier:newAppObj; 168, identifier:oldAppObj; 169, block; 169, 170; 170, return_statement; 171, if_statement; 171, 172; 171, 183; 172, boolean_operator:and; 172, 173; 172, 178; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:oldAppObj; 176, identifier:qteIsVisible; 177, argument_list; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:newAppObj; 181, identifier:qteIsVisible; 182, argument_list; 183, block; 183, 184; 184, return_statement; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:split; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:_qteFindAppletInSplitter; 192, argument_list; 192, 193; 192, 194; 193, identifier:oldAppObj; 194, attribute; 194, 195; 194, 196; 195, identifier:windowObj; 196, identifier:qteAppletSplitter; 197, if_statement; 197, 198; 197, 201; 198, comparison_operator:is; 198, 199; 198, 200; 199, identifier:split; 200, None; 201, block; 201, 202; 201, 218; 201, 227; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:msg; 205, parenthesized_expression; 205, 206; 206, call; 206, 207; 206, 212; 207, attribute; 207, 208; 207, 211; 208, concatenated_string; 208, 209; 208, 210; 209, string:'Applet <b>{}</b> not replaced because it is not'; 210, string:'in the layout.'; 211, identifier:format; 212, argument_list; 212, 213; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:oldAppObj; 216, identifier:qteAppletID; 217, argument_list; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 225; 220, attribute; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:self; 223, identifier:qteLogger; 224, identifier:warning; 225, argument_list; 225, 226; 226, identifier:msg; 227, return_statement; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:oldAppIdx; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:split; 234, identifier:indexOf; 235, argument_list; 235, 236; 236, identifier:oldAppObj; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:sizes; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:split; 243, identifier:sizes; 244, argument_list; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:split; 249, identifier:qteInsertWidget; 250, argument_list; 250, 251; 250, 252; 251, identifier:oldAppIdx; 252, identifier:newAppObj; 253, expression_statement; 253, 254; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:oldAppObj; 257, identifier:hide; 258, argument_list; 258, 259; 259, True; 260, expression_statement; 260, 261; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:split; 264, identifier:setSizes; 265, argument_list; 265, 266; 266, identifier:sizes | def qteReplaceAppletInLayout(self, newApplet: (QtmacsApplet, str),
oldApplet: (QtmacsApplet, str)=None,
windowObj: QtmacsWindow=None):
if isinstance(oldApplet, str):
oldAppObj = self.qteGetAppletHandle(oldApplet)
else:
oldAppObj = oldApplet
if isinstance(newApplet, str):
newAppObj = self.qteGetAppletHandle(newApplet)
else:
newAppObj = newApplet
if windowObj is None:
windowObj = self.qteActiveWindow()
if windowObj is None:
msg = 'Cannot determine the currently active window.'
self.qteLogger.warning(msg, stack_info=True)
return
if windowObj.qteAppletSplitter.count() == 0:
windowObj.qteAppletSplitter.qteAddWidget(newAppObj)
return
if oldAppObj is None:
oldAppObj = self.qteNextApplet(numSkip=0, windowObj=windowObj)
if oldAppObj is None:
msg = 'Applet to replace does not exist.'
self.qteLogger.error(msg, stack_info=True)
return
if newAppObj is oldAppObj:
return
if oldAppObj.qteIsVisible() and newAppObj.qteIsVisible():
return
split = self._qteFindAppletInSplitter(
oldAppObj, windowObj.qteAppletSplitter)
if split is None:
msg = ('Applet <b>{}</b> not replaced because it is not'
'in the layout.'.format(oldAppObj.qteAppletID()))
self.qteLogger.warning(msg)
return
oldAppIdx = split.indexOf(oldAppObj)
sizes = split.sizes()
split.qteInsertWidget(oldAppIdx, newAppObj)
oldAppObj.hide(True)
split.setSizes(sizes) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:qteRemoveAppletFromLayout; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:applet; 7, type; 7, 8; 8, tuple; 8, 9; 8, 10; 9, identifier:QtmacsApplet; 10, identifier:str; 11, block; 11, 12; 11, 34; 11, 58; 11, 64; 11, 137; 11, 146; 11, 153; 11, 187; 11, 196; 12, if_statement; 12, 13; 12, 18; 12, 28; 13, call; 13, 14; 13, 15; 14, identifier:isinstance; 15, argument_list; 15, 16; 15, 17; 16, identifier:applet; 17, identifier:str; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:appletObj; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:qteGetAppletHandle; 26, argument_list; 26, 27; 27, identifier:applet; 28, else_clause; 28, 29; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:appletObj; 33, identifier:applet; 34, for_statement; 34, 35; 34, 36; 34, 39; 35, identifier:window; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:_qteWindowList; 39, block; 39, 40; 39, 52; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:split; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:_qteFindAppletInSplitter; 47, argument_list; 47, 48; 47, 49; 48, identifier:appletObj; 49, attribute; 49, 50; 49, 51; 50, identifier:window; 51, identifier:qteAppletSplitter; 52, if_statement; 52, 53; 52, 56; 53, comparison_operator:is; 53, 54; 53, 55; 54, identifier:split; 55, None; 56, block; 56, 57; 57, break_statement; 58, if_statement; 58, 59; 58, 62; 59, comparison_operator:is; 59, 60; 59, 61; 60, identifier:split; 61, None; 62, block; 62, 63; 63, return_statement; 64, if_statement; 64, 65; 64, 80; 65, boolean_operator:and; 65, 66; 65, 72; 66, parenthesized_expression; 66, 67; 67, comparison_operator:is; 67, 68; 67, 69; 68, identifier:split; 69, attribute; 69, 70; 69, 71; 70, identifier:window; 71, identifier:qteAppletSplitter; 72, parenthesized_expression; 72, 73; 73, comparison_operator:==; 73, 74; 73, 79; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:split; 77, identifier:count; 78, argument_list; 79, integer:1; 80, block; 80, 81; 80, 93; 80, 104; 80, 129; 80, 136; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 91; 83, attribute; 83, 84; 83, 90; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:split; 87, identifier:widget; 88, argument_list; 88, 89; 89, integer:0; 90, identifier:hide; 91, argument_list; 91, 92; 92, True; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:nextApp; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:qteNextApplet; 100, argument_list; 100, 101; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:windowObj; 103, identifier:window; 104, if_statement; 104, 105; 104, 108; 105, comparison_operator:is; 105, 106; 105, 107; 106, identifier:nextApp; 107, None; 108, block; 108, 109; 108, 123; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:nextApp; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:qteNextApplet; 116, argument_list; 116, 117; 116, 120; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:skipInvisible; 119, False; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:skipVisible; 122, True; 123, if_statement; 123, 124; 123, 127; 124, comparison_operator:is; 124, 125; 124, 126; 125, identifier:nextApp; 126, None; 127, block; 127, 128; 128, return_statement; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:split; 133, identifier:qteAddWidget; 134, argument_list; 134, 135; 135, identifier:nextApp; 136, return_statement; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:appletIdx; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:split; 143, identifier:indexOf; 144, argument_list; 144, 145; 145, identifier:appletObj; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:appletObj; 150, identifier:hide; 151, argument_list; 151, 152; 152, True; 153, if_statement; 153, 154; 153, 161; 154, comparison_operator:!=; 154, 155; 154, 160; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:split; 158, identifier:count; 159, argument_list; 160, integer:1; 161, block; 161, 162; 161, 178; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:msg; 165, parenthesized_expression; 165, 166; 166, call; 166, 167; 166, 172; 167, attribute; 167, 168; 167, 171; 168, concatenated_string; 168, 169; 168, 170; 169, string:'Splitter has <b>{}</b> elements left instead of'; 170, string:' exactly one.'; 171, identifier:format; 172, argument_list; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:split; 176, identifier:count; 177, argument_list; 178, expression_statement; 178, 179; 179, call; 179, 180; 179, 185; 180, attribute; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:qteLogger; 184, identifier:warning; 185, argument_list; 185, 186; 186, identifier:msg; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:otherWidget; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:split; 193, identifier:widget; 194, argument_list; 194, 195; 195, integer:0; 196, if_statement; 196, 197; 196, 204; 196, 262; 197, comparison_operator:==; 197, 198; 197, 203; 198, attribute; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:otherWidget; 201, identifier:_qteAdmin; 202, identifier:widgetSignature; 203, string:'__QtmacsLayoutSplitter__'; 204, block; 204, 205; 204, 249; 204, 256; 205, for_statement; 205, 206; 205, 207; 205, 215; 206, identifier:ii; 207, call; 207, 208; 207, 209; 208, identifier:range; 209, argument_list; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:otherWidget; 213, identifier:count; 214, argument_list; 215, block; 215, 216; 215, 225; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:obj; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:otherWidget; 222, identifier:widget; 223, argument_list; 223, 224; 224, integer:0; 225, if_statement; 225, 226; 225, 229; 225, 237; 226, comparison_operator:==; 226, 227; 226, 228; 227, identifier:appletIdx; 228, integer:0; 229, block; 229, 230; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:split; 234, identifier:qteAddWidget; 235, argument_list; 235, 236; 236, identifier:obj; 237, else_clause; 237, 238; 238, block; 238, 239; 239, expression_statement; 239, 240; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:split; 243, identifier:qteInsertWidget; 244, argument_list; 244, 245; 244, 248; 245, binary_operator:+; 245, 246; 245, 247; 246, integer:1; 247, identifier:ii; 248, identifier:obj; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:otherWidget; 253, identifier:setParent; 254, argument_list; 254, 255; 255, None; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:otherWidget; 260, identifier:close; 261, argument_list; 262, else_clause; 262, 263; 263, block; 263, 264; 264, if_statement; 264, 265; 264, 270; 265, comparison_operator:is; 265, 266; 265, 267; 266, identifier:split; 267, attribute; 267, 268; 267, 269; 268, identifier:window; 269, identifier:qteAppletSplitter; 270, block; 270, 271; 270, 282; 270, 289; 271, expression_statement; 271, 272; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:otherWidget; 275, identifier:qteReparent; 276, argument_list; 276, 277; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:split; 280, identifier:parent; 281, argument_list; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:split; 286, identifier:setParent; 287, argument_list; 287, 288; 288, None; 289, expression_statement; 289, 290; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:split; 293, identifier:close; 294, argument_list | def qteRemoveAppletFromLayout(self, applet: (QtmacsApplet, str)):
if isinstance(applet, str):
appletObj = self.qteGetAppletHandle(applet)
else:
appletObj = applet
for window in self._qteWindowList:
split = self._qteFindAppletInSplitter(
appletObj, window.qteAppletSplitter)
if split is not None:
break
if split is None:
return
if (split is window.qteAppletSplitter) and (split.count() == 1):
split.widget(0).hide(True)
nextApp = self.qteNextApplet(windowObj=window)
if nextApp is None:
nextApp = self.qteNextApplet(skipInvisible=False,
skipVisible=True)
if nextApp is None:
return
split.qteAddWidget(nextApp)
return
appletIdx = split.indexOf(appletObj)
appletObj.hide(True)
if split.count() != 1:
msg = ('Splitter has <b>{}</b> elements left instead of'
' exactly one.'.format(split.count()))
self.qteLogger.warning(msg)
otherWidget = split.widget(0)
if otherWidget._qteAdmin.widgetSignature == '__QtmacsLayoutSplitter__':
for ii in range(otherWidget.count()):
obj = otherWidget.widget(0)
if appletIdx == 0:
split.qteAddWidget(obj)
else:
split.qteInsertWidget(1 + ii, obj)
otherWidget.setParent(None)
otherWidget.close()
else:
if split is not window.qteAppletSplitter:
otherWidget.qteReparent(split.parent())
split.setParent(None)
split.close() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:qteKillApplet; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:appletID; 7, type; 7, 8; 8, identifier:str; 9, block; 9, 10; 9, 24; 9, 49; 9, 64; 9, 70; 9, 78; 9, 96; 9, 122; 9, 135; 9, 149; 9, 158; 9, 164; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:ID_list; 13, list_comprehension; 13, 14; 13, 19; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:_; 17, identifier:qteAppletID; 18, argument_list; 19, for_in_clause; 19, 20; 19, 21; 20, identifier:_; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_qteAppletList; 24, if_statement; 24, 25; 24, 28; 24, 30; 25, comparison_operator:not; 25, 26; 25, 27; 26, identifier:appletID; 27, identifier:ID_list; 28, block; 28, 29; 29, return_statement; 30, else_clause; 30, 31; 31, block; 31, 32; 31, 41; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:idx; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:ID_list; 38, identifier:index; 39, argument_list; 39, 40; 40, identifier:appletID; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:appObj; 44, subscript; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_qteAppletList; 48, identifier:idx; 49, if_statement; 49, 50; 49, 56; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:qteIsMiniApplet; 54, argument_list; 54, 55; 55, identifier:appObj; 56, block; 56, 57; 56, 63; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:qteKillMiniApplet; 62, argument_list; 63, return_statement; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:appObj; 68, identifier:qteToBeKilled; 69, argument_list; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:window; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:appObj; 76, identifier:qteParentWindow; 77, argument_list; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:newApplet; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:qteNextApplet; 85, argument_list; 85, 86; 85, 90; 85, 93; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:numSkip; 88, unary_operator:-; 88, 89; 89, integer:1; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:skipInvisible; 92, False; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:skipVisible; 95, True; 96, if_statement; 96, 97; 96, 106; 96, 111; 97, boolean_operator:or; 97, 98; 97, 102; 98, parenthesized_expression; 98, 99; 99, comparison_operator:is; 99, 100; 99, 101; 100, identifier:newApplet; 101, None; 102, parenthesized_expression; 102, 103; 103, comparison_operator:is; 103, 104; 103, 105; 104, identifier:newApplet; 105, identifier:appObj; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:newApplet; 110, None; 111, else_clause; 111, 112; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:qteReplaceAppletInLayout; 118, argument_list; 118, 119; 118, 120; 118, 121; 119, identifier:newApplet; 120, identifier:appObj; 121, identifier:window; 122, if_statement; 122, 123; 122, 128; 123, comparison_operator:is; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:_qteActiveApplet; 127, identifier:appObj; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:self; 133, identifier:_qteActiveApplet; 134, identifier:newApplet; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 142; 137, attribute; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:self; 140, identifier:qteLogger; 141, identifier:debug; 142, argument_list; 142, 143; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, string:'Kill applet: <b>{}</b>'; 146, identifier:format; 147, argument_list; 147, 148; 148, identifier:appletID; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 156; 151, attribute; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:_qteAppletList; 155, identifier:remove; 156, argument_list; 156, 157; 157, identifier:appObj; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:appObj; 162, identifier:close; 163, argument_list; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:sip; 168, identifier:delete; 169, argument_list; 169, 170; 170, identifier:appObj | def qteKillApplet(self, appletID: str):
ID_list = [_.qteAppletID() for _ in self._qteAppletList]
if appletID not in ID_list:
return
else:
idx = ID_list.index(appletID)
appObj = self._qteAppletList[idx]
if self.qteIsMiniApplet(appObj):
self.qteKillMiniApplet()
return
appObj.qteToBeKilled()
window = appObj.qteParentWindow()
newApplet = self.qteNextApplet(numSkip=-1, skipInvisible=False,
skipVisible=True)
if (newApplet is None) or (newApplet is appObj):
newApplet = None
else:
self.qteReplaceAppletInLayout(newApplet, appObj, window)
if self._qteActiveApplet is appObj:
self._qteActiveApplet = newApplet
self.qteLogger.debug('Kill applet: <b>{}</b>'.format(appletID))
self._qteAppletList.remove(appObj)
appObj.close()
sip.delete(appObj) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:qteRunHook; 3, parameters; 3, 4; 3, 5; 3, 9; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:hookName; 7, type; 7, 8; 8, identifier:str; 9, typed_default_parameter; 9, 10; 9, 11; 9, 13; 10, identifier:msgObj; 11, type; 11, 12; 12, identifier:QtmacsMessage; 13, None; 14, block; 14, 15; 14, 21; 14, 27; 14, 38; 14, 45; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:reg; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_qteRegistryHooks; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:not; 22, 23; 22, 24; 23, identifier:hookName; 24, identifier:reg; 25, block; 25, 26; 26, return_statement; 27, if_statement; 27, 28; 27, 31; 28, comparison_operator:is; 28, 29; 28, 30; 29, identifier:msgObj; 30, None; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:msgObj; 35, call; 35, 36; 35, 37; 36, identifier:QtmacsMessage; 37, argument_list; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:msgObj; 42, identifier:setHookName; 43, argument_list; 43, 44; 44, identifier:hookName; 45, for_statement; 45, 46; 45, 47; 45, 50; 46, identifier:fun; 47, subscript; 47, 48; 47, 49; 48, identifier:reg; 49, identifier:hookName; 50, block; 50, 51; 51, try_statement; 51, 52; 51, 58; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:fun; 56, argument_list; 56, 57; 57, identifier:msgObj; 58, except_clause; 58, 59; 58, 63; 59, as_pattern; 59, 60; 59, 61; 60, identifier:Exception; 61, as_pattern_target; 61, 62; 62, identifier:err; 63, block; 63, 64; 63, 83; 63, 87; 63, 103; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:msg; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, string:'<b>{}</b>-hook function <b>{}</b>'; 70, identifier:format; 71, argument_list; 71, 72; 71, 73; 72, identifier:hookName; 73, subscript; 73, 74; 73, 78; 74, call; 74, 75; 74, 76; 75, identifier:str; 76, argument_list; 76, 77; 77, identifier:fun; 78, slice; 78, 79; 78, 80; 78, 81; 79, integer:1; 80, colon; 81, unary_operator:-; 81, 82; 82, integer:1; 83, expression_statement; 83, 84; 84, augmented_assignment:+=; 84, 85; 84, 86; 85, identifier:msg; 86, string:" did not execute properly."; 87, if_statement; 87, 88; 87, 93; 88, call; 88, 89; 88, 90; 89, identifier:isinstance; 90, argument_list; 90, 91; 90, 92; 91, identifier:err; 92, identifier:QtmacsArgumentError; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, augmented_assignment:+=; 95, 96; 95, 97; 96, identifier:msg; 97, binary_operator:+; 97, 98; 97, 99; 98, string:'<br/>'; 99, call; 99, 100; 99, 101; 100, identifier:str; 101, argument_list; 101, 102; 102, identifier:err; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:qteLogger; 109, identifier:exception; 110, argument_list; 110, 111; 110, 112; 110, 115; 111, identifier:msg; 112, keyword_argument; 112, 113; 112, 114; 113, identifier:exc_info; 114, True; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:stack_info; 117, True | def qteRunHook(self, hookName: str, msgObj: QtmacsMessage=None):
reg = self._qteRegistryHooks
if hookName not in reg:
return
if msgObj is None:
msgObj = QtmacsMessage()
msgObj.setHookName(hookName)
for fun in reg[hookName]:
try:
fun(msgObj)
except Exception as err:
msg = '<b>{}</b>-hook function <b>{}</b>'.format(
hookName, str(fun)[1:-1])
msg += " did not execute properly."
if isinstance(err, QtmacsArgumentError):
msg += '<br/>' + str(err)
self.qteLogger.exception(msg, exc_info=True, stack_info=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:qteMacroNameMangling; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:macroCls; 6, block; 6, 7; 6, 20; 6, 35; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:macroName; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:re; 13, identifier:sub; 14, argument_list; 14, 15; 14, 16; 14, 17; 15, string:r"([A-Z])"; 16, string:r'-\1'; 17, attribute; 17, 18; 17, 19; 18, identifier:macroCls; 19, identifier:__name__; 20, if_statement; 20, 21; 20, 26; 21, comparison_operator:==; 21, 22; 21, 25; 22, subscript; 22, 23; 22, 24; 23, identifier:macroName; 24, integer:0; 25, string:'-'; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:macroName; 30, subscript; 30, 31; 30, 32; 31, identifier:macroName; 32, slice; 32, 33; 32, 34; 33, integer:1; 34, colon; 35, return_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:macroName; 39, identifier:lower; 40, argument_list | def qteMacroNameMangling(self, macroCls):
macroName = re.sub(r"([A-Z])", r'-\1', macroCls.__name__)
if macroName[0] == '-':
macroName = macroName[1:]
return macroName.lower() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:qteRegisterMacro; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 11; 4, identifier:self; 5, identifier:macroCls; 6, typed_default_parameter; 6, 7; 6, 8; 6, 10; 7, identifier:replaceMacro; 8, type; 8, 9; 9, identifier:bool; 10, False; 11, typed_default_parameter; 11, 12; 11, 13; 11, 15; 12, identifier:macroName; 13, type; 13, 14; 14, identifier:str; 15, None; 16, block; 16, 17; 16, 46; 16, 86; 16, 119; 16, 125; 16, 160; 16, 195; 16, 199; 16, 328; 17, if_statement; 17, 18; 17, 24; 18, not_operator; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:issubclass; 21, argument_list; 21, 22; 21, 23; 22, identifier:macroCls; 23, identifier:QtmacsMacro; 24, block; 24, 25; 24, 40; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:args; 28, tuple; 28, 29; 28, 30; 28, 31; 29, string:'macroCls'; 30, string:'class QtmacsMacro'; 31, subscript; 31, 32; 31, 39; 32, subscript; 32, 33; 32, 38; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:inspect; 36, identifier:stack; 37, argument_list; 38, integer:0; 39, integer:3; 40, raise_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:QtmacsArgumentError; 43, argument_list; 43, 44; 44, list_splat; 44, 45; 45, identifier:args; 46, try_statement; 46, 47; 46, 54; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:macroObj; 51, call; 51, 52; 51, 53; 52, identifier:macroCls; 53, argument_list; 54, except_clause; 54, 55; 54, 56; 55, identifier:Exception; 56, block; 56, 57; 56, 61; 56, 72; 56, 84; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:msg; 60, string:'The macro <b>{}</b> has a faulty constructor.'; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:msg; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:msg; 67, identifier:format; 68, argument_list; 68, 69; 69, attribute; 69, 70; 69, 71; 70, identifier:macroCls; 71, identifier:__name__; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 79; 74, attribute; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:qteLogger; 78, identifier:error; 79, argument_list; 79, 80; 79, 81; 80, identifier:msg; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:stack_info; 83, True; 84, return_statement; 84, 85; 85, None; 86, if_statement; 86, 87; 86, 90; 87, comparison_operator:is; 87, 88; 87, 89; 88, identifier:macroName; 89, None; 90, block; 90, 91; 91, if_statement; 91, 92; 91, 99; 91, 109; 92, comparison_operator:is; 92, 93; 92, 98; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:macroObj; 96, identifier:qteMacroName; 97, argument_list; 98, None; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:macroName; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:qteMacroNameMangling; 107, argument_list; 107, 108; 108, identifier:macroCls; 109, else_clause; 109, 110; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:macroName; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:macroObj; 117, identifier:qteMacroName; 118, argument_list; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:macroObj; 123, identifier:_qteMacroName; 124, identifier:macroName; 125, if_statement; 125, 126; 125, 136; 126, comparison_operator:==; 126, 127; 126, 135; 127, call; 127, 128; 127, 129; 128, identifier:len; 129, argument_list; 129, 130; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:macroObj; 133, identifier:qteAppletSignature; 134, argument_list; 135, integer:0; 136, block; 136, 137; 136, 146; 136, 158; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:msg; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, string:'Macro <b>{}</b> has no applet signatures.'; 143, identifier:format; 144, argument_list; 144, 145; 145, identifier:macroName; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 153; 148, attribute; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:qteLogger; 152, identifier:error; 153, argument_list; 153, 154; 153, 155; 154, identifier:msg; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:stack_info; 157, True; 158, return_statement; 158, 159; 159, None; 160, if_statement; 160, 161; 160, 171; 161, comparison_operator:==; 161, 162; 161, 170; 162, call; 162, 163; 162, 164; 163, identifier:len; 164, argument_list; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:macroObj; 168, identifier:qteWidgetSignature; 169, argument_list; 170, integer:0; 171, block; 171, 172; 171, 181; 171, 193; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:msg; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, string:'Macro <b>{}</b> has no widget signatures.'; 178, identifier:format; 179, argument_list; 179, 180; 180, identifier:macroName; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 188; 183, attribute; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:qteLogger; 187, identifier:error; 188, argument_list; 188, 189; 188, 190; 189, identifier:msg; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:stack_info; 192, True; 193, return_statement; 193, 194; 194, None; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:anyRegistered; 198, False; 199, for_statement; 199, 200; 199, 201; 199, 206; 200, identifier:app_sig; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:macroObj; 204, identifier:qteAppletSignature; 205, argument_list; 206, block; 206, 207; 207, for_statement; 207, 208; 207, 209; 207, 214; 208, identifier:wid_sig; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:macroObj; 212, identifier:qteWidgetSignature; 213, argument_list; 214, block; 214, 215; 214, 222; 214, 297; 214, 305; 214, 315; 214, 324; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:macroNameInternal; 218, tuple; 218, 219; 218, 220; 218, 221; 219, identifier:macroName; 220, identifier:app_sig; 221, identifier:wid_sig; 222, if_statement; 222, 223; 222, 228; 223, comparison_operator:in; 223, 224; 223, 225; 224, identifier:macroNameInternal; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:_qteRegistryMacros; 228, block; 228, 229; 229, if_statement; 229, 230; 229, 231; 229, 272; 230, identifier:replaceMacro; 231, block; 231, 232; 231, 243; 231, 247; 231, 257; 231, 266; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:tmp; 235, call; 235, 236; 235, 241; 236, attribute; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:self; 239, identifier:_qteRegistryMacros; 240, identifier:pop; 241, argument_list; 241, 242; 242, identifier:macroNameInternal; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:msg; 246, string:'Replacing existing macro <b>{}</b> with new {}.'; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:msg; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:msg; 253, identifier:format; 254, argument_list; 254, 255; 254, 256; 255, identifier:macroNameInternal; 256, identifier:macroObj; 257, expression_statement; 257, 258; 258, call; 258, 259; 258, 264; 259, attribute; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:self; 262, identifier:qteLogger; 263, identifier:info; 264, argument_list; 264, 265; 265, identifier:msg; 266, expression_statement; 266, 267; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:tmp; 270, identifier:deleteLater; 271, argument_list; 272, else_clause; 272, 273; 273, block; 273, 274; 273, 278; 273, 287; 273, 296; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:msg; 277, string:'Macro <b>{}</b> already exists (not replaced).'; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:msg; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:msg; 284, identifier:format; 285, argument_list; 285, 286; 286, identifier:macroNameInternal; 287, expression_statement; 287, 288; 288, call; 288, 289; 288, 294; 289, attribute; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:self; 292, identifier:qteLogger; 293, identifier:info; 294, argument_list; 294, 295; 295, identifier:msg; 296, continue_statement; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 304; 299, subscript; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:self; 302, identifier:_qteRegistryMacros; 303, identifier:macroNameInternal; 304, identifier:macroObj; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:msg; 308, parenthesized_expression; 308, 309; 309, call; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, string:'Macro <b>{}</b> successfully registered.'; 312, identifier:format; 313, argument_list; 313, 314; 314, identifier:macroNameInternal; 315, expression_statement; 315, 316; 316, call; 316, 317; 316, 322; 317, attribute; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:self; 320, identifier:qteLogger; 321, identifier:info; 322, argument_list; 322, 323; 323, identifier:msg; 324, expression_statement; 324, 325; 325, assignment; 325, 326; 325, 327; 326, identifier:anyRegistered; 327, True; 328, return_statement; 328, 329; 329, identifier:macroName | def qteRegisterMacro(self, macroCls, replaceMacro: bool=False,
macroName: str=None):
if not issubclass(macroCls, QtmacsMacro):
args = ('macroCls', 'class QtmacsMacro', inspect.stack()[0][3])
raise QtmacsArgumentError(*args)
try:
macroObj = macroCls()
except Exception:
msg = 'The macro <b>{}</b> has a faulty constructor.'
msg = msg.format(macroCls.__name__)
self.qteLogger.error(msg, stack_info=True)
return None
if macroName is None:
if macroObj.qteMacroName() is None:
macroName = self.qteMacroNameMangling(macroCls)
else:
macroName = macroObj.qteMacroName()
macroObj._qteMacroName = macroName
if len(macroObj.qteAppletSignature()) == 0:
msg = 'Macro <b>{}</b> has no applet signatures.'.format(macroName)
self.qteLogger.error(msg, stack_info=True)
return None
if len(macroObj.qteWidgetSignature()) == 0:
msg = 'Macro <b>{}</b> has no widget signatures.'.format(macroName)
self.qteLogger.error(msg, stack_info=True)
return None
anyRegistered = False
for app_sig in macroObj.qteAppletSignature():
for wid_sig in macroObj.qteWidgetSignature():
macroNameInternal = (macroName, app_sig, wid_sig)
if macroNameInternal in self._qteRegistryMacros:
if replaceMacro:
tmp = self._qteRegistryMacros.pop(macroNameInternal)
msg = 'Replacing existing macro <b>{}</b> with new {}.'
msg = msg.format(macroNameInternal, macroObj)
self.qteLogger.info(msg)
tmp.deleteLater()
else:
msg = 'Macro <b>{}</b> already exists (not replaced).'
msg = msg.format(macroNameInternal)
self.qteLogger.info(msg)
continue
self._qteRegistryMacros[macroNameInternal] = macroObj
msg = ('Macro <b>{}</b> successfully registered.'
.format(macroNameInternal))
self.qteLogger.info(msg)
anyRegistered = True
return macroName |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:qteGetMacroObject; 3, parameters; 3, 4; 3, 5; 3, 9; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:macroName; 7, type; 7, 8; 8, identifier:str; 9, typed_parameter; 9, 10; 9, 11; 10, identifier:widgetObj; 11, type; 11, 12; 12, attribute; 12, 13; 12, 14; 13, identifier:QtGui; 14, identifier:QWidget; 15, block; 15, 16; 15, 94; 15, 110; 15, 126; 15, 163; 16, if_statement; 16, 17; 16, 22; 16, 62; 17, call; 17, 18; 17, 19; 18, identifier:hasattr; 19, argument_list; 19, 20; 19, 21; 20, identifier:widgetObj; 21, string:'_qteAdmin'; 22, block; 22, 23; 22, 31; 22, 39; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:app_signature; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:widgetObj; 29, identifier:_qteAdmin; 30, identifier:appletSignature; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:wid_signature; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:widgetObj; 37, identifier:_qteAdmin; 38, identifier:widgetSignature; 39, if_statement; 39, 40; 39, 43; 40, comparison_operator:is; 40, 41; 40, 42; 41, identifier:app_signature; 42, None; 43, block; 43, 44; 43, 48; 43, 60; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:msg; 47, string:'Applet has no signature.'; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:qteLogger; 54, identifier:error; 55, argument_list; 55, 56; 55, 57; 56, identifier:msg; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:stack_info; 59, True; 60, return_statement; 60, 61; 61, None; 62, else_clause; 62, 63; 63, block; 63, 64; 63, 68; 63, 75; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:wid_signature; 67, None; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:app; 71, call; 71, 72; 71, 73; 72, identifier:qteGetAppletFromWidget; 73, argument_list; 73, 74; 74, identifier:widgetObj; 75, if_statement; 75, 76; 75, 79; 75, 84; 76, comparison_operator:is; 76, 77; 76, 78; 77, identifier:app; 78, None; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:app_signature; 83, None; 84, else_clause; 84, 85; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:app_signature; 89, attribute; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:app; 92, identifier:_qteAdmin; 93, identifier:appletSignature; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:name_match; 97, list_comprehension; 97, 98; 97, 99; 97, 104; 98, identifier:m; 99, for_in_clause; 99, 100; 99, 101; 100, identifier:m; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:_qteRegistryMacros; 104, if_clause; 104, 105; 105, comparison_operator:==; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:m; 108, integer:0; 109, identifier:macroName; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:app_sig_match; 113, list_comprehension; 113, 114; 113, 115; 113, 118; 114, identifier:_; 115, for_in_clause; 115, 116; 115, 117; 116, identifier:_; 117, identifier:name_match; 118, if_clause; 118, 119; 119, comparison_operator:in; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:_; 122, integer:1; 123, tuple; 123, 124; 123, 125; 124, identifier:app_signature; 125, string:'*'; 126, if_statement; 126, 127; 126, 130; 126, 145; 127, comparison_operator:is; 127, 128; 127, 129; 128, identifier:wid_signature; 129, None; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:wid_sig_match; 134, list_comprehension; 134, 135; 134, 136; 134, 139; 135, identifier:_; 136, for_in_clause; 136, 137; 136, 138; 137, identifier:_; 138, identifier:app_sig_match; 139, if_clause; 139, 140; 140, comparison_operator:==; 140, 141; 140, 144; 141, subscript; 141, 142; 141, 143; 142, identifier:_; 143, integer:2; 144, string:'*'; 145, else_clause; 145, 146; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:wid_sig_match; 150, list_comprehension; 150, 151; 150, 152; 150, 155; 151, identifier:_; 152, for_in_clause; 152, 153; 152, 154; 153, identifier:_; 154, identifier:app_sig_match; 155, if_clause; 155, 156; 156, comparison_operator:in; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:_; 159, integer:2; 160, tuple; 160, 161; 160, 162; 161, identifier:wid_signature; 162, string:'*'; 163, if_statement; 163, 164; 163, 170; 163, 173; 163, 193; 164, comparison_operator:==; 164, 165; 164, 169; 165, call; 165, 166; 165, 167; 166, identifier:len; 167, argument_list; 167, 168; 168, identifier:wid_sig_match; 169, integer:0; 170, block; 170, 171; 171, return_statement; 171, 172; 172, None; 173, elif_clause; 173, 174; 173, 180; 174, comparison_operator:==; 174, 175; 174, 179; 175, call; 175, 176; 175, 177; 176, identifier:len; 177, argument_list; 177, 178; 178, identifier:wid_sig_match; 179, integer:1; 180, block; 180, 181; 180, 187; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:match; 184, subscript; 184, 185; 184, 186; 185, identifier:wid_sig_match; 186, integer:0; 187, return_statement; 187, 188; 188, subscript; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:_qteRegistryMacros; 192, identifier:match; 193, else_clause; 193, 194; 194, block; 194, 195; 194, 217; 194, 237; 194, 251; 194, 271; 194, 285; 194, 305; 194, 327; 194, 347; 194, 351; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:tmp; 198, list_comprehension; 198, 199; 198, 200; 198, 203; 199, identifier:match; 200, for_in_clause; 200, 201; 200, 202; 201, identifier:match; 202, identifier:wid_sig_match; 203, if_clause; 203, 204; 204, boolean_operator:and; 204, 205; 204, 211; 205, parenthesized_expression; 205, 206; 206, comparison_operator:!=; 206, 207; 206, 210; 207, subscript; 207, 208; 207, 209; 208, identifier:match; 209, integer:1; 210, string:'*'; 211, parenthesized_expression; 211, 212; 212, comparison_operator:!=; 212, 213; 212, 216; 213, subscript; 213, 214; 213, 215; 214, identifier:match; 215, integer:2; 216, string:'*'; 217, if_statement; 217, 218; 217, 224; 218, comparison_operator:>; 218, 219; 218, 223; 219, call; 219, 220; 219, 221; 220, identifier:len; 221, argument_list; 221, 222; 222, identifier:tmp; 223, integer:0; 224, block; 224, 225; 224, 231; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:match; 228, subscript; 228, 229; 228, 230; 229, identifier:tmp; 230, integer:0; 231, return_statement; 231, 232; 232, subscript; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:self; 235, identifier:_qteRegistryMacros; 236, identifier:match; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:tmp; 240, list_comprehension; 240, 241; 240, 242; 240, 245; 241, identifier:match; 242, for_in_clause; 242, 243; 242, 244; 243, identifier:match; 244, identifier:wid_sig_match; 245, if_clause; 245, 246; 246, comparison_operator:!=; 246, 247; 246, 250; 247, subscript; 247, 248; 247, 249; 248, identifier:match; 249, integer:2; 250, string:'*'; 251, if_statement; 251, 252; 251, 258; 252, comparison_operator:>; 252, 253; 252, 257; 253, call; 253, 254; 253, 255; 254, identifier:len; 255, argument_list; 255, 256; 256, identifier:tmp; 257, integer:0; 258, block; 258, 259; 258, 265; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:match; 262, subscript; 262, 263; 262, 264; 263, identifier:tmp; 264, integer:0; 265, return_statement; 265, 266; 266, subscript; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:self; 269, identifier:_qteRegistryMacros; 270, identifier:match; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:tmp; 274, list_comprehension; 274, 275; 274, 276; 274, 279; 275, identifier:match; 276, for_in_clause; 276, 277; 276, 278; 277, identifier:match; 278, identifier:wid_sig_match; 279, if_clause; 279, 280; 280, comparison_operator:!=; 280, 281; 280, 284; 281, subscript; 281, 282; 281, 283; 282, identifier:match; 283, integer:1; 284, string:'*'; 285, if_statement; 285, 286; 285, 292; 286, comparison_operator:>; 286, 287; 286, 291; 287, call; 287, 288; 287, 289; 288, identifier:len; 289, argument_list; 289, 290; 290, identifier:tmp; 291, integer:0; 292, block; 292, 293; 292, 299; 293, expression_statement; 293, 294; 294, assignment; 294, 295; 294, 296; 295, identifier:match; 296, subscript; 296, 297; 296, 298; 297, identifier:tmp; 298, integer:0; 299, return_statement; 299, 300; 300, subscript; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:self; 303, identifier:_qteRegistryMacros; 304, identifier:match; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:tmp; 308, list_comprehension; 308, 309; 308, 310; 308, 313; 309, identifier:match; 310, for_in_clause; 310, 311; 310, 312; 311, identifier:match; 312, identifier:wid_sig_match; 313, if_clause; 313, 314; 314, boolean_operator:and; 314, 315; 314, 321; 315, parenthesized_expression; 315, 316; 316, comparison_operator:==; 316, 317; 316, 320; 317, subscript; 317, 318; 317, 319; 318, identifier:match; 319, integer:1; 320, string:'*'; 321, parenthesized_expression; 321, 322; 322, comparison_operator:==; 322, 323; 322, 326; 323, subscript; 323, 324; 323, 325; 324, identifier:match; 325, integer:2; 326, string:'*'; 327, if_statement; 327, 328; 327, 334; 328, comparison_operator:>; 328, 329; 328, 333; 329, call; 329, 330; 329, 331; 330, identifier:len; 331, argument_list; 331, 332; 332, identifier:tmp; 333, integer:0; 334, block; 334, 335; 334, 341; 335, expression_statement; 335, 336; 336, assignment; 336, 337; 336, 338; 337, identifier:match; 338, subscript; 338, 339; 338, 340; 339, identifier:tmp; 340, integer:0; 341, return_statement; 341, 342; 342, subscript; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:self; 345, identifier:_qteRegistryMacros; 346, identifier:match; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 350; 349, identifier:msg; 350, string:'No compatible macro found - should be impossible.'; 351, expression_statement; 351, 352; 352, call; 352, 353; 352, 358; 353, attribute; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:self; 356, identifier:qteLogger; 357, identifier:error; 358, argument_list; 358, 359; 358, 360; 359, identifier:msg; 360, keyword_argument; 360, 361; 360, 362; 361, identifier:stack_info; 362, True | def qteGetMacroObject(self, macroName: str, widgetObj: QtGui.QWidget):
if hasattr(widgetObj, '_qteAdmin'):
app_signature = widgetObj._qteAdmin.appletSignature
wid_signature = widgetObj._qteAdmin.widgetSignature
if app_signature is None:
msg = 'Applet has no signature.'
self.qteLogger.error(msg, stack_info=True)
return None
else:
wid_signature = None
app = qteGetAppletFromWidget(widgetObj)
if app is None:
app_signature = None
else:
app_signature = app._qteAdmin.appletSignature
name_match = [m for m in self._qteRegistryMacros if m[0] == macroName]
app_sig_match = [_ for _ in name_match if _[1] in (app_signature, '*')]
if wid_signature is None:
wid_sig_match = [_ for _ in app_sig_match if _[2] == '*']
else:
wid_sig_match = [_ for _ in app_sig_match
if _[2] in (wid_signature, '*')]
if len(wid_sig_match) == 0:
return None
elif len(wid_sig_match) == 1:
match = wid_sig_match[0]
return self._qteRegistryMacros[match]
else:
tmp = [match for match in wid_sig_match if (match[1] != '*')
and (match[2] != '*')]
if len(tmp) > 0:
match = tmp[0]
return self._qteRegistryMacros[match]
tmp = [match for match in wid_sig_match if match[2] != '*']
if len(tmp) > 0:
match = tmp[0]
return self._qteRegistryMacros[match]
tmp = [match for match in wid_sig_match if match[1] != '*']
if len(tmp) > 0:
match = tmp[0]
return self._qteRegistryMacros[match]
tmp = [match for match in wid_sig_match if (match[1] == '*')
and (match[2] == '*')]
if len(tmp) > 0:
match = tmp[0]
return self._qteRegistryMacros[match]
msg = 'No compatible macro found - should be impossible.'
self.qteLogger.error(msg, stack_info=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:qteGetAllMacroNames; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_default_parameter; 5, 6; 5, 7; 5, 11; 6, identifier:widgetObj; 7, type; 7, 8; 8, attribute; 8, 9; 8, 10; 9, identifier:QtGui; 10, identifier:QWidget; 11, None; 12, block; 12, 13; 12, 26; 12, 36; 12, 46; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:macro_list; 16, call; 16, 17; 16, 18; 17, identifier:tuple; 18, argument_list; 18, 19; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_qteRegistryMacros; 24, identifier:keys; 25, argument_list; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:macro_list; 29, list_comprehension; 29, 30; 29, 33; 30, subscript; 30, 31; 30, 32; 31, identifier:_; 32, integer:0; 33, for_in_clause; 33, 34; 33, 35; 34, identifier:_; 35, identifier:macro_list; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:macro_list; 39, call; 39, 40; 39, 41; 40, identifier:tuple; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:set; 44, argument_list; 44, 45; 45, identifier:macro_list; 46, if_statement; 46, 47; 46, 50; 46, 53; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:widgetObj; 49, None; 50, block; 50, 51; 51, return_statement; 51, 52; 52, identifier:macro_list; 53, else_clause; 53, 54; 54, block; 54, 55; 54, 69; 54, 85; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:macro_list; 58, list_comprehension; 58, 59; 58, 66; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:qteGetMacroObject; 63, argument_list; 63, 64; 63, 65; 64, identifier:macroName; 65, identifier:widgetObj; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:macroName; 68, identifier:macro_list; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:macro_list; 72, list_comprehension; 72, 73; 72, 78; 72, 81; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:_; 76, identifier:qteMacroName; 77, argument_list; 78, for_in_clause; 78, 79; 78, 80; 79, identifier:_; 80, identifier:macro_list; 81, if_clause; 81, 82; 82, comparison_operator:is; 82, 83; 82, 84; 83, identifier:_; 84, None; 85, return_statement; 85, 86; 86, identifier:macro_list | def qteGetAllMacroNames(self, widgetObj: QtGui.QWidget=None):
macro_list = tuple(self._qteRegistryMacros.keys())
macro_list = [_[0] for _ in macro_list]
macro_list = tuple(set(macro_list))
if widgetObj is None:
return macro_list
else:
macro_list = [self.qteGetMacroObject(macroName, widgetObj)
for macroName in macro_list]
macro_list = [_.qteMacroName() for _ in macro_list
if _ is not None]
return macro_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:qteBindKeyGlobal; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:keysequence; 6, typed_parameter; 6, 7; 6, 8; 7, identifier:macroName; 8, type; 8, 9; 9, identifier:str; 10, block; 10, 11; 10, 18; 10, 54; 10, 64; 10, 79; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:keysequence; 14, call; 14, 15; 14, 16; 15, identifier:QtmacsKeysequence; 16, argument_list; 16, 17; 17, identifier:keysequence; 18, if_statement; 18, 19; 18, 26; 19, not_operator; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:qteIsMacroRegistered; 24, argument_list; 24, 25; 25, identifier:macroName; 26, block; 26, 27; 26, 31; 26, 40; 26, 52; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:msg; 30, string:'Cannot globally bind key to unknown macro <b>{}</b>.'; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:msg; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:msg; 37, identifier:format; 38, argument_list; 38, 39; 39, identifier:macroName; 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:qteLogger; 46, identifier:error; 47, argument_list; 47, 48; 47, 49; 48, identifier:msg; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:stack_info; 51, True; 52, return_statement; 52, 53; 53, False; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_qteGlobalKeyMap; 60, identifier:qteInsertKey; 61, argument_list; 61, 62; 61, 63; 62, identifier:keysequence; 63, identifier:macroName; 64, for_statement; 64, 65; 64, 66; 64, 69; 65, identifier:app; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:_qteAppletList; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:qteBindKeyApplet; 75, argument_list; 75, 76; 75, 77; 75, 78; 76, identifier:keysequence; 77, identifier:macroName; 78, identifier:app; 79, return_statement; 79, 80; 80, True | def qteBindKeyGlobal(self, keysequence, macroName: str):
keysequence = QtmacsKeysequence(keysequence)
if not self.qteIsMacroRegistered(macroName):
msg = 'Cannot globally bind key to unknown macro <b>{}</b>.'
msg = msg.format(macroName)
self.qteLogger.error(msg, stack_info=True)
return False
self._qteGlobalKeyMap.qteInsertKey(keysequence, macroName)
for app in self._qteAppletList:
self.qteBindKeyApplet(keysequence, macroName, app)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:qteRegisterApplet; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:cls; 6, typed_default_parameter; 6, 7; 6, 8; 6, 10; 7, identifier:replaceApplet; 8, type; 8, 9; 9, identifier:bool; 10, False; 11, block; 11, 12; 11, 41; 11, 47; 11, 96; 11, 102; 11, 110; 11, 124; 12, if_statement; 12, 13; 12, 19; 13, not_operator; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:issubclass; 16, argument_list; 16, 17; 16, 18; 17, identifier:cls; 18, identifier:QtmacsApplet; 19, block; 19, 20; 19, 35; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:args; 23, tuple; 23, 24; 23, 25; 23, 26; 24, string:'cls'; 25, string:'class QtmacsApplet'; 26, subscript; 26, 27; 26, 34; 27, subscript; 27, 28; 27, 33; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:inspect; 31, identifier:stack; 32, argument_list; 33, integer:0; 34, integer:3; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:QtmacsArgumentError; 38, argument_list; 38, 39; 39, list_splat; 39, 40; 40, identifier:args; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:class_name; 44, attribute; 44, 45; 44, 46; 45, identifier:cls; 46, identifier:__name__; 47, if_statement; 47, 48; 47, 53; 48, comparison_operator:in; 48, 49; 48, 50; 49, identifier:class_name; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:_qteRegistryApplets; 53, block; 53, 54; 53, 63; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:msg; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, string:'The original applet <b>{}</b>'; 60, identifier:format; 61, argument_list; 61, 62; 62, identifier:class_name; 63, if_statement; 63, 64; 63, 65; 63, 79; 64, identifier:replaceApplet; 65, block; 65, 66; 65, 70; 66, expression_statement; 66, 67; 67, augmented_assignment:+=; 67, 68; 67, 69; 68, identifier:msg; 69, string:' was redefined.'; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:qteLogger; 76, identifier:warning; 77, argument_list; 77, 78; 78, identifier:msg; 79, else_clause; 79, 80; 80, block; 80, 81; 80, 85; 80, 94; 81, expression_statement; 81, 82; 82, augmented_assignment:+=; 82, 83; 82, 84; 83, identifier:msg; 84, string:' was not redefined.'; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:qteLogger; 91, identifier:warning; 92, argument_list; 92, 93; 93, identifier:msg; 94, return_statement; 94, 95; 95, identifier:class_name; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:cls; 100, identifier:__qteRegisterAppletInit__; 101, argument_list; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 109; 104, subscript; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:_qteRegistryApplets; 108, identifier:class_name; 109, identifier:cls; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 117; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:qteLogger; 116, identifier:info; 117, argument_list; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, string:'Applet <b>{}</b> now registered.'; 121, identifier:format; 122, argument_list; 122, 123; 123, identifier:class_name; 124, return_statement; 124, 125; 125, identifier:class_name | def qteRegisterApplet(self, cls, replaceApplet: bool=False):
if not issubclass(cls, QtmacsApplet):
args = ('cls', 'class QtmacsApplet', inspect.stack()[0][3])
raise QtmacsArgumentError(*args)
class_name = cls.__name__
if class_name in self._qteRegistryApplets:
msg = 'The original applet <b>{}</b>'.format(class_name)
if replaceApplet:
msg += ' was redefined.'
self.qteLogger.warning(msg)
else:
msg += ' was not redefined.'
self.qteLogger.warning(msg)
return class_name
cls.__qteRegisterAppletInit__()
self._qteRegistryApplets[class_name] = cls
self.qteLogger.info('Applet <b>{}</b> now registered.'
.format(class_name))
return class_name |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:start; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 12; 7, 16; 7, 23; 7, 119; 7, 125; 7, 130; 7, 136; 7, 195; 7, 259; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:ts; 11, dictionary; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:ret; 15, dictionary; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:info_parts; 19, set; 19, 20; 19, 21; 19, 22; 20, string:'info'; 21, string:'get-value'; 22, string:'get_value'; 23, for_statement; 23, 24; 23, 25; 23, 28; 24, identifier:cmd; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:commands; 28, block; 28, 29; 28, 41; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:parser_cmd; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:parser_commands; 37, identifier:get; 38, argument_list; 38, 39; 38, 40; 39, identifier:cmd; 40, identifier:cmd; 41, if_statement; 41, 42; 41, 49; 42, boolean_operator:or; 42, 43; 42, 46; 43, comparison_operator:in; 43, 44; 43, 45; 44, identifier:parser_cmd; 45, identifier:kwargs; 46, comparison_operator:in; 46, 47; 46, 48; 47, identifier:cmd; 48, identifier:kwargs; 49, block; 49, 50; 49, 65; 49, 79; 49, 89; 49, 99; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:kws; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:kwargs; 56, identifier:get; 57, argument_list; 57, 58; 57, 59; 58, identifier:cmd; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:kwargs; 62, identifier:get; 63, argument_list; 63, 64; 64, identifier:parser_cmd; 65, if_statement; 65, 66; 65, 71; 66, call; 66, 67; 66, 68; 67, identifier:isinstance; 68, argument_list; 68, 69; 68, 70; 69, identifier:kws; 70, identifier:Namespace; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:kws; 75, call; 75, 76; 75, 77; 76, identifier:vars; 77, argument_list; 77, 78; 78, identifier:kws; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:func; 82, call; 82, 83; 82, 84; 83, identifier:getattr; 84, argument_list; 84, 85; 84, 86; 85, identifier:self; 86, boolean_operator:or; 86, 87; 86, 88; 87, identifier:cmd; 88, string:'main'; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 94; 91, subscript; 91, 92; 91, 93; 92, identifier:ret; 93, identifier:cmd; 94, call; 94, 95; 94, 96; 95, identifier:func; 96, argument_list; 96, 97; 97, dictionary_splat; 97, 98; 98, identifier:kws; 99, if_statement; 99, 100; 99, 103; 100, comparison_operator:not; 100, 101; 100, 102; 101, identifier:cmd; 102, identifier:info_parts; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:ts; 108, identifier:cmd; 109, call; 109, 110; 109, 111; 110, identifier:str; 111, argument_list; 111, 112; 112, call; 112, 113; 112, 118; 113, attribute; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:dt; 116, identifier:datetime; 117, identifier:now; 118, argument_list; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:exp; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:_experiment; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:project_parts; 128, set; 128, 129; 129, string:'setup'; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:projectname; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:_projectname; 136, if_statement; 136, 137; 136, 156; 136, 185; 137, parenthesized_expression; 137, 138; 138, boolean_operator:and; 138, 139; 138, 149; 139, boolean_operator:and; 139, 140; 139, 143; 140, comparison_operator:is; 140, 141; 140, 142; 141, identifier:projectname; 142, None; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:project_parts; 146, identifier:intersection; 147, argument_list; 147, 148; 148, identifier:ts; 149, comparison_operator:in; 149, 150; 149, 151; 150, identifier:projectname; 151, attribute; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:config; 155, identifier:projects; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 170; 159, attribute; 159, 160; 159, 169; 160, subscript; 160, 161; 160, 168; 161, subscript; 161, 162; 161, 167; 162, attribute; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:config; 166, identifier:projects; 167, identifier:projectname; 168, string:'timestamps'; 169, identifier:update; 170, argument_list; 170, 171; 171, dictionary_comprehension; 171, 172; 171, 177; 172, pair; 172, 173; 172, 174; 173, identifier:key; 174, subscript; 174, 175; 174, 176; 175, identifier:ts; 176, identifier:key; 177, for_in_clause; 177, 178; 177, 179; 178, identifier:key; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:project_parts; 182, identifier:intersection; 183, argument_list; 183, 184; 184, identifier:ts; 185, elif_clause; 185, 186; 185, 188; 186, not_operator; 186, 187; 187, identifier:ts; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:self; 193, identifier:no_modification; 194, True; 195, if_statement; 195, 196; 195, 207; 196, boolean_operator:and; 196, 197; 196, 200; 197, comparison_operator:is; 197, 198; 197, 199; 198, identifier:exp; 199, None; 200, comparison_operator:in; 200, 201; 200, 202; 201, identifier:exp; 202, attribute; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:self; 205, identifier:config; 206, identifier:experiments; 207, block; 207, 208; 207, 214; 207, 235; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:projectname; 211, attribute; 211, 212; 211, 213; 212, identifier:self; 213, identifier:projectname; 214, try_statement; 214, 215; 214, 231; 215, block; 215, 216; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:ts; 220, identifier:update; 221, argument_list; 221, 222; 222, subscript; 222, 223; 222, 230; 223, subscript; 223, 224; 223, 229; 224, attribute; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:config; 228, identifier:projects; 229, identifier:projectname; 230, string:'timestamps'; 231, except_clause; 231, 232; 231, 233; 232, identifier:KeyError; 233, block; 233, 234; 234, pass_statement; 235, if_statement; 235, 236; 235, 243; 236, not_operator; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:self; 240, identifier:is_archived; 241, argument_list; 241, 242; 242, identifier:exp; 243, block; 243, 244; 244, expression_statement; 244, 245; 245, call; 245, 246; 245, 257; 246, attribute; 246, 247; 246, 256; 247, subscript; 247, 248; 247, 255; 248, subscript; 248, 249; 248, 254; 249, attribute; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:self; 252, identifier:config; 253, identifier:experiments; 254, identifier:exp; 255, string:'timestamps'; 256, identifier:update; 257, argument_list; 257, 258; 258, identifier:ts; 259, return_statement; 259, 260; 260, call; 260, 261; 260, 262; 261, identifier:Namespace; 262, argument_list; 262, 263; 263, dictionary_splat; 263, 264; 264, identifier:ret | def start(self, **kwargs):
ts = {}
ret = {}
info_parts = {'info', 'get-value', 'get_value'}
for cmd in self.commands:
parser_cmd = self.parser_commands.get(cmd, cmd)
if parser_cmd in kwargs or cmd in kwargs:
kws = kwargs.get(cmd, kwargs.get(parser_cmd))
if isinstance(kws, Namespace):
kws = vars(kws)
func = getattr(self, cmd or 'main')
ret[cmd] = func(**kws)
if cmd not in info_parts:
ts[cmd] = str(dt.datetime.now())
exp = self._experiment
project_parts = {'setup'}
projectname = self._projectname
if (projectname is not None and project_parts.intersection(ts) and
projectname in self.config.projects):
self.config.projects[projectname]['timestamps'].update(
{key: ts[key] for key in project_parts.intersection(ts)})
elif not ts:
self.no_modification = True
if exp is not None and exp in self.config.experiments:
projectname = self.projectname
try:
ts.update(self.config.projects[projectname]['timestamps'])
except KeyError:
pass
if not self.is_archived(exp):
self.config.experiments[exp]['timestamps'].update(ts)
return Namespace(**ret) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:app_main; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:experiment; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:last; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:new; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:verbose; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:verbosity_level; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:no_modification; 22, False; 23, default_parameter; 23, 24; 23, 25; 24, identifier:match; 25, False; 26, block; 26, 27; 26, 94; 26, 151; 26, 189; 26, 223; 27, if_statement; 27, 28; 27, 29; 28, identifier:match; 29, block; 29, 30; 29, 39; 29, 56; 29, 88; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:patt; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:re; 36, identifier:compile; 37, argument_list; 37, 38; 38, identifier:experiment; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:matches; 42, call; 42, 43; 42, 44; 43, identifier:list; 44, argument_list; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:filter; 47, argument_list; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:patt; 50, identifier:search; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:config; 55, identifier:experiments; 56, if_statement; 56, 57; 56, 63; 56, 73; 57, comparison_operator:>; 57, 58; 57, 62; 58, call; 58, 59; 58, 60; 59, identifier:len; 60, argument_list; 60, 61; 61, identifier:matches; 62, integer:1; 63, block; 63, 64; 64, raise_statement; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:ValueError; 67, argument_list; 67, 68; 68, binary_operator:%; 68, 69; 68, 70; 69, string:"Found multiple matches for %s: %s"; 70, tuple; 70, 71; 70, 72; 71, identifier:experiment; 72, identifier:matches; 73, elif_clause; 73, 74; 73, 80; 74, comparison_operator:==; 74, 75; 74, 79; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, identifier:matches; 79, integer:0; 80, block; 80, 81; 81, raise_statement; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:ValueError; 84, argument_list; 84, 85; 85, binary_operator:%; 85, 86; 85, 87; 86, string:"No experiment matches %s"; 87, identifier:experiment; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:experiment; 91, subscript; 91, 92; 91, 93; 92, identifier:matches; 93, integer:0; 94, if_statement; 94, 95; 94, 102; 94, 109; 94, 143; 95, boolean_operator:and; 95, 96; 95, 97; 96, identifier:last; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:config; 101, identifier:experiments; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:experiment; 108, None; 109, elif_clause; 109, 110; 109, 117; 110, boolean_operator:and; 110, 111; 110, 112; 111, identifier:new; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:config; 116, identifier:experiments; 117, block; 117, 118; 118, try_statement; 118, 119; 118, 133; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:experiment; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:utils; 128, identifier:get_next_name; 129, argument_list; 129, 130; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:experiment; 133, except_clause; 133, 134; 133, 135; 134, identifier:ValueError; 135, block; 135, 136; 136, raise_statement; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:ValueError; 139, argument_list; 139, 140; 140, concatenated_string; 140, 141; 140, 142; 141, string:"Could not estimate an experiment id! Please use the "; 142, string:"experiment argument to provide an id."; 143, else_clause; 143, 144; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:_experiment; 150, identifier:experiment; 151, if_statement; 151, 152; 151, 153; 151, 160; 152, identifier:verbose; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:verbose; 157, attribute; 157, 158; 157, 159; 158, identifier:logging; 159, identifier:DEBUG; 160, elif_clause; 160, 161; 160, 162; 161, identifier:verbosity_level; 162, block; 162, 163; 163, if_statement; 163, 164; 163, 171; 163, 180; 164, comparison_operator:in; 164, 165; 164, 166; 165, identifier:verbosity_level; 166, list:['DEBUG', 'INFO', 'WARNING', 'ERROR']; 166, 167; 166, 168; 166, 169; 166, 170; 167, string:'DEBUG'; 168, string:'INFO'; 169, string:'WARNING'; 170, string:'ERROR'; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:verbose; 175, call; 175, 176; 175, 177; 176, identifier:getattr; 177, argument_list; 177, 178; 177, 179; 178, identifier:logging; 179, identifier:verbosity_level; 180, else_clause; 180, 181; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:verbose; 185, call; 185, 186; 185, 187; 186, identifier:int; 187, argument_list; 187, 188; 188, identifier:verbosity_level; 189, if_statement; 189, 190; 189, 191; 190, identifier:verbose; 191, block; 191, 192; 191, 214; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 212; 194, attribute; 194, 195; 194, 211; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:logging; 198, identifier:getLogger; 199, argument_list; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:utils; 203, identifier:get_toplevel_module; 204, argument_list; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:inspect; 208, identifier:getmodule; 209, argument_list; 209, 210; 210, identifier:self; 211, identifier:setLevel; 212, argument_list; 212, 213; 213, identifier:verbose; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 221; 216, attribute; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:self; 219, identifier:logger; 220, identifier:setLevel; 221, argument_list; 221, 222; 222, identifier:verbose; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:no_modification; 228, identifier:no_modification | def app_main(self, experiment=None, last=False, new=False,
verbose=False, verbosity_level=None, no_modification=False,
match=False):
if match:
patt = re.compile(experiment)
matches = list(filter(patt.search, self.config.experiments))
if len(matches) > 1:
raise ValueError("Found multiple matches for %s: %s" % (
experiment, matches))
elif len(matches) == 0:
raise ValueError("No experiment matches %s" % experiment)
experiment = matches[0]
if last and self.config.experiments:
self.experiment = None
elif new and self.config.experiments:
try:
self.experiment = utils.get_next_name(self.experiment)
except ValueError:
raise ValueError(
"Could not estimate an experiment id! Please use the "
"experiment argument to provide an id.")
else:
self._experiment = experiment
if verbose:
verbose = logging.DEBUG
elif verbosity_level:
if verbosity_level in ['DEBUG', 'INFO', 'WARNING', 'ERROR']:
verbose = getattr(logging, verbosity_level)
else:
verbose = int(verbosity_level)
if verbose:
logging.getLogger(
utils.get_toplevel_module(inspect.getmodule(self))).setLevel(
verbose)
self.logger.setLevel(verbose)
self.no_modification = no_modification |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 28; 2, function_name:configure; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:global_config; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:project_config; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ifile; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:forcing; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:serial; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:nprocs; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:update_from; 25, None; 26, dictionary_splat_pattern; 26, 27; 27, identifier:kwargs; 28, block; 28, 29; 28, 77; 28, 93; 28, 109; 28, 137; 28, 145; 29, if_statement; 29, 30; 29, 31; 29, 40; 29, 63; 30, identifier:global_config; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:d; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:config; 39, identifier:global_config; 40, elif_clause; 40, 41; 40, 42; 41, identifier:project_config; 42, block; 42, 43; 42, 51; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:app_main; 48, argument_list; 48, 49; 49, dictionary_splat; 49, 50; 50, identifier:kwargs; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:d; 54, subscript; 54, 55; 54, 60; 55, attribute; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:config; 59, identifier:projects; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:projectname; 63, else_clause; 63, 64; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:d; 68, subscript; 68, 69; 68, 74; 69, attribute; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:config; 73, identifier:experiments; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:experiment; 77, if_statement; 77, 78; 77, 81; 78, comparison_operator:is; 78, 79; 78, 80; 79, identifier:ifile; 80, None; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:d; 86, string:'input'; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:osp; 90, identifier:abspath; 91, argument_list; 91, 92; 92, identifier:ifile; 93, if_statement; 93, 94; 93, 97; 94, comparison_operator:is; 94, 95; 94, 96; 95, identifier:forcing; 96, None; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:d; 102, string:'forcing'; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:osp; 106, identifier:abspath; 107, argument_list; 107, 108; 108, identifier:forcing; 109, if_statement; 109, 110; 109, 113; 110, comparison_operator:is; 110, 111; 110, 112; 111, identifier:update_from; 112, None; 113, block; 113, 114; 114, with_statement; 114, 115; 114, 124; 115, with_clause; 115, 116; 116, with_item; 116, 117; 117, as_pattern; 117, 118; 117, 122; 118, call; 118, 119; 118, 120; 119, identifier:open; 120, argument_list; 120, 121; 121, string:'update_from'; 122, as_pattern_target; 122, 123; 123, identifier:f; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:d; 129, identifier:update; 130, argument_list; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:yaml; 134, identifier:load; 135, argument_list; 135, 136; 136, identifier:f; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:global_config; 140, attribute; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:config; 144, identifier:global_config; 145, if_statement; 145, 146; 145, 147; 145, 154; 146, identifier:serial; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 153; 150, subscript; 150, 151; 150, 152; 151, identifier:global_config; 152, string:'serial'; 153, True; 154, elif_clause; 154, 155; 154, 156; 155, identifier:nprocs; 156, block; 156, 157; 156, 169; 156, 175; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:nprocs; 160, conditional_expression:if; 160, 161; 160, 165; 160, 168; 161, call; 161, 162; 161, 163; 162, identifier:int; 163, argument_list; 163, 164; 164, identifier:nprocs; 165, comparison_operator:!=; 165, 166; 165, 167; 166, identifier:nprocs; 167, string:'all'; 168, identifier:nprocs; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 174; 171, subscript; 171, 172; 171, 173; 172, identifier:global_config; 173, string:'serial'; 174, False; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 180; 177, subscript; 177, 178; 177, 179; 178, identifier:global_config; 179, string:'nprocs'; 180, identifier:nprocs | def configure(self, global_config=False, project_config=False, ifile=None,
forcing=None, serial=False, nprocs=None, update_from=None,
**kwargs):
if global_config:
d = self.config.global_config
elif project_config:
self.app_main(**kwargs)
d = self.config.projects[self.projectname]
else:
d = self.config.experiments[self.experiment]
if ifile is not None:
d['input'] = osp.abspath(ifile)
if forcing is not None:
d['forcing'] = osp.abspath(forcing)
if update_from is not None:
with open('update_from') as f:
d.update(yaml.load(f))
global_config = self.config.global_config
if serial:
global_config['serial'] = True
elif nprocs:
nprocs = int(nprocs) if nprocs != 'all' else nprocs
global_config['serial'] = False
global_config['nprocs'] = nprocs |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:generate_basic_type_docs; 3, parameters; 3, 4; 3, 5; 4, identifier:fields; 5, identifier:existing_types; 6, block; 6, 7; 6, 133; 6, 137; 6, 325; 6, 347; 6, 354; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:raml_built_in_types; 10, dictionary; 10, 11; 10, 17; 10, 23; 10, 33; 10, 39; 10, 49; 10, 55; 10, 65; 10, 77; 10, 83; 10, 89; 10, 99; 10, 105; 10, 111; 10, 117; 10, 123; 11, pair; 11, 12; 11, 13; 12, string:"any"; 13, dictionary; 13, 14; 14, pair; 14, 15; 14, 16; 15, string:"parent"; 16, None; 17, pair; 17, 18; 17, 19; 18, string:"time-only"; 19, dictionary; 19, 20; 20, pair; 20, 21; 20, 22; 21, string:"parent"; 22, string:"any"; 23, pair; 23, 24; 23, 25; 24, string:"datetime"; 25, dictionary; 25, 26; 25, 29; 26, pair; 26, 27; 26, 28; 27, string:"parent"; 28, string:"any"; 29, pair; 29, 30; 29, 31; 30, string:"pale_children"; 31, list:["timestamp"]; 31, 32; 32, string:"timestamp"; 33, pair; 33, 34; 33, 35; 34, string:"datetime-only"; 35, dictionary; 35, 36; 36, pair; 36, 37; 36, 38; 37, string:"parent"; 38, string:"any"; 39, pair; 39, 40; 39, 41; 40, string:"date-only"; 41, dictionary; 41, 42; 41, 45; 42, pair; 42, 43; 42, 44; 43, string:"parent"; 44, string:"any"; 45, pair; 45, 46; 45, 47; 46, string:"pale_children"; 47, list:["date"]; 47, 48; 48, string:"date"; 49, pair; 49, 50; 49, 51; 50, string:"number"; 51, dictionary; 51, 52; 52, pair; 52, 53; 52, 54; 53, string:"parent"; 54, string:"any"; 55, pair; 55, 56; 55, 57; 56, string:"boolean"; 57, dictionary; 57, 58; 57, 61; 58, pair; 58, 59; 58, 60; 59, string:"parent"; 60, string:"any"; 61, pair; 61, 62; 61, 63; 62, string:"pale_children"; 63, list:["boolean"]; 63, 64; 64, string:"boolean"; 65, pair; 65, 66; 65, 67; 66, string:"string"; 67, dictionary; 67, 68; 67, 71; 68, pair; 68, 69; 68, 70; 69, string:"parent"; 70, string:"any"; 71, pair; 71, 72; 71, 73; 72, string:"pale_children"; 73, list:["url", "string", "uri"]; 73, 74; 73, 75; 73, 76; 74, string:"url"; 75, string:"string"; 76, string:"uri"; 77, pair; 77, 78; 77, 79; 78, string:"null"; 79, dictionary; 79, 80; 80, pair; 80, 81; 80, 82; 81, string:"parent"; 82, string:"any"; 83, pair; 83, 84; 83, 85; 84, string:"file"; 85, dictionary; 85, 86; 86, pair; 86, 87; 86, 88; 87, string:"parent"; 88, string:"any"; 89, pair; 89, 90; 89, 91; 90, string:"array"; 91, dictionary; 91, 92; 91, 95; 92, pair; 92, 93; 92, 94; 93, string:"parent"; 94, string:"any"; 95, pair; 95, 96; 95, 97; 96, string:"pale_children"; 97, list:["list"]; 97, 98; 98, string:"list"; 99, pair; 99, 100; 99, 101; 100, string:"object"; 101, dictionary; 101, 102; 102, pair; 102, 103; 102, 104; 103, string:"parent"; 104, string:"any"; 105, pair; 105, 106; 105, 107; 106, string:"union"; 107, dictionary; 107, 108; 108, pair; 108, 109; 108, 110; 109, string:"parent"; 110, string:"any"; 111, pair; 111, 112; 111, 113; 112, string:"XSD Schema"; 113, dictionary; 113, 114; 114, pair; 114, 115; 114, 116; 115, string:"parent"; 116, string:"any"; 117, pair; 117, 118; 117, 119; 118, string:"JSON Schema"; 119, dictionary; 119, 120; 120, pair; 120, 121; 120, 122; 121, string:"parent"; 122, string:"any"; 123, pair; 123, 124; 123, 125; 124, string:"integer"; 125, dictionary; 125, 126; 125, 129; 126, pair; 126, 127; 126, 128; 127, string:"parent"; 128, string:"number"; 129, pair; 129, 130; 129, 131; 130, string:"pale_children"; 131, list:["integer"]; 131, 132; 132, string:"integer"; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:basic_types; 136, dictionary; 137, for_statement; 137, 138; 137, 139; 137, 140; 138, identifier:field; 139, identifier:fields; 140, block; 140, 141; 141, if_statement; 141, 142; 141, 147; 142, call; 142, 143; 142, 144; 143, identifier:hasattr; 144, argument_list; 144, 145; 144, 146; 145, identifier:field; 146, string:"value_type"; 147, block; 147, 148; 147, 160; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:type_name; 151, call; 151, 152; 151, 157; 152, attribute; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:field; 155, identifier:value_type; 156, identifier:replace; 157, argument_list; 157, 158; 157, 159; 158, string:" "; 159, string:"_"; 160, if_statement; 160, 161; 160, 174; 161, boolean_operator:and; 161, 162; 161, 170; 161, 171; 162, boolean_operator:and; 162, 163; 162, 166; 162, 167; 163, comparison_operator:not; 163, 164; 163, 165; 164, identifier:type_name; 165, identifier:raml_built_in_types; 166, line_continuation:\; 167, comparison_operator:not; 167, 168; 167, 169; 168, identifier:type_name; 169, identifier:basic_types; 170, line_continuation:\; 171, comparison_operator:not; 171, 172; 171, 173; 172, identifier:type_name; 173, identifier:existing_types; 174, block; 174, 175; 174, 181; 174, 205; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 180; 177, subscript; 177, 178; 177, 179; 178, identifier:basic_types; 179, identifier:type_name; 180, dictionary; 181, if_statement; 181, 182; 181, 187; 182, call; 182, 183; 182, 184; 183, identifier:hasattr; 184, argument_list; 184, 185; 184, 186; 185, identifier:field; 186, string:"__doc__"; 187, block; 187, 188; 187, 197; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:modified_description; 191, call; 191, 192; 191, 193; 192, identifier:clean_description; 193, argument_list; 193, 194; 194, attribute; 194, 195; 194, 196; 195, identifier:field; 196, identifier:__doc__; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 204; 199, subscript; 199, 200; 199, 203; 200, subscript; 200, 201; 200, 202; 201, identifier:basic_types; 202, identifier:type_name; 203, string:"description"; 204, identifier:modified_description; 205, for_statement; 205, 206; 205, 207; 205, 208; 206, identifier:raml_type; 207, identifier:raml_built_in_types; 208, block; 208, 209; 209, if_statement; 209, 210; 209, 215; 209, 234; 210, comparison_operator:in; 210, 211; 210, 212; 211, string:"pale_children"; 212, subscript; 212, 213; 212, 214; 213, identifier:raml_built_in_types; 214, identifier:raml_type; 215, block; 215, 216; 216, if_statement; 216, 217; 216, 224; 217, comparison_operator:in; 217, 218; 217, 219; 218, identifier:type_name; 219, subscript; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:raml_built_in_types; 222, identifier:raml_type; 223, string:"pale_children"; 224, block; 224, 225; 224, 233; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 232; 227, subscript; 227, 228; 227, 231; 228, subscript; 228, 229; 228, 230; 229, identifier:basic_types; 230, identifier:type_name; 231, string:"type"; 232, identifier:raml_type; 233, break_statement; 234, else_clause; 234, 235; 235, block; 235, 236; 236, if_statement; 236, 237; 236, 246; 236, 288; 237, boolean_operator:and; 237, 238; 237, 243; 238, call; 238, 239; 238, 240; 239, identifier:hasattr; 240, argument_list; 240, 241; 240, 242; 241, identifier:field; 242, string:"is_list"; 243, attribute; 243, 244; 243, 245; 244, identifier:field; 245, identifier:is_list; 246, block; 246, 247; 246, 255; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 254; 249, subscript; 249, 250; 249, 253; 250, subscript; 250, 251; 250, 252; 251, identifier:basic_types; 252, identifier:type_name; 253, string:"type"; 254, string:"array"; 255, if_statement; 255, 256; 255, 267; 255, 278; 256, boolean_operator:and; 256, 257; 256, 262; 257, call; 257, 258; 257, 259; 258, identifier:hasattr; 259, argument_list; 259, 260; 259, 261; 260, identifier:field; 261, string:"list_item_type"; 262, comparison_operator:!=; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:field; 265, identifier:list_item_type; 266, None; 267, block; 267, 268; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 275; 270, subscript; 270, 271; 270, 274; 271, subscript; 271, 272; 271, 273; 272, identifier:basic_types; 273, identifier:type_name; 274, string:"items"; 275, attribute; 275, 276; 275, 277; 276, identifier:field; 277, identifier:list_item_type; 278, else_clause; 278, 279; 279, block; 279, 280; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 287; 282, subscript; 282, 283; 282, 286; 283, subscript; 283, 284; 283, 285; 284, identifier:basic_types; 285, identifier:type_name; 286, string:"items"; 287, string:"base"; 288, else_clause; 288, 289; 289, block; 289, 290; 289, 298; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:pale_parent_class; 293, subscript; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:field; 296, identifier:__mro__; 297, integer:1; 298, if_statement; 298, 299; 298, 304; 298, 313; 299, comparison_operator:==; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:pale_parent_class; 302, identifier:__name__; 303, string:"object"; 304, block; 304, 305; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 312; 307, subscript; 307, 308; 307, 311; 308, subscript; 308, 309; 308, 310; 309, identifier:basic_types; 310, identifier:type_name; 311, string:"type"; 312, string:"object"; 313, else_clause; 313, 314; 314, block; 314, 315; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 322; 317, subscript; 317, 318; 317, 321; 318, subscript; 318, 319; 318, 320; 319, identifier:basic_types; 320, identifier:type_name; 321, string:"type"; 322, attribute; 322, 323; 322, 324; 323, identifier:pale_parent_class; 324, identifier:value_type; 325, expression_statement; 325, 326; 326, assignment; 326, 327; 326, 328; 327, identifier:ordered_basic_types; 328, call; 328, 329; 328, 330; 329, identifier:OrderedDict; 330, argument_list; 330, 331; 331, call; 331, 332; 331, 333; 332, identifier:sorted; 333, argument_list; 333, 334; 333, 339; 334, call; 334, 335; 334, 338; 335, attribute; 335, 336; 335, 337; 336, identifier:basic_types; 337, identifier:items; 338, argument_list; 339, keyword_argument; 339, 340; 339, 341; 340, identifier:key; 341, lambda; 341, 342; 341, 344; 342, lambda_parameters; 342, 343; 343, identifier:t; 344, subscript; 344, 345; 344, 346; 345, identifier:t; 346, integer:0; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 350; 349, identifier:basic_docs; 350, call; 350, 351; 350, 352; 351, identifier:generate_type_docs; 352, argument_list; 352, 353; 353, identifier:ordered_basic_types; 354, return_statement; 354, 355; 355, tuple; 355, 356; 355, 357; 356, identifier:basic_docs; 357, identifier:basic_types | def generate_basic_type_docs(fields, existing_types):
raml_built_in_types = {
"any": {
"parent": None,
},
"time-only": {
"parent": "any",
},
"datetime": {
"parent": "any",
"pale_children": ["timestamp"],
},
"datetime-only": {
"parent": "any",
},
"date-only": {
"parent": "any",
"pale_children": ["date"],
},
"number": {
"parent": "any",
},
"boolean": {
"parent": "any",
"pale_children": ["boolean"]
},
"string": {
"parent": "any",
"pale_children": ["url", "string", "uri"],
},
"null": {
"parent": "any",
},
"file": {
"parent": "any",
},
"array": {
"parent": "any",
"pale_children": ["list"],
},
"object": {
"parent": "any",
},
"union": {
"parent": "any",
},
"XSD Schema": {
"parent": "any",
},
"JSON Schema": {
"parent": "any",
},
"integer": {
"parent": "number",
"pale_children": ["integer"],
},
}
basic_types = {}
for field in fields:
if hasattr(field, "value_type"):
type_name = field.value_type.replace(" ", "_")
if type_name not in raml_built_in_types \
and type_name not in basic_types \
and type_name not in existing_types:
basic_types[type_name] = {}
if hasattr(field, "__doc__"):
modified_description = clean_description(field.__doc__)
basic_types[type_name]["description"] = modified_description
for raml_type in raml_built_in_types:
if "pale_children" in raml_built_in_types[raml_type]:
if type_name in raml_built_in_types[raml_type]["pale_children"]:
basic_types[type_name]["type"] = raml_type
break
else:
if hasattr(field, "is_list") and field.is_list:
basic_types[type_name]["type"] = "array"
if hasattr(field, "list_item_type") and field.list_item_type != None:
basic_types[type_name]["items"] = field.list_item_type
else:
basic_types[type_name]["items"] = "base"
else:
pale_parent_class = field.__mro__[1]
if pale_parent_class.__name__ == "object":
basic_types[type_name]["type"] = "object"
else:
basic_types[type_name]["type"] = pale_parent_class.value_type
ordered_basic_types = OrderedDict(sorted(basic_types.items(), key=lambda t: t[0]))
basic_docs = generate_type_docs(ordered_basic_types)
return (basic_docs, basic_types) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:generate_doc_dict; 3, parameters; 3, 4; 3, 5; 4, identifier:module; 5, identifier:user; 6, block; 6, 7; 6, 16; 6, 27; 6, 34; 6, 50; 6, 54; 6, 98; 6, 105; 6, 121; 7, import_from_statement; 7, 8; 7, 10; 7, 12; 7, 14; 8, dotted_name; 8, 9; 9, identifier:pale; 10, dotted_name; 10, 11; 11, identifier:extract_endpoints; 12, dotted_name; 12, 13; 13, identifier:extract_resources; 14, dotted_name; 14, 15; 15, identifier:is_pale_module; 16, if_statement; 16, 17; 16, 22; 17, not_operator; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:is_pale_module; 20, argument_list; 20, 21; 21, identifier:module; 22, block; 22, 23; 23, raise_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:ValueError; 26, argument_list; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:module_endpoints; 30, call; 30, 31; 30, 32; 31, identifier:extract_endpoints; 32, argument_list; 32, 33; 33, identifier:module; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:ep_doc; 37, dictionary_comprehension; 37, 38; 37, 46; 38, pair; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:ep; 41, identifier:_route_name; 42, call; 42, 43; 42, 44; 43, identifier:document_endpoint; 44, argument_list; 44, 45; 45, identifier:ep; 46, for_in_clause; 46, 47; 46, 48; 46, 49; 47, identifier:ep; 48, line_continuation:\; 49, identifier:module_endpoints; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:ep_doc_filtered; 53, dictionary; 54, for_statement; 54, 55; 54, 56; 54, 57; 55, identifier:endpoint; 56, identifier:ep_doc; 57, block; 57, 58; 58, if_statement; 58, 59; 58, 89; 59, boolean_operator:or; 59, 60; 59, 78; 59, 79; 60, boolean_operator:and; 60, 61; 60, 75; 61, boolean_operator:and; 61, 62; 61, 72; 62, comparison_operator:!=; 62, 63; 62, 71; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:ep_doc; 67, identifier:endpoint; 68, identifier:get; 69, argument_list; 69, 70; 70, string:"requires_permission"; 71, None; 72, comparison_operator:!=; 72, 73; 72, 74; 73, identifier:user; 74, None; 75, attribute; 75, 76; 75, 77; 76, identifier:user; 77, identifier:is_admin; 78, line_continuation:\; 79, comparison_operator:==; 79, 80; 79, 88; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, subscript; 82, 83; 82, 84; 83, identifier:ep_doc; 84, identifier:endpoint; 85, identifier:get; 86, argument_list; 86, 87; 87, string:"requires_permission"; 88, None; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 95; 92, subscript; 92, 93; 92, 94; 93, identifier:ep_doc_filtered; 94, identifier:endpoint; 95, subscript; 95, 96; 95, 97; 96, identifier:ep_doc; 97, identifier:endpoint; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:module_resources; 101, call; 101, 102; 101, 103; 102, identifier:extract_resources; 103, argument_list; 103, 104; 104, identifier:module; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:res_doc; 108, dictionary_comprehension; 108, 109; 108, 117; 109, pair; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:r; 112, identifier:_value_type; 113, call; 113, 114; 113, 115; 114, identifier:document_resource; 115, argument_list; 115, 116; 116, identifier:r; 117, for_in_clause; 117, 118; 117, 119; 117, 120; 118, identifier:r; 119, line_continuation:\; 120, identifier:module_resources; 121, return_statement; 121, 122; 122, dictionary; 122, 123; 122, 126; 123, pair; 123, 124; 123, 125; 124, string:'endpoints'; 125, identifier:ep_doc_filtered; 126, pair; 126, 127; 126, 128; 127, string:'resources'; 128, identifier:res_doc | def generate_doc_dict(module, user):
from pale import extract_endpoints, extract_resources, is_pale_module
if not is_pale_module(module):
raise ValueError(
)
module_endpoints = extract_endpoints(module)
ep_doc = { ep._route_name: document_endpoint(ep) for ep \
in module_endpoints }
ep_doc_filtered = {}
for endpoint in ep_doc:
if ep_doc[endpoint].get("requires_permission") != None and user != None and user.is_admin or \
ep_doc[endpoint].get("requires_permission") == None:
ep_doc_filtered[endpoint] = ep_doc[endpoint]
module_resources = extract_resources(module)
res_doc = { r._value_type: document_resource(r) for r \
in module_resources }
return {'endpoints': ep_doc_filtered,
'resources': res_doc} |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_driver; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:desired_capabilities; 7, None; 8, block; 8, 9; 8, 15; 8, 26; 8, 33; 8, 41; 8, 45; 8, 333; 8, 371; 8, 380; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:override_caps; 12, boolean_operator:or; 12, 13; 12, 14; 13, identifier:desired_capabilities; 14, dictionary; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 16, 19; 17, identifier:desired_capabilities; 18, line_continuation:\; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:config; 24, identifier:make_selenium_desired_capabilities; 25, argument_list; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:desired_capabilities; 30, identifier:update; 31, argument_list; 31, 32; 32, identifier:override_caps; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:browser_string; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:config; 40, identifier:browser; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:chromedriver_version; 44, None; 45, if_statement; 45, 46; 45, 49; 45, 100; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:remote; 49, block; 49, 50; 49, 61; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:driver; 53, call; 53, 54; 53, 59; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:remote_service; 58, identifier:build_driver; 59, argument_list; 59, 60; 60, identifier:desired_capabilities; 61, if_statement; 61, 62; 61, 74; 62, boolean_operator:and; 62, 63; 62, 66; 62, 67; 63, comparison_operator:==; 63, 64; 63, 65; 64, identifier:browser_string; 65, string:"CHROME"; 66, line_continuation:\; 67, comparison_operator:==; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:remote_service; 72, identifier:name; 73, string:"saucelabs"; 74, block; 74, 75; 74, 86; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 76, 79; 77, identifier:chromedriver_version; 78, line_continuation:\; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:desired_capabilities; 82, identifier:get; 83, argument_list; 83, 84; 83, 85; 84, string:"chromedriver-version"; 85, None; 86, if_statement; 86, 87; 86, 90; 87, comparison_operator:is; 87, 88; 87, 89; 88, identifier:chromedriver_version; 89, None; 90, block; 90, 91; 91, raise_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:ValueError; 94, argument_list; 94, 95; 95, concatenated_string; 95, 96; 95, 97; 95, 98; 95, 99; 96, string:"when using Chrome, you must set a "; 97, string:"``chromedriver-version`` capability so that Selenic "; 98, string:"can detect which version of Chromedriver will "; 99, string:"be used."; 100, else_clause; 100, 101; 101, block; 101, 102; 101, 272; 101, 281; 101, 295; 101, 317; 102, if_statement; 102, 103; 102, 106; 102, 187; 102, 237; 102, 250; 102, 263; 103, comparison_operator:==; 103, 104; 103, 105; 104, identifier:browser_string; 105, string:"CHROME"; 106, block; 106, 107; 106, 115; 106, 154; 106, 165; 106, 180; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:chromedriver_path; 110, subscript; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:local_conf; 114, string:"CHROMEDRIVER_PATH"; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:driver; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:webdriver; 121, identifier:Chrome; 122, argument_list; 122, 123; 122, 124; 122, 134; 122, 137; 122, 144; 123, identifier:chromedriver_path; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:chrome_options; 126, call; 126, 127; 126, 132; 127, attribute; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:local_conf; 131, identifier:get; 132, argument_list; 132, 133; 133, string:"CHROME_OPTIONS"; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:desired_capabilities; 136, identifier:desired_capabilities; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:service_log_path; 139, subscript; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:self; 142, identifier:local_conf; 143, string:"SERVICE_LOG_PATH"; 144, keyword_argument; 144, 145; 144, 146; 145, identifier:service_args; 146, call; 146, 147; 146, 152; 147, attribute; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:local_conf; 151, identifier:get; 152, argument_list; 152, 153; 153, string:"SERVICE_ARGS"; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:version_line; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:subprocess; 160, identifier:check_output; 161, argument_list; 161, 162; 162, list:[chromedriver_path, "--version"]; 162, 163; 162, 164; 163, identifier:chromedriver_path; 164, string:"--version"; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:version_str; 168, call; 168, 169; 168, 178; 169, attribute; 169, 170; 169, 177; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:re; 173, identifier:match; 174, argument_list; 174, 175; 174, 176; 175, string:ur"^ChromeDriver (\d+\.\d+)"; 176, identifier:version_line; 177, identifier:group; 178, argument_list; 178, 179; 179, integer:1; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:chromedriver_version; 183, call; 183, 184; 183, 185; 184, identifier:StrictVersion; 185, argument_list; 185, 186; 186, identifier:version_str; 187, elif_clause; 187, 188; 187, 191; 188, comparison_operator:==; 188, 189; 188, 190; 189, identifier:browser_string; 190, string:"FIREFOX"; 191, block; 191, 192; 191, 208; 191, 224; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:profile; 195, boolean_operator:or; 195, 196; 195, 204; 195, 205; 196, call; 196, 197; 196, 202; 197, attribute; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:local_conf; 201, identifier:get; 202, argument_list; 202, 203; 203, string:"FIREFOX_PROFILE"; 204, line_continuation:\; 205, call; 205, 206; 205, 207; 206, identifier:FirefoxProfile; 207, argument_list; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:binary; 211, boolean_operator:or; 211, 212; 211, 220; 211, 221; 212, call; 212, 213; 212, 218; 213, attribute; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:local_conf; 217, identifier:get; 218, argument_list; 218, 219; 219, string:"FIREFOX_BINARY"; 220, line_continuation:\; 221, call; 221, 222; 221, 223; 222, identifier:FirefoxBinary; 223, argument_list; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:driver; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:webdriver; 230, identifier:Firefox; 231, argument_list; 231, 232; 231, 233; 231, 234; 232, identifier:profile; 233, identifier:binary; 234, keyword_argument; 234, 235; 234, 236; 235, identifier:capabilities; 236, identifier:desired_capabilities; 237, elif_clause; 237, 238; 237, 241; 238, comparison_operator:==; 238, 239; 238, 240; 239, identifier:browser_string; 240, string:"INTERNETEXPLORER"; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:driver; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:webdriver; 248, identifier:Ie; 249, argument_list; 250, elif_clause; 250, 251; 250, 254; 251, comparison_operator:==; 251, 252; 251, 253; 252, identifier:browser_string; 253, string:"OPERA"; 254, block; 254, 255; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:driver; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:webdriver; 261, identifier:Opera; 262, argument_list; 263, else_clause; 263, 264; 264, block; 264, 265; 265, raise_statement; 265, 266; 266, call; 266, 267; 266, 268; 267, identifier:ValueError; 268, argument_list; 268, 269; 269, binary_operator:+; 269, 270; 269, 271; 270, string:"can't start a local "; 271, identifier:browser_string; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:driver_caps; 275, call; 275, 276; 275, 277; 276, identifier:NormalizedCapabilities; 277, argument_list; 277, 278; 278, attribute; 278, 279; 278, 280; 279, identifier:driver; 280, identifier:desired_capabilities; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 282, 285; 283, identifier:browser_version; 284, line_continuation:\; 285, call; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:re; 288, identifier:sub; 289, argument_list; 289, 290; 289, 291; 289, 292; 290, string:r"\..*$"; 291, string:""; 292, subscript; 292, 293; 292, 294; 293, identifier:driver_caps; 294, string:"browserVersion"; 295, if_statement; 295, 296; 295, 309; 296, comparison_operator:!=; 296, 297; 296, 304; 297, call; 297, 298; 297, 303; 298, attribute; 298, 299; 298, 302; 299, subscript; 299, 300; 299, 301; 300, identifier:driver_caps; 301, string:"platformName"; 302, identifier:upper; 303, argument_list; 304, attribute; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:self; 307, identifier:config; 308, identifier:platform; 309, block; 309, 310; 310, raise_statement; 310, 311; 311, call; 311, 312; 311, 313; 312, identifier:ValueError; 313, argument_list; 313, 314; 314, concatenated_string; 314, 315; 314, 316; 315, string:"the platform you want is not the one "; 316, string:"you are running selenic on"; 317, if_statement; 317, 318; 317, 325; 318, comparison_operator:!=; 318, 319; 318, 320; 319, identifier:browser_version; 320, attribute; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:self; 323, identifier:config; 324, identifier:version; 325, block; 325, 326; 326, raise_statement; 326, 327; 327, call; 327, 328; 327, 329; 328, identifier:ValueError; 329, argument_list; 329, 330; 330, concatenated_string; 330, 331; 330, 332; 331, string:"the version installed is not the one "; 332, string:"you wanted"; 333, if_statement; 333, 334; 333, 359; 334, boolean_operator:or; 334, 335; 334, 347; 334, 348; 335, parenthesized_expression; 335, 336; 336, boolean_operator:and; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:self; 339, identifier:remote_service; 340, comparison_operator:==; 340, 341; 340, 346; 341, attribute; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, identifier:self; 344, identifier:remote_service; 345, identifier:name; 346, string:"browserstack"; 347, line_continuation:\; 348, parenthesized_expression; 348, 349; 349, boolean_operator:and; 349, 350; 349, 353; 350, comparison_operator:is; 350, 351; 350, 352; 351, identifier:chromedriver_version; 352, None; 353, comparison_operator:>; 353, 354; 353, 355; 354, identifier:chromedriver_version; 355, call; 355, 356; 355, 357; 356, identifier:StrictVersion; 357, argument_list; 357, 358; 358, string:"2.13"; 359, block; 359, 360; 359, 364; 360, expression_statement; 360, 361; 361, call; 361, 362; 361, 363; 362, identifier:chromedriver_element_center_patch; 363, argument_list; 364, expression_statement; 364, 365; 365, call; 365, 366; 365, 367; 366, identifier:setattr; 367, argument_list; 367, 368; 367, 369; 367, 370; 368, identifier:driver; 369, identifier:CHROMEDRIVER_ELEMENT_CENTER_PATCH_FLAG; 370, True; 371, expression_statement; 371, 372; 372, assignment; 372, 373; 372, 374; 373, identifier:driver; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:self; 377, identifier:patch; 378, argument_list; 378, 379; 379, identifier:driver; 380, return_statement; 380, 381; 381, identifier:driver | def get_driver(self, desired_capabilities=None):
override_caps = desired_capabilities or {}
desired_capabilities = \
self.config.make_selenium_desired_capabilities()
desired_capabilities.update(override_caps)
browser_string = self.config.browser
chromedriver_version = None
if self.remote:
driver = self.remote_service.build_driver(desired_capabilities)
if browser_string == "CHROME" and \
self.remote_service.name == "saucelabs":
chromedriver_version = \
desired_capabilities.get("chromedriver-version", None)
if chromedriver_version is None:
raise ValueError(
"when using Chrome, you must set a "
"``chromedriver-version`` capability so that Selenic "
"can detect which version of Chromedriver will "
"be used.")
else:
if browser_string == "CHROME":
chromedriver_path = self.local_conf["CHROMEDRIVER_PATH"]
driver = webdriver.Chrome(
chromedriver_path,
chrome_options=self.local_conf.get("CHROME_OPTIONS"),
desired_capabilities=desired_capabilities,
service_log_path=self.local_conf["SERVICE_LOG_PATH"],
service_args=self.local_conf.get("SERVICE_ARGS"))
version_line = subprocess.check_output(
[chromedriver_path, "--version"])
version_str = re.match(ur"^ChromeDriver (\d+\.\d+)",
version_line).group(1)
chromedriver_version = StrictVersion(version_str)
elif browser_string == "FIREFOX":
profile = self.local_conf.get("FIREFOX_PROFILE") or \
FirefoxProfile()
binary = self.local_conf.get("FIREFOX_BINARY") or \
FirefoxBinary()
driver = webdriver.Firefox(profile, binary,
capabilities=desired_capabilities)
elif browser_string == "INTERNETEXPLORER":
driver = webdriver.Ie()
elif browser_string == "OPERA":
driver = webdriver.Opera()
else:
raise ValueError("can't start a local " + browser_string)
driver_caps = NormalizedCapabilities(driver.desired_capabilities)
browser_version = \
re.sub(r"\..*$", "", driver_caps["browserVersion"])
if driver_caps["platformName"].upper() != self.config.platform:
raise ValueError("the platform you want is not the one "
"you are running selenic on")
if browser_version != self.config.version:
raise ValueError("the version installed is not the one "
"you wanted")
if (self.remote_service and
self.remote_service.name == "browserstack") or \
(chromedriver_version is not None and
chromedriver_version > StrictVersion("2.13")):
chromedriver_element_center_patch()
setattr(driver, CHROMEDRIVER_ELEMENT_CENTER_PATCH_FLAG, True)
driver = self.patch(driver)
return driver |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:load; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:typedef; 6, identifier:value; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 10, try_statement; 10, 11; 10, 20; 10, 33; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:bound_type; 15, subscript; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:bound_types; 19, identifier:typedef; 20, except_clause; 20, 21; 20, 22; 21, identifier:KeyError; 22, block; 22, 23; 23, raise_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:DeclareException; 26, argument_list; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, string:"Can't load unknown type {}"; 30, identifier:format; 31, argument_list; 31, 32; 32, identifier:typedef; 33, else_clause; 33, 34; 34, block; 34, 35; 35, return_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:bound_type; 39, string:"load"; 40, argument_list; 40, 41; 40, 42; 41, identifier:value; 42, dictionary_splat; 42, 43; 43, identifier:kwargs | def load(self, typedef, value, **kwargs):
try:
bound_type = self.bound_types[typedef]
except KeyError:
raise DeclareException(
"Can't load unknown type {}".format(typedef))
else:
return bound_type["load"](value, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:qteSetLexer; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:lexer; 6, block; 6, 7; 6, 31; 6, 37; 6, 60; 7, if_statement; 7, 8; 7, 22; 8, boolean_operator:and; 8, 9; 8, 13; 9, parenthesized_expression; 9, 10; 10, comparison_operator:is; 10, 11; 10, 12; 11, identifier:lexer; 12, None; 13, parenthesized_expression; 13, 14; 14, not_operator; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:issubclass; 17, argument_list; 17, 18; 17, 19; 18, identifier:lexer; 19, attribute; 19, 20; 19, 21; 20, identifier:Qsci; 21, identifier:QsciLexer; 22, block; 22, 23; 22, 30; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:QtmacsOtherError; 26, argument_list; 26, 27; 27, concatenated_string; 27, 28; 27, 29; 28, string:'lexer must be a class object and derived from'; 29, string:' <b>QsciLexer</b>'; 30, return_statement; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:qteLastLexer; 36, identifier:lexer; 37, if_statement; 37, 38; 37, 41; 37, 49; 38, comparison_operator:is; 38, 39; 38, 40; 39, identifier:lexer; 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:self; 46, identifier:setLexer; 47, argument_list; 47, 48; 48, None; 49, else_clause; 49, 50; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:setLexer; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:lexer; 59, argument_list; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:setMonospace; 65, argument_list | def qteSetLexer(self, lexer):
if (lexer is not None) and (not issubclass(lexer, Qsci.QsciLexer)):
QtmacsOtherError('lexer must be a class object and derived from'
' <b>QsciLexer</b>')
return
self.qteLastLexer = lexer
if lexer is None:
self.setLexer(None)
else:
self.setLexer(lexer())
self.setMonospace() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:get_function_args; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:func; 5, default_parameter; 5, 6; 5, 7; 6, identifier:no_self; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:no_varargs; 10, False; 11, block; 11, 12; 11, 21; 11, 34; 11, 47; 11, 54; 11, 90; 11, 114; 11, 141; 11, 163; 11, 191; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:par_dict; 15, attribute; 15, 16; 15, 20; 16, call; 16, 17; 16, 18; 17, identifier:signature; 18, argument_list; 18, 19; 19, identifier:func; 20, identifier:parameters; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:pos; 24, lambda; 24, 25; 24, 27; 25, lambda_parameters; 25, 26; 26, identifier:x; 27, comparison_operator:==; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:x; 30, identifier:kind; 31, attribute; 31, 32; 31, 33; 32, identifier:Parameter; 33, identifier:VAR_POSITIONAL; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:kw; 37, lambda; 37, 38; 37, 40; 38, lambda_parameters; 38, 39; 39, identifier:x; 40, comparison_operator:==; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:x; 43, identifier:kind; 44, attribute; 44, 45; 44, 46; 45, identifier:Parameter; 46, identifier:VAR_KEYWORD; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:opts; 50, list:["", "*", "**"]; 50, 51; 50, 52; 50, 53; 51, string:""; 52, string:"*"; 53, string:"**"; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:args; 57, list_comprehension; 57, 58; 57, 81; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, string:"{prefix}{arg}"; 61, identifier:format; 62, argument_list; 62, 63; 62, 78; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:prefix; 65, subscript; 65, 66; 65, 67; 66, identifier:opts; 67, binary_operator:+; 67, 68; 67, 72; 68, call; 68, 69; 68, 70; 69, identifier:pos; 70, argument_list; 70, 71; 71, identifier:value; 72, binary_operator:*; 72, 73; 72, 74; 73, integer:2; 74, call; 74, 75; 74, 76; 75, identifier:kw; 76, argument_list; 76, 77; 77, identifier:value; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:arg; 80, identifier:par; 81, for_in_clause; 81, 82; 81, 85; 82, pattern_list; 82, 83; 82, 84; 83, identifier:par; 84, identifier:value; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:par_dict; 88, identifier:items; 89, argument_list; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:self_filtered_args; 93, parenthesized_expression; 93, 94; 94, conditional_expression:if; 94, 95; 94, 96; 94, 98; 95, identifier:args; 96, not_operator; 96, 97; 97, identifier:args; 98, parenthesized_expression; 98, 99; 99, subscript; 99, 100; 99, 101; 100, identifier:args; 101, slice; 101, 102; 101, 113; 102, conditional_expression:if; 102, 103; 102, 104; 102, 112; 103, integer:1; 104, boolean_operator:and; 104, 105; 104, 111; 105, parenthesized_expression; 105, 106; 106, comparison_operator:==; 106, 107; 106, 110; 107, subscript; 107, 108; 107, 109; 108, identifier:args; 109, integer:0; 110, string:"self"; 111, identifier:no_self; 112, integer:0; 113, colon; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:pos; 117, lambda; 117, 118; 117, 120; 118, lambda_parameters; 118, 119; 119, identifier:x; 120, boolean_operator:and; 120, 121; 120, 135; 121, boolean_operator:and; 121, 122; 121, 129; 122, parenthesized_expression; 122, 123; 123, comparison_operator:>; 123, 124; 123, 128; 124, call; 124, 125; 124, 126; 125, identifier:len; 126, argument_list; 126, 127; 127, identifier:x; 128, integer:1; 129, parenthesized_expression; 129, 130; 130, comparison_operator:==; 130, 131; 130, 134; 131, subscript; 131, 132; 131, 133; 132, identifier:x; 133, integer:0; 134, string:"*"; 135, parenthesized_expression; 135, 136; 136, comparison_operator:!=; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:x; 139, integer:1; 140, string:"*"; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:kw; 144, lambda; 144, 145; 144, 147; 145, lambda_parameters; 145, 146; 146, identifier:x; 147, boolean_operator:and; 147, 148; 147, 155; 148, parenthesized_expression; 148, 149; 149, comparison_operator:>; 149, 150; 149, 154; 150, call; 150, 151; 150, 152; 151, identifier:len; 152, argument_list; 152, 153; 153, identifier:x; 154, integer:2; 155, parenthesized_expression; 155, 156; 156, comparison_operator:==; 156, 157; 156, 162; 157, subscript; 157, 158; 157, 159; 158, identifier:x; 159, slice; 159, 160; 159, 161; 160, colon; 161, integer:2; 162, string:"**"; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:varargs_filtered_args; 166, list_comprehension; 166, 167; 166, 168; 166, 171; 167, identifier:arg; 168, for_in_clause; 168, 169; 168, 170; 169, identifier:arg; 170, identifier:self_filtered_args; 171, if_clause; 171, 172; 172, boolean_operator:or; 172, 173; 172, 176; 173, parenthesized_expression; 173, 174; 174, not_operator; 174, 175; 175, identifier:no_varargs; 176, call; 176, 177; 176, 178; 177, identifier:all; 178, argument_list; 178, 179; 179, list:[no_varargs, not pos(arg), not kw(arg)]; 179, 180; 179, 181; 179, 186; 180, identifier:no_varargs; 181, not_operator; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:pos; 184, argument_list; 184, 185; 185, identifier:arg; 186, not_operator; 186, 187; 187, call; 187, 188; 187, 189; 188, identifier:kw; 189, argument_list; 189, 190; 190, identifier:arg; 191, return_statement; 191, 192; 192, call; 192, 193; 192, 194; 193, identifier:tuple; 194, argument_list; 194, 195; 195, identifier:varargs_filtered_args | def get_function_args(func, no_self=False, no_varargs=False):
par_dict = signature(func).parameters
pos = lambda x: x.kind == Parameter.VAR_POSITIONAL
kw = lambda x: x.kind == Parameter.VAR_KEYWORD
opts = ["", "*", "**"]
args = [
"{prefix}{arg}".format(prefix=opts[pos(value) + 2 * kw(value)], arg=par)
for par, value in par_dict.items()
]
self_filtered_args = (
args if not args else (args[1 if (args[0] == "self") and no_self else 0 :])
)
pos = lambda x: (len(x) > 1) and (x[0] == "*") and (x[1] != "*")
kw = lambda x: (len(x) > 2) and (x[:2] == "**")
varargs_filtered_args = [
arg
for arg in self_filtered_args
if (not no_varargs) or all([no_varargs, not pos(arg), not kw(arg)])
]
return tuple(varargs_filtered_args) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_close_callable; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:node; 6, default_parameter; 6, 7; 6, 8; 7, identifier:force; 8, False; 9, block; 9, 10; 9, 22; 9, 30; 9, 31; 9, 35; 9, 81; 9, 90; 9, 95; 9, 96; 9, 100; 9, 221; 9, 227; 9, 236; 9, 252; 10, try_statement; 10, 11; 10, 18; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:lineno; 15, attribute; 15, 16; 15, 17; 16, identifier:node; 17, identifier:lineno; 18, except_clause; 18, 19; 18, 20; 19, identifier:AttributeError; 20, block; 20, 21; 21, return_statement; 22, if_statement; 22, 23; 22, 28; 23, comparison_operator:<=; 23, 24; 23, 25; 24, identifier:lineno; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_processed_line; 28, block; 28, 29; 29, return_statement; 30, comment; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:name; 34, string:""; 35, try_statement; 35, 36; 35, 77; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:name; 40, parenthesized_expression; 40, 41; 41, conditional_expression:if; 41, 42; 41, 45; 41, 50; 42, attribute; 42, 43; 42, 44; 43, identifier:node; 44, identifier:name; 45, call; 45, 46; 45, 47; 46, identifier:hasattr; 47, argument_list; 47, 48; 47, 49; 48, identifier:node; 49, string:"name"; 50, parenthesized_expression; 50, 51; 51, conditional_expression:if; 51, 52; 51, 59; 51, 68; 52, attribute; 52, 53; 52, 58; 53, subscript; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:node; 56, identifier:targets; 57, integer:0; 58, identifier:id; 59, call; 59, 60; 59, 61; 60, identifier:hasattr; 61, argument_list; 61, 62; 61, 67; 62, subscript; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:node; 65, identifier:targets; 66, integer:0; 67, string:"id"; 68, attribute; 68, 69; 68, 76; 69, attribute; 69, 70; 69, 75; 70, subscript; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:node; 73, identifier:targets; 74, integer:0; 75, identifier:value; 76, identifier:id; 77, except_clause; 77, 78; 77, 79; 78, identifier:AttributeError; 79, block; 79, 80; 80, pass_statement; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:indent; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:_get_indent; 88, argument_list; 88, 89; 89, identifier:node; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:count; 93, unary_operator:-; 93, 94; 94, integer:1; 95, comment; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:dlist; 99, list:[]; 100, while_statement; 100, 101; 100, 110; 101, comparison_operator:>=; 101, 102; 101, 103; 102, identifier:count; 103, unary_operator:-; 103, 104; 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:_indent_stack; 110, block; 110, 111; 110, 121; 110, 133; 110, 143; 110, 153; 110, 154; 110, 211; 110, 217; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:element_full_name; 114, subscript; 114, 115; 114, 120; 115, subscript; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:_indent_stack; 119, identifier:count; 120, string:"full_name"; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:edict; 124, call; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:_callables_db; 129, identifier:get; 130, argument_list; 130, 131; 130, 132; 131, identifier:element_full_name; 132, None; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:stack_indent; 136, subscript; 136, 137; 136, 142; 137, subscript; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:self; 140, identifier:_indent_stack; 141, identifier:count; 142, string:"level"; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:open_callable; 146, boolean_operator:and; 146, 147; 146, 148; 147, identifier:element_full_name; 148, parenthesized_expression; 148, 149; 149, not_operator; 149, 150; 150, subscript; 150, 151; 150, 152; 151, identifier:edict; 152, string:"last_lineno"; 153, comment; 154, if_statement; 154, 155; 154, 194; 154, 195; 155, boolean_operator:and; 155, 156; 155, 157; 156, identifier:open_callable; 157, parenthesized_expression; 157, 158; 158, boolean_operator:or; 158, 159; 158, 165; 159, boolean_operator:or; 159, 160; 159, 161; 160, identifier:force; 161, parenthesized_expression; 161, 162; 162, comparison_operator:<; 162, 163; 162, 164; 163, identifier:indent; 164, identifier:stack_indent; 165, parenthesized_expression; 165, 166; 166, boolean_operator:and; 166, 167; 166, 171; 167, parenthesized_expression; 167, 168; 168, comparison_operator:==; 168, 169; 168, 170; 169, identifier:indent; 170, identifier:stack_indent; 171, parenthesized_expression; 171, 172; 172, boolean_operator:or; 172, 173; 172, 179; 173, parenthesized_expression; 173, 174; 174, comparison_operator:!=; 174, 175; 174, 178; 175, subscript; 175, 176; 175, 177; 176, identifier:edict; 177, string:"type"; 178, string:"prop"; 179, parenthesized_expression; 179, 180; 180, boolean_operator:and; 180, 181; 180, 187; 181, parenthesized_expression; 181, 182; 182, comparison_operator:==; 182, 183; 182, 186; 183, subscript; 183, 184; 183, 185; 184, identifier:edict; 185, string:"type"; 186, string:"prop"; 187, parenthesized_expression; 187, 188; 188, boolean_operator:and; 188, 189; 188, 190; 189, identifier:name; 190, parenthesized_expression; 190, 191; 191, comparison_operator:!=; 191, 192; 191, 193; 192, identifier:name; 193, identifier:element_full_name; 194, comment; 195, block; 195, 196; 195, 204; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:edict; 200, string:"last_lineno"; 201, binary_operator:-; 201, 202; 201, 203; 202, identifier:lineno; 203, integer:1; 204, expression_statement; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:dlist; 208, identifier:append; 209, argument_list; 209, 210; 210, identifier:count; 211, if_statement; 211, 212; 211, 215; 212, comparison_operator:>; 212, 213; 212, 214; 213, identifier:indent; 214, identifier:stack_indent; 215, block; 215, 216; 216, break_statement; 217, expression_statement; 217, 218; 218, augmented_assignment:-=; 218, 219; 218, 220; 219, identifier:count; 220, integer:1; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:stack; 224, attribute; 224, 225; 224, 226; 225, identifier:self; 226, identifier:_indent_stack; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:stack_length; 230, call; 230, 231; 230, 232; 231, identifier:len; 232, argument_list; 232, 233; 233, attribute; 233, 234; 233, 235; 234, identifier:self; 235, identifier:_indent_stack; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:dlist; 239, list_comprehension; 239, 240; 239, 241; 239, 244; 240, identifier:item; 241, for_in_clause; 241, 242; 241, 243; 242, identifier:item; 243, identifier:dlist; 244, if_clause; 244, 245; 245, comparison_operator:!=; 245, 246; 245, 251; 246, subscript; 246, 247; 246, 250; 247, subscript; 247, 248; 247, 249; 248, identifier:stack; 249, identifier:item; 250, string:"type"; 251, string:"module"; 252, for_statement; 252, 253; 252, 254; 252, 255; 253, identifier:item; 254, identifier:dlist; 255, block; 255, 256; 256, delete_statement; 256, 257; 257, subscript; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:self; 260, identifier:_indent_stack; 261, binary_operator:+; 261, 262; 261, 263; 262, identifier:stack_length; 263, identifier:item | def _close_callable(self, node, force=False):
try:
lineno = node.lineno
except AttributeError:
return
if lineno <= self._processed_line:
return
# code =
name = ""
try:
name = (
node.name
if hasattr(node, "name")
else (
node.targets[0].id
if hasattr(node.targets[0], "id")
else node.targets[0].value.id
)
)
except AttributeError:
pass
indent = self._get_indent(node)
count = -1
# code =
dlist = []
while count >= -len(self._indent_stack):
element_full_name = self._indent_stack[count]["full_name"]
edict = self._callables_db.get(element_full_name, None)
stack_indent = self._indent_stack[count]["level"]
open_callable = element_full_name and (not edict["last_lineno"])
# code =
if open_callable and (
force
or (indent < stack_indent)
or (
(indent == stack_indent)
and (
(edict["type"] != "prop")
or (
(edict["type"] == "prop")
and (name and (name != element_full_name))
)
)
)
):
# code =
edict["last_lineno"] = lineno - 1
dlist.append(count)
if indent > stack_indent:
break
count -= 1
stack = self._indent_stack
stack_length = len(self._indent_stack)
dlist = [item for item in dlist if stack[item]["type"] != "module"]
for item in dlist:
del self._indent_stack[stack_length + item] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:qteRemoveKey; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:keysequence; 7, type; 7, 8; 8, identifier:QtmacsKeysequence; 9, block; 9, 10; 9, 14; 9, 18; 9, 26; 9, 47; 9, 68; 9, 77; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:keyMap; 13, identifier:self; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:keyMapRef; 17, identifier:keyMap; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:keysequence; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:keysequence; 24, identifier:toQtKeylist; 25, argument_list; 26, for_statement; 26, 27; 26, 28; 26, 34; 27, identifier:key; 28, subscript; 28, 29; 28, 30; 29, identifier:keysequence; 30, slice; 30, 31; 30, 32; 31, colon; 32, unary_operator:-; 32, 33; 33, integer:1; 34, block; 34, 35; 34, 41; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:not; 36, 37; 36, 38; 37, identifier:key; 38, identifier:keyMap; 39, block; 39, 40; 40, return_statement; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:keyMap; 44, subscript; 44, 45; 44, 46; 45, identifier:keyMap; 46, identifier:key; 47, if_statement; 47, 48; 47, 54; 47, 56; 48, comparison_operator:not; 48, 49; 48, 53; 49, subscript; 49, 50; 49, 51; 50, identifier:keysequence; 51, unary_operator:-; 51, 52; 52, integer:1; 53, identifier:keyMap; 54, block; 54, 55; 55, return_statement; 56, else_clause; 56, 57; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:keyMap; 62, identifier:pop; 63, argument_list; 63, 64; 64, subscript; 64, 65; 64, 66; 65, identifier:keysequence; 66, unary_operator:-; 66, 67; 67, integer:1; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:keysequence; 71, subscript; 71, 72; 71, 73; 72, identifier:keysequence; 73, slice; 73, 74; 73, 75; 74, colon; 75, unary_operator:-; 75, 76; 76, integer:1; 77, while_statement; 77, 78; 77, 83; 78, parenthesized_expression; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:len; 81, argument_list; 81, 82; 82, identifier:keysequence; 83, block; 83, 84; 83, 88; 83, 103; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:keyMap; 87, identifier:keyMapRef; 88, for_statement; 88, 89; 88, 90; 88, 96; 89, identifier:key; 90, subscript; 90, 91; 90, 92; 91, identifier:keysequence; 92, slice; 92, 93; 92, 94; 93, colon; 94, unary_operator:-; 94, 95; 95, integer:1; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:keyMap; 100, subscript; 100, 101; 100, 102; 101, identifier:keyMap; 102, identifier:key; 103, if_statement; 103, 104; 103, 110; 103, 112; 104, call; 104, 105; 104, 106; 105, identifier:len; 106, argument_list; 106, 107; 107, subscript; 107, 108; 107, 109; 108, identifier:keyMap; 109, identifier:key; 110, block; 110, 111; 111, return_statement; 112, else_clause; 112, 113; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:keyMap; 118, identifier:pop; 119, argument_list; 119, 120; 120, identifier:key | def qteRemoveKey(self, keysequence: QtmacsKeysequence):
keyMap = self
keyMapRef = keyMap
keysequence = keysequence.toQtKeylist()
for key in keysequence[:-1]:
if key not in keyMap:
return
keyMap = keyMap[key]
if keysequence[-1] not in keyMap:
return
else:
keyMap.pop(keysequence[-1])
keysequence = keysequence[:-1]
while(len(keysequence)):
keyMap = keyMapRef
for key in keysequence[:-1]:
keyMap = keyMap[key]
if len(keyMap[key]):
return
else:
keyMap.pop(key) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:find_labels; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:find_in_name; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:find_in_units; 11, False; 12, block; 12, 13; 12, 123; 12, 160; 12, 182; 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:key; 19, identifier:str; 20, block; 20, 21; 20, 25; 20, 121; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:found_keys; 24, list:[]; 25, if_statement; 25, 26; 25, 32; 25, 84; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:key; 29, identifier:startswith; 30, argument_list; 30, 31; 31, string:'~'; 32, block; 32, 33; 33, for_statement; 33, 34; 33, 37; 33, 43; 34, pattern_list; 34, 35; 34, 36; 35, identifier:label_no; 36, identifier:label; 37, call; 37, 38; 37, 39; 38, identifier:enumerate; 39, argument_list; 39, 40; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:labels; 43, block; 43, 44; 43, 64; 44, if_statement; 44, 45; 44, 56; 45, boolean_operator:and; 45, 46; 45, 47; 46, identifier:find_in_name; 47, comparison_operator:in; 47, 48; 47, 53; 48, subscript; 48, 49; 48, 50; 49, identifier:key; 50, slice; 50, 51; 50, 52; 51, integer:1; 52, colon; 53, attribute; 53, 54; 53, 55; 54, identifier:label; 55, identifier:name; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:found_keys; 61, identifier:append; 62, argument_list; 62, 63; 63, identifier:label_no; 64, if_statement; 64, 65; 64, 76; 65, boolean_operator:and; 65, 66; 65, 67; 66, identifier:find_in_units; 67, comparison_operator:in; 67, 68; 67, 73; 68, subscript; 68, 69; 68, 70; 69, identifier:key; 70, slice; 70, 71; 70, 72; 71, integer:1; 72, colon; 73, attribute; 73, 74; 73, 75; 74, identifier:label; 75, identifier:units; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:found_keys; 81, identifier:append; 82, argument_list; 82, 83; 83, identifier:label_no; 84, else_clause; 84, 85; 85, block; 85, 86; 86, for_statement; 86, 87; 86, 90; 86, 96; 87, pattern_list; 87, 88; 87, 89; 88, identifier:label_no; 89, identifier:label; 90, call; 90, 91; 90, 92; 91, identifier:enumerate; 92, argument_list; 92, 93; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:labels; 96, block; 96, 97; 96, 109; 97, if_statement; 97, 98; 97, 105; 98, boolean_operator:and; 98, 99; 98, 100; 99, identifier:find_in_name; 100, comparison_operator:==; 100, 101; 100, 102; 101, identifier:key; 102, attribute; 102, 103; 102, 104; 103, identifier:label; 104, identifier:name; 105, block; 105, 106; 106, return_statement; 106, 107; 107, list:[label_no]; 107, 108; 108, identifier:label_no; 109, if_statement; 109, 110; 109, 117; 110, boolean_operator:and; 110, 111; 110, 112; 111, identifier:find_in_units; 112, comparison_operator:==; 112, 113; 112, 114; 113, identifier:key; 114, attribute; 114, 115; 114, 116; 115, identifier:label; 116, identifier:units; 117, block; 117, 118; 118, return_statement; 118, 119; 119, list:[label_no]; 119, 120; 120, identifier:label_no; 121, return_statement; 121, 122; 122, identifier:found_keys; 123, if_statement; 123, 124; 123, 129; 124, call; 124, 125; 124, 126; 125, identifier:hasattr; 126, argument_list; 126, 127; 126, 128; 127, identifier:key; 128, string:'__call__'; 129, block; 129, 130; 129, 134; 129, 158; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:found_keys; 133, list:[]; 134, for_statement; 134, 135; 134, 138; 134, 144; 135, pattern_list; 135, 136; 135, 137; 136, identifier:label_no; 137, identifier:label; 138, call; 138, 139; 138, 140; 139, identifier:enumerate; 140, argument_list; 140, 141; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:labels; 144, block; 144, 145; 145, if_statement; 145, 146; 145, 150; 146, call; 146, 147; 146, 148; 147, identifier:key; 148, argument_list; 148, 149; 149, identifier:label; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:found_keys; 155, identifier:append; 156, argument_list; 156, 157; 157, identifier:label_no; 158, return_statement; 158, 159; 159, identifier:found_keys; 160, if_statement; 160, 161; 160, 167; 161, comparison_operator:is; 161, 162; 161, 166; 162, call; 162, 163; 162, 164; 163, identifier:type; 164, argument_list; 164, 165; 165, identifier:key; 166, identifier:int; 167, block; 167, 168; 168, return_statement; 168, 169; 169, conditional_expression:if; 169, 170; 169, 172; 169, 181; 170, list:[key]; 170, 171; 171, identifier:key; 172, comparison_operator:<; 172, 173; 172, 174; 173, identifier:key; 174, subscript; 174, 175; 174, 180; 175, attribute; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:matrix; 179, identifier:shape; 180, integer:1; 181, list:[]; 182, return_statement; 182, 183; 183, list:[key]; 183, 184; 184, identifier:key | def find_labels(self,key,find_in_name=True,find_in_units=False):
if type(key) is str:
found_keys = []
if key.startswith('~'):
for label_no,label in enumerate(self.labels):
if find_in_name and key[1:] in label.name:
found_keys.append(label_no)
if find_in_units and key[1:] in label.units:
found_keys.append(label_no)
else:
for label_no,label in enumerate(self.labels):
if find_in_name and key == label.name:
return [label_no]
if find_in_units and key == label.units:
return [label_no]
return found_keys
if hasattr(key, '__call__'):
found_keys = []
for label_no,label in enumerate(self.labels):
if key(label):
found_keys.append(label_no)
return found_keys
if type(key) is int:
return [key] if key < self.matrix.shape[1] else []
return [key] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:_get_constrained_labels; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:remove_dimensions; 7, False; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 15; 10, 255; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:new_labels; 14, list:[]; 15, for_statement; 15, 16; 15, 19; 15, 25; 16, pattern_list; 16, 17; 16, 18; 17, identifier:label_no; 18, identifier:label; 19, call; 19, 20; 19, 21; 20, identifier:enumerate; 21, argument_list; 21, 22; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:labels; 25, block; 25, 26; 25, 33; 25, 37; 25, 241; 25, 248; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:new_label; 29, call; 29, 30; 29, 31; 30, identifier:LabelDimension; 31, argument_list; 31, 32; 32, identifier:label; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:remove; 36, False; 37, for_statement; 37, 38; 37, 39; 37, 40; 38, identifier:k; 39, identifier:kwargs; 40, block; 40, 41; 40, 68; 40, 122; 40, 148; 40, 202; 40, 228; 41, if_statement; 41, 42; 41, 47; 42, comparison_operator:==; 42, 43; 42, 44; 43, identifier:k; 44, attribute; 44, 45; 44, 46; 45, identifier:label; 46, identifier:name; 47, block; 47, 48; 47, 56; 47, 64; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:new_label; 52, identifier:max; 53, subscript; 53, 54; 53, 55; 54, identifier:kwargs; 55, identifier:k; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:new_label; 60, identifier:min; 61, subscript; 61, 62; 61, 63; 62, identifier:kwargs; 63, identifier:k; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:remove; 67, True; 68, if_statement; 68, 69; 68, 76; 69, comparison_operator:==; 69, 70; 69, 71; 70, identifier:k; 71, binary_operator:+; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:label; 74, identifier:name; 75, string:'__lt'; 76, block; 76, 77; 77, if_statement; 77, 78; 77, 83; 77, 103; 78, comparison_operator:==; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:new_label; 81, identifier:units; 82, string:'1'; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:new_label; 88, identifier:max; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:np; 92, identifier:min; 93, argument_list; 93, 94; 94, list:[new_label.max,kwargs[k]-1]; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:new_label; 97, identifier:max; 98, binary_operator:-; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:kwargs; 101, identifier:k; 102, integer:1; 103, else_clause; 103, 104; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:new_label; 109, identifier:max; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:np; 113, identifier:min; 114, argument_list; 114, 115; 115, list:[new_label.max,kwargs[k]]; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:new_label; 118, identifier:max; 119, subscript; 119, 120; 119, 121; 120, identifier:kwargs; 121, identifier:k; 122, if_statement; 122, 123; 122, 130; 123, comparison_operator:==; 123, 124; 123, 125; 124, identifier:k; 125, binary_operator:+; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:label; 128, identifier:name; 129, string:'__lte'; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:new_label; 135, identifier:max; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:np; 139, identifier:min; 140, argument_list; 140, 141; 141, list:[new_label.max,kwargs[k]]; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:new_label; 144, identifier:max; 145, subscript; 145, 146; 145, 147; 146, identifier:kwargs; 147, identifier:k; 148, if_statement; 148, 149; 148, 156; 149, comparison_operator:==; 149, 150; 149, 151; 150, identifier:k; 151, binary_operator:+; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:label; 154, identifier:name; 155, string:'__gt'; 156, block; 156, 157; 157, if_statement; 157, 158; 157, 163; 157, 183; 158, comparison_operator:==; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:new_label; 161, identifier:units; 162, string:'1'; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:new_label; 168, identifier:min; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:np; 172, identifier:max; 173, argument_list; 173, 174; 174, list:[new_label.min,kwargs[k]+1]; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:new_label; 177, identifier:min; 178, binary_operator:+; 178, 179; 178, 182; 179, subscript; 179, 180; 179, 181; 180, identifier:kwargs; 181, identifier:k; 182, integer:1; 183, else_clause; 183, 184; 184, block; 184, 185; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:new_label; 189, identifier:min; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:np; 193, identifier:max; 194, argument_list; 194, 195; 195, list:[new_label.min,kwargs[k]]; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:new_label; 198, identifier:min; 199, subscript; 199, 200; 199, 201; 200, identifier:kwargs; 201, identifier:k; 202, if_statement; 202, 203; 202, 210; 203, comparison_operator:==; 203, 204; 203, 205; 204, identifier:k; 205, binary_operator:+; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:label; 208, identifier:name; 209, string:'__gte'; 210, block; 210, 211; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:new_label; 215, identifier:min; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:np; 219, identifier:max; 220, argument_list; 220, 221; 221, list:[new_label.min,kwargs[k]]; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:new_label; 224, identifier:min; 225, subscript; 225, 226; 225, 227; 226, identifier:kwargs; 227, identifier:k; 228, if_statement; 228, 229; 228, 236; 229, comparison_operator:==; 229, 230; 229, 231; 230, identifier:k; 231, binary_operator:+; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:label; 234, identifier:name; 235, string:'__evals'; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:remove; 240, True; 241, if_statement; 241, 242; 241, 243; 242, identifier:remove_dimensions; 243, block; 243, 244; 244, if_statement; 244, 245; 244, 246; 245, identifier:remove; 246, block; 246, 247; 247, continue_statement; 248, expression_statement; 248, 249; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:new_labels; 252, identifier:append; 253, argument_list; 253, 254; 254, identifier:new_label; 255, return_statement; 255, 256; 256, identifier:new_labels | def _get_constrained_labels(self,remove_dimensions=False,**kwargs):
new_labels = []
for label_no,label in enumerate(self.labels):
new_label = LabelDimension(label)
remove = False
for k in kwargs:
if k == label.name:
new_label.max = kwargs[k]
new_label.min = kwargs[k]
remove = True
if k == label.name+'__lt':
if new_label.units == '1':
new_label.max = np.min([new_label.max,kwargs[k]-1])
else:
new_label.max = np.min([new_label.max,kwargs[k]])
if k == label.name+'__lte':
new_label.max = np.min([new_label.max,kwargs[k]])
if k == label.name+'__gt':
if new_label.units == '1':
new_label.min = np.max([new_label.min,kwargs[k]+1])
else:
new_label.min = np.max([new_label.min,kwargs[k]])
if k == label.name+'__gte':
new_label.min = np.max([new_label.min,kwargs[k]])
if k == label.name+'__evals':
remove = True
if remove_dimensions:
if remove:
continue
new_labels.append(new_label)
return new_labels |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:populate_field_values; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:data; 6, block; 6, 7; 6, 36; 6, 76; 6, 222; 7, if_statement; 7, 8; 7, 14; 8, not_operator; 8, 9; 9, attribute; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_meta; 13, identifier:case_sensitive_fields; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:data; 18, dictionary_comprehension; 18, 19; 18, 26; 19, pair; 19, 20; 19, 25; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:k; 23, identifier:lower; 24, argument_list; 25, identifier:v; 26, for_in_clause; 26, 27; 26, 30; 27, pattern_list; 27, 28; 27, 29; 28, identifier:k; 29, identifier:v; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:six; 33, identifier:iteritems; 34, argument_list; 34, 35; 35, identifier:data; 36, if_statement; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:_meta; 41, identifier:match_fuzzy_keys; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:data; 46, dictionary_comprehension; 46, 47; 46, 66; 47, pair; 47, 48; 47, 65; 48, call; 48, 49; 48, 64; 49, attribute; 49, 50; 49, 63; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, string:''; 53, identifier:join; 54, generator_expression; 54, 55; 54, 56; 54, 59; 55, identifier:x; 56, for_in_clause; 56, 57; 56, 58; 57, identifier:x; 58, identifier:k; 59, if_clause; 59, 60; 60, comparison_operator:in; 60, 61; 60, 62; 61, identifier:x; 62, identifier:ALPHANUMERIC; 63, identifier:lower; 64, argument_list; 65, identifier:v; 66, for_in_clause; 66, 67; 66, 70; 67, pattern_list; 67, 68; 67, 69; 68, identifier:k; 69, identifier:v; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:six; 73, identifier:iteritems; 74, argument_list; 74, 75; 75, identifier:data; 76, for_statement; 76, 77; 76, 78; 76, 83; 77, identifier:field; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:_meta; 82, identifier:fields; 83, block; 83, 84; 83, 103; 83, 107; 83, 134; 83, 213; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:name; 87, conditional_expression:if; 87, 88; 87, 91; 87, 96; 88, attribute; 88, 89; 88, 90; 89, identifier:field; 90, identifier:name; 91, attribute; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:_meta; 95, identifier:case_sensitive_fields; 96, call; 96, 97; 96, 102; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:field; 100, identifier:name; 101, identifier:lower; 102, argument_list; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:value; 106, None; 107, if_statement; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:_meta; 112, identifier:match_fuzzy_keys; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:name; 117, call; 117, 118; 117, 133; 118, attribute; 118, 119; 118, 132; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, string:''; 122, identifier:join; 123, generator_expression; 123, 124; 123, 125; 123, 128; 124, identifier:x; 125, for_in_clause; 125, 126; 125, 127; 126, identifier:x; 127, identifier:name; 128, if_clause; 128, 129; 129, comparison_operator:in; 129, 130; 129, 131; 130, identifier:x; 131, identifier:ALPHANUMERIC; 132, identifier:lower; 133, argument_list; 134, if_statement; 134, 135; 134, 138; 134, 151; 134, 195; 135, comparison_operator:in; 135, 136; 135, 137; 136, identifier:name; 137, identifier:data; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:value; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:field; 145, identifier:to_python; 146, argument_list; 146, 147; 146, 150; 147, subscript; 147, 148; 147, 149; 148, identifier:data; 149, identifier:name; 150, identifier:self; 151, elif_clause; 151, 152; 151, 161; 152, boolean_operator:and; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:field; 155, identifier:required; 156, comparison_operator:is; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:field; 159, identifier:default; 160, None; 161, block; 161, 162; 161, 176; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:message; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, string:"Response from {0} is missing required field '{1}'"; 168, identifier:format; 169, argument_list; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:self; 172, identifier:_url; 173, attribute; 173, 174; 173, 175; 174, identifier:field; 175, identifier:name; 176, if_statement; 176, 177; 176, 180; 176, 186; 177, attribute; 177, 178; 177, 179; 178, identifier:self; 179, identifier:_strict; 180, block; 180, 181; 181, raise_statement; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:MissingFieldException; 184, argument_list; 184, 185; 185, identifier:message; 186, else_clause; 186, 187; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:logger; 192, identifier:warn; 193, argument_list; 193, 194; 194, identifier:message; 195, elif_clause; 195, 196; 195, 201; 196, comparison_operator:is; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:field; 199, identifier:default; 200, None; 201, block; 201, 202; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:value; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:copy; 208, identifier:copy; 209, argument_list; 209, 210; 210, attribute; 210, 211; 210, 212; 211, identifier:field; 212, identifier:default; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:setattr; 216, argument_list; 216, 217; 216, 218; 216, 221; 217, identifier:self; 218, attribute; 218, 219; 218, 220; 219, identifier:field; 220, identifier:_attr_name; 221, identifier:value; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:self; 226, identifier:_populated_field_values; 227, True | def populate_field_values(self, data):
if not self._meta.case_sensitive_fields:
data = {k.lower(): v for k, v in six.iteritems(data)}
if self._meta.match_fuzzy_keys:
data = {''.join(x for x in k if x in ALPHANUMERIC).lower(): v for k, v in six.iteritems(data)}
for field in self._meta.fields:
name = field.name if self._meta.case_sensitive_fields else field.name.lower()
value = None
if self._meta.match_fuzzy_keys:
name = ''.join(x for x in name if x in ALPHANUMERIC).lower()
if name in data:
value = field.to_python(data[name], self)
elif field.required and field.default is None:
message = "Response from {0} is missing required field '{1}'".format(self._url, field.name)
if self._strict:
raise MissingFieldException(message)
else:
logger.warn(message)
elif field.default is not None:
value = copy.copy(field.default)
setattr(self, field._attr_name, value)
self._populated_field_values = True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:build_contact; 3, parameters; 3, 4; 3, 5; 4, identifier:request; 5, default_parameter; 5, 6; 5, 7; 6, identifier:slug; 7, string:""; 8, block; 8, 9; 8, 19; 8, 29; 8, 35; 8, 41; 8, 60; 8, 132; 8, 444; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:controller; 12, call; 12, 13; 12, 14; 13, identifier:get_object_or_404; 14, argument_list; 14, 15; 14, 16; 15, identifier:ContactFormController; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:slug; 18, identifier:slug; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:site; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:Site; 26, identifier:objects; 27, identifier:get_current; 28, argument_list; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:UserModel; 32, call; 32, 33; 32, 34; 33, identifier:get_user_model; 34, argument_list; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:user; 38, attribute; 38, 39; 38, 40; 39, identifier:request; 40, identifier:user; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:form; 44, call; 44, 45; 44, 46; 45, identifier:ContactForm; 46, argument_list; 46, 47; 46, 52; 46, 57; 47, boolean_operator:or; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:request; 50, identifier:POST; 51, None; 52, boolean_operator:or; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:request; 55, identifier:FILES; 56, None; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:controller; 59, identifier:controller; 60, if_statement; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:user; 63, identifier:is_authenticated; 64, block; 64, 65; 64, 82; 64, 96; 64, 106; 64, 120; 65, try_statement; 65, 66; 65, 73; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:name; 70, attribute; 70, 71; 70, 72; 71, identifier:user; 72, identifier:display_name; 73, except_clause; 73, 74; 73, 75; 74, identifier:AttributeError; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:name; 79, attribute; 79, 80; 79, 81; 80, identifier:user; 81, identifier:username; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 95; 84, subscript; 84, 85; 84, 94; 85, attribute; 85, 86; 85, 93; 86, attribute; 86, 87; 86, 92; 87, subscript; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:form; 90, identifier:fields; 91, string:'sender_name'; 92, identifier:widget; 93, identifier:attrs; 94, string:'readonly'; 95, string:'true'; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 105; 98, attribute; 98, 99; 98, 104; 99, subscript; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:form; 102, identifier:fields; 103, string:'sender_name'; 104, identifier:initial; 105, identifier:name; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 119; 108, subscript; 108, 109; 108, 118; 109, attribute; 109, 110; 109, 117; 110, attribute; 110, 111; 110, 116; 111, subscript; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:form; 114, identifier:fields; 115, string:'sender_email'; 116, identifier:widget; 117, identifier:attrs; 118, string:'readonly'; 119, string:'true'; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 129; 122, attribute; 122, 123; 122, 128; 123, subscript; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:form; 126, identifier:fields; 127, string:'sender_email'; 128, identifier:initial; 129, attribute; 129, 130; 129, 131; 130, identifier:user; 131, identifier:email; 132, if_statement; 132, 133; 132, 138; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:form; 136, identifier:is_valid; 137, argument_list; 138, block; 138, 139; 138, 185; 138, 434; 139, if_statement; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:controller; 142, identifier:store_in_db; 143, block; 143, 144; 143, 154; 143, 160; 143, 166; 143, 179; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:new_msg; 147, call; 147, 148; 147, 149; 148, identifier:Contact; 149, argument_list; 149, 150; 150, dictionary_splat; 150, 151; 151, attribute; 151, 152; 151, 153; 152, identifier:form; 153, identifier:cleaned_data; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:new_msg; 158, identifier:controller; 159, identifier:controller; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:new_msg; 164, identifier:site; 165, identifier:site; 166, if_statement; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:controller; 169, identifier:override_subject; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:new_msg; 175, identifier:subject; 176, attribute; 176, 177; 176, 178; 177, identifier:controller; 178, identifier:override_subject; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:new_msg; 183, identifier:save; 184, argument_list; 185, if_statement; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:controller; 188, identifier:send_emails; 189, block; 189, 190; 189, 196; 189, 234; 189, 248; 189, 273; 189, 314; 189, 356; 189, 374; 189, 396; 189, 428; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:form_data; 193, attribute; 193, 194; 193, 195; 194, identifier:form; 195, identifier:cleaned_data; 196, if_statement; 196, 197; 196, 200; 196, 207; 196, 218; 197, attribute; 197, 198; 197, 199; 198, identifier:controller; 199, identifier:override_subject; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:subject; 204, attribute; 204, 205; 204, 206; 205, identifier:controller; 206, identifier:override_subject; 207, elif_clause; 207, 208; 207, 211; 208, comparison_operator:in; 208, 209; 208, 210; 209, string:'subject'; 210, identifier:form_data; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:subject; 215, subscript; 215, 216; 215, 217; 216, identifier:form_data; 217, string:'subject'; 218, else_clause; 218, 219; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:subject; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, string:"{} message from {}"; 226, identifier:format; 227, argument_list; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:controller; 230, identifier:name; 231, subscript; 231, 232; 231, 233; 232, identifier:form_data; 233, string:'sender_name'; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:body; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, string:"{} \n\n {}"; 240, identifier:format; 241, argument_list; 241, 242; 241, 245; 242, subscript; 242, 243; 242, 244; 243, identifier:form_data; 244, string:'body'; 245, subscript; 245, 246; 245, 247; 246, identifier:form_data; 247, string:'sender_name'; 248, if_statement; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:controller; 251, identifier:request_contact_info; 252, block; 252, 253; 253, expression_statement; 253, 254; 254, augmented_assignment:+=; 254, 255; 254, 256; 255, identifier:body; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, string:"\nAddress: {} \nCity: {} \nState: {} \nPhone: {}"; 259, identifier:format; 260, argument_list; 260, 261; 260, 264; 260, 267; 260, 270; 261, subscript; 261, 262; 261, 263; 262, identifier:form_data; 263, string:'contact_address'; 264, subscript; 264, 265; 264, 266; 265, identifier:form_data; 266, string:'contact_city'; 267, subscript; 267, 268; 267, 269; 268, identifier:form_data; 269, string:'contact_state'; 270, subscript; 270, 271; 270, 272; 271, identifier:form_data; 272, string:'contact_phone'; 273, if_statement; 273, 274; 273, 279; 274, comparison_operator:==; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:controller; 277, identifier:email_options; 278, string:'2'; 279, block; 279, 280; 280, try_statement; 280, 281; 280, 302; 281, block; 281, 282; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 285; 284, identifier:to; 285, list:[UserModel.objects.get(username=form.cleaned_data['to']).email]; 285, 286; 286, attribute; 286, 287; 286, 301; 287, call; 287, 288; 287, 293; 288, attribute; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:UserModel; 291, identifier:objects; 292, identifier:get; 293, argument_list; 293, 294; 294, keyword_argument; 294, 295; 294, 296; 295, identifier:username; 296, subscript; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:form; 299, identifier:cleaned_data; 300, string:'to'; 301, identifier:email; 302, except_clause; 302, 303; 302, 304; 303, identifier:Exception; 304, block; 304, 305; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:to; 308, list:[form.cleaned_data['to']]; 308, 309; 309, subscript; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:form; 312, identifier:cleaned_data; 313, string:'to'; 314, if_statement; 314, 315; 314, 320; 315, comparison_operator:==; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:controller; 318, identifier:email_options; 319, string:'1'; 320, block; 320, 321; 320, 337; 321, expression_statement; 321, 322; 322, assignment; 322, 323; 322, 324; 323, identifier:to; 324, list_comprehension; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:r; 327, identifier:email; 328, for_in_clause; 328, 329; 328, 330; 329, identifier:r; 330, call; 330, 331; 330, 336; 331, attribute; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:controller; 334, identifier:recipients; 335, identifier:all; 336, argument_list; 337, for_statement; 337, 338; 337, 339; 337, 346; 338, identifier:r; 339, call; 339, 340; 339, 345; 340, attribute; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:controller; 343, identifier:other_recipients; 344, identifier:all; 345, argument_list; 346, block; 346, 347; 347, expression_statement; 347, 348; 348, call; 348, 349; 348, 352; 349, attribute; 349, 350; 349, 351; 350, identifier:to; 351, identifier:append; 352, argument_list; 352, 353; 353, attribute; 353, 354; 353, 355; 354, identifier:r; 355, identifier:email; 356, if_statement; 356, 357; 356, 362; 357, comparison_operator:in; 357, 358; 357, 359; 358, string:'send_a_copy'; 359, attribute; 359, 360; 359, 361; 360, identifier:form; 361, identifier:cleaned_data; 362, block; 362, 363; 363, expression_statement; 363, 364; 364, call; 364, 365; 364, 368; 365, attribute; 365, 366; 365, 367; 366, identifier:to; 367, identifier:append; 368, argument_list; 368, 369; 369, subscript; 369, 370; 369, 373; 370, attribute; 370, 371; 370, 372; 371, identifier:form; 372, identifier:cleaned_data; 373, string:'sender_email'; 374, expression_statement; 374, 375; 375, assignment; 375, 376; 375, 377; 376, identifier:mail; 377, call; 377, 378; 377, 379; 378, identifier:EmailMessage; 379, argument_list; 379, 380; 379, 383; 379, 386; 379, 393; 380, keyword_argument; 380, 381; 380, 382; 381, identifier:subject; 382, identifier:subject; 383, keyword_argument; 383, 384; 383, 385; 384, identifier:body; 385, identifier:body; 386, keyword_argument; 386, 387; 386, 388; 387, identifier:from_email; 388, subscript; 388, 389; 388, 392; 389, attribute; 389, 390; 389, 391; 390, identifier:form; 391, identifier:cleaned_data; 392, string:'sender_email'; 393, keyword_argument; 393, 394; 393, 395; 394, identifier:to; 395, identifier:to; 396, if_statement; 396, 397; 396, 402; 397, comparison_operator:in; 397, 398; 397, 399; 398, string:'photo'; 399, attribute; 399, 400; 399, 401; 400, identifier:request; 401, identifier:FILES; 402, block; 402, 403; 402, 411; 403, expression_statement; 403, 404; 404, assignment; 404, 405; 404, 406; 405, identifier:photo; 406, subscript; 406, 407; 406, 410; 407, attribute; 407, 408; 407, 409; 408, identifier:request; 409, identifier:FILES; 410, string:'photo'; 411, expression_statement; 411, 412; 412, call; 412, 413; 412, 416; 413, attribute; 413, 414; 413, 415; 414, identifier:mail; 415, identifier:attach; 416, argument_list; 416, 417; 416, 420; 416, 425; 417, attribute; 417, 418; 417, 419; 418, identifier:photo; 419, identifier:name; 420, call; 420, 421; 420, 424; 421, attribute; 421, 422; 421, 423; 422, identifier:photo; 423, identifier:read; 424, argument_list; 425, attribute; 425, 426; 425, 427; 426, identifier:photo; 427, identifier:content_type; 428, expression_statement; 428, 429; 429, call; 429, 430; 429, 433; 430, attribute; 430, 431; 430, 432; 431, identifier:mail; 432, identifier:send; 433, argument_list; 434, return_statement; 434, 435; 435, call; 435, 436; 435, 437; 436, identifier:render; 437, argument_list; 437, 438; 437, 439; 437, 440; 438, identifier:request; 439, string:'success_url'; 440, dictionary; 440, 441; 441, pair; 441, 442; 441, 443; 442, string:'controller'; 443, identifier:controller; 444, return_statement; 444, 445; 445, call; 445, 446; 445, 447; 446, identifier:render; 447, argument_list; 447, 448; 447, 449; 447, 450; 448, identifier:request; 449, string:'contact/form.html'; 450, dictionary; 450, 451; 450, 454; 450, 457; 451, pair; 451, 452; 451, 453; 452, string:'form'; 453, identifier:form; 454, pair; 454, 455; 454, 456; 455, string:'site'; 456, identifier:site; 457, pair; 457, 458; 457, 459; 458, string:'controller'; 459, identifier:controller | def build_contact(request, slug=""):
controller = get_object_or_404(ContactFormController, slug=slug)
site = Site.objects.get_current()
UserModel = get_user_model()
user = request.user
form = ContactForm(request.POST or None, request.FILES or None, controller=controller)
if user.is_authenticated:
try:
name = user.display_name
except AttributeError:
name = user.username
form.fields['sender_name'].widget.attrs['readonly'] = 'true'
form.fields['sender_name'].initial = name
form.fields['sender_email'].widget.attrs['readonly'] = 'true'
form.fields['sender_email'].initial = user.email
if form.is_valid():
if controller.store_in_db:
new_msg = Contact(**form.cleaned_data)
new_msg.controller = controller
new_msg.site = site
if controller.override_subject:
new_msg.subject = controller.override_subject
new_msg.save()
if controller.send_emails:
form_data = form.cleaned_data
if controller.override_subject:
subject = controller.override_subject
elif 'subject' in form_data:
subject = form_data['subject']
else:
subject = "{} message from {}".format(controller.name, form_data['sender_name'])
body = "{} \n\n {}".format(form_data['body'], form_data['sender_name'])
if controller.request_contact_info:
body += "\nAddress: {} \nCity: {} \nState: {} \nPhone: {}".format(
form_data['contact_address'],
form_data['contact_city'],
form_data['contact_state'],
form_data['contact_phone']
)
if controller.email_options == '2':
try:
to = [UserModel.objects.get(username=form.cleaned_data['to']).email]
except Exception:
to = [form.cleaned_data['to']]
if controller.email_options == '1':
to = [r.email for r in controller.recipients.all()]
for r in controller.other_recipients.all():
to.append(r.email)
if 'send_a_copy' in form.cleaned_data:
to.append(form.cleaned_data['sender_email'])
mail = EmailMessage(
subject=subject,
body=body,
from_email=form.cleaned_data['sender_email'],
to=to
)
if 'photo' in request.FILES:
photo = request.FILES['photo']
mail.attach(photo.name, photo.read(), photo.content_type)
mail.send()
return render(request, 'success_url', {'controller': controller})
return render(request, 'contact/form.html', {
'form': form,
'site': site,
'controller': controller
}) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:stop_task; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:task_tag; 6, default_parameter; 6, 7; 6, 8; 7, identifier:stop_dependent; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:stop_requirements; 11, False; 12, block; 12, 13; 12, 24; 12, 30; 12, 66; 12, 113; 12, 210; 12, 371; 12, 381; 12, 402; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:task; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:started_tasks; 20, argument_list; 20, 21; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:task_registry_id; 23, identifier:task_tag; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:task; 27, None; 28, block; 28, 29; 29, return_statement; 30, function_definition; 30, 31; 30, 32; 30, 34; 31, function_name:stop; 32, parameters; 32, 33; 33, identifier:task_to_stop; 34, block; 34, 35; 35, if_statement; 35, 36; 35, 41; 36, comparison_operator:in; 36, 37; 36, 38; 37, identifier:task_to_stop; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:__started; 41, block; 41, 42; 41, 57; 42, if_statement; 42, 43; 42, 50; 43, comparison_operator:is; 43, 44; 43, 49; 44, call; 44, 45; 44, 46; 45, identifier:isinstance; 46, argument_list; 46, 47; 46, 48; 47, identifier:task_to_stop; 48, identifier:WStoppableTask; 49, True; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:task_to_stop; 55, identifier:stop; 56, argument_list; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:__started; 63, identifier:remove; 64, argument_list; 64, 65; 65, identifier:task_to_stop; 66, function_definition; 66, 67; 66, 68; 66, 70; 67, function_name:stop_dependency; 68, parameters; 68, 69; 69, identifier:task_to_stop; 70, block; 70, 71; 70, 75; 70, 99; 70, 108; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:deeper_dependencies; 74, list:[]; 75, for_statement; 75, 76; 75, 77; 75, 80; 76, identifier:dependent_task; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:__started; 80, block; 80, 81; 81, if_statement; 81, 82; 81, 91; 82, comparison_operator:in; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:task_to_stop; 85, identifier:__registry_tag__; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:dependent_task; 89, identifier:__class__; 90, identifier:__dependency__; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:deeper_dependencies; 96, identifier:append; 97, argument_list; 97, 98; 98, identifier:dependent_task; 99, for_statement; 99, 100; 99, 101; 99, 102; 100, identifier:dependent_task; 101, identifier:deeper_dependencies; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:stop_dependency; 106, argument_list; 106, 107; 107, identifier:dependent_task; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:stop; 111, argument_list; 111, 112; 112, identifier:task_to_stop; 113, function_definition; 113, 114; 113, 115; 113, 120; 114, function_name:calculate_requirements; 115, parameters; 115, 116; 115, 117; 116, identifier:task_to_stop; 117, default_parameter; 117, 118; 117, 119; 118, identifier:cross_requirements; 119, False; 120, block; 120, 121; 120, 127; 120, 153; 120, 160; 120, 166; 120, 208; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:requirements; 124, call; 124, 125; 124, 126; 125, identifier:set; 126, argument_list; 127, for_statement; 127, 128; 127, 129; 127, 132; 128, identifier:dependent_task; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:__started; 132, block; 132, 133; 133, if_statement; 133, 134; 133, 145; 134, comparison_operator:in; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:dependent_task; 138, identifier:__class__; 139, identifier:__registry_tag__; 140, attribute; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:task_to_stop; 143, identifier:__class__; 144, identifier:__dependency__; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:requirements; 150, identifier:add; 151, argument_list; 151, 152; 152, identifier:dependent_task; 153, if_statement; 153, 154; 153, 157; 154, comparison_operator:is; 154, 155; 154, 156; 155, identifier:cross_requirements; 156, True; 157, block; 157, 158; 158, return_statement; 158, 159; 159, identifier:requirements; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:result; 163, call; 163, 164; 163, 165; 164, identifier:set; 165, argument_list; 166, for_statement; 166, 167; 166, 168; 166, 169; 167, identifier:task_a; 168, identifier:requirements; 169, block; 169, 170; 169, 174; 169, 196; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:requirement_match; 173, False; 174, for_statement; 174, 175; 174, 176; 174, 177; 175, identifier:task_b; 176, identifier:requirements; 177, block; 177, 178; 178, if_statement; 178, 179; 178, 190; 179, comparison_operator:in; 179, 180; 179, 185; 180, attribute; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:task_a; 183, identifier:__class__; 184, identifier:__registry_tag__; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:task_b; 188, identifier:__class__; 189, identifier:__dependency__; 190, block; 190, 191; 190, 195; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:requirement_match; 194, True; 195, break_statement; 196, if_statement; 196, 197; 196, 200; 197, comparison_operator:is; 197, 198; 197, 199; 198, identifier:requirement_match; 199, False; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:result; 205, identifier:add; 206, argument_list; 206, 207; 207, identifier:task_a; 208, return_statement; 208, 209; 209, identifier:result; 210, function_definition; 210, 211; 210, 212; 210, 222; 211, function_name:calculate_priorities; 212, parameters; 212, 213; 212, 214; 212, 216; 212, 219; 213, identifier:task_to_stop; 214, list_splat_pattern; 214, 215; 215, identifier:extra_tasks; 216, default_parameter; 216, 217; 216, 218; 217, identifier:current_result; 218, None; 219, default_parameter; 219, 220; 219, 221; 220, identifier:requirements_left; 221, None; 222, block; 222, 223; 222, 232; 222, 237; 222, 252; 222, 262; 222, 274; 222, 283; 222, 316; 222, 325; 222, 346; 222, 356; 223, if_statement; 223, 224; 223, 227; 224, comparison_operator:is; 224, 225; 224, 226; 225, identifier:current_result; 226, None; 227, block; 227, 228; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:current_result; 231, list:[]; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:tasks_to_stop; 235, list:[task_to_stop]; 235, 236; 236, identifier:task_to_stop; 237, if_statement; 237, 238; 237, 244; 238, comparison_operator:>; 238, 239; 238, 243; 239, call; 239, 240; 239, 241; 240, identifier:len; 241, argument_list; 241, 242; 242, identifier:extra_tasks; 243, integer:0; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:tasks_to_stop; 249, identifier:extend; 250, argument_list; 250, 251; 251, identifier:extra_tasks; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:current_result; 256, identifier:append; 257, argument_list; 257, 258; 258, call; 258, 259; 258, 260; 259, identifier:list; 260, argument_list; 260, 261; 261, identifier:tasks_to_stop; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:all_requirements; 265, call; 265, 266; 265, 267; 266, identifier:calculate_requirements; 267, argument_list; 267, 268; 267, 271; 268, subscript; 268, 269; 268, 270; 269, identifier:tasks_to_stop; 270, integer:0; 271, keyword_argument; 271, 272; 271, 273; 272, identifier:cross_requirements; 273, True; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:nested_requirements; 277, call; 277, 278; 277, 279; 278, identifier:calculate_requirements; 279, argument_list; 279, 280; 280, subscript; 280, 281; 280, 282; 281, identifier:tasks_to_stop; 282, integer:0; 283, for_statement; 283, 284; 283, 285; 283, 290; 284, identifier:dependent_task; 285, subscript; 285, 286; 285, 287; 286, identifier:tasks_to_stop; 287, slice; 287, 288; 287, 289; 288, integer:1; 289, colon; 290, block; 290, 291; 290, 303; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:nested_requirements; 294, call; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:nested_requirements; 297, identifier:union; 298, argument_list; 298, 299; 299, call; 299, 300; 299, 301; 300, identifier:calculate_requirements; 301, argument_list; 301, 302; 302, identifier:dependent_task; 303, expression_statement; 303, 304; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:all_requirements; 307, identifier:update; 308, argument_list; 308, 309; 309, call; 309, 310; 309, 311; 310, identifier:calculate_requirements; 311, argument_list; 311, 312; 311, 313; 312, identifier:dependent_task; 313, keyword_argument; 313, 314; 313, 315; 314, identifier:cross_requirements; 315, True; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 319; 318, identifier:all_requirements; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:all_requirements; 322, identifier:difference; 323, argument_list; 323, 324; 324, identifier:nested_requirements; 325, if_statement; 325, 326; 325, 329; 326, comparison_operator:is; 326, 327; 326, 328; 327, identifier:requirements_left; 328, None; 329, block; 329, 330; 329, 339; 330, expression_statement; 330, 331; 331, assignment; 331, 332; 331, 333; 332, identifier:requirements_left; 333, call; 333, 334; 333, 337; 334, attribute; 334, 335; 334, 336; 335, identifier:requirements_left; 336, identifier:difference; 337, argument_list; 337, 338; 338, identifier:all_requirements; 339, expression_statement; 339, 340; 340, call; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:nested_requirements; 343, identifier:update; 344, argument_list; 344, 345; 345, identifier:requirements_left; 346, if_statement; 346, 347; 346, 353; 347, comparison_operator:==; 347, 348; 347, 352; 348, call; 348, 349; 348, 350; 349, identifier:len; 350, argument_list; 350, 351; 351, identifier:nested_requirements; 352, integer:0; 353, block; 353, 354; 354, return_statement; 354, 355; 355, identifier:current_result; 356, return_statement; 356, 357; 357, call; 357, 358; 357, 359; 358, identifier:calculate_priorities; 359, argument_list; 359, 360; 359, 365; 359, 368; 360, list_splat; 360, 361; 361, call; 361, 362; 361, 363; 362, identifier:list; 363, argument_list; 363, 364; 364, identifier:nested_requirements; 365, keyword_argument; 365, 366; 365, 367; 366, identifier:current_result; 367, identifier:current_result; 368, keyword_argument; 368, 369; 368, 370; 369, identifier:requirements_left; 370, identifier:all_requirements; 371, if_statement; 371, 372; 371, 375; 372, comparison_operator:is; 372, 373; 372, 374; 373, identifier:stop_dependent; 374, True; 375, block; 375, 376; 376, expression_statement; 376, 377; 377, call; 377, 378; 377, 379; 378, identifier:stop_dependency; 379, argument_list; 379, 380; 380, identifier:task; 381, if_statement; 381, 382; 381, 385; 382, comparison_operator:is; 382, 383; 382, 384; 383, identifier:stop_requirements; 384, True; 385, block; 385, 386; 386, for_statement; 386, 387; 386, 388; 386, 392; 387, identifier:task_list; 388, call; 388, 389; 388, 390; 389, identifier:calculate_priorities; 390, argument_list; 390, 391; 391, identifier:task; 392, block; 392, 393; 393, for_statement; 393, 394; 393, 395; 393, 396; 394, identifier:single_task; 395, identifier:task_list; 396, block; 396, 397; 397, expression_statement; 397, 398; 398, call; 398, 399; 398, 400; 399, identifier:stop; 400, argument_list; 400, 401; 401, identifier:single_task; 402, if_statement; 402, 403; 402, 406; 403, comparison_operator:is; 403, 404; 403, 405; 404, identifier:stop_dependent; 405, True; 406, block; 406, 407; 407, expression_statement; 407, 408; 408, call; 408, 409; 408, 410; 409, identifier:stop; 410, argument_list; 410, 411; 411, identifier:task | def stop_task(self, task_tag, stop_dependent=True, stop_requirements=False):
task = self.started_tasks(task_registry_id=task_tag)
if task is None:
return
def stop(task_to_stop):
if task_to_stop in self.__started:
if isinstance(task_to_stop, WStoppableTask) is True:
task_to_stop.stop()
self.__started.remove(task_to_stop)
def stop_dependency(task_to_stop):
deeper_dependencies = []
for dependent_task in self.__started:
if task_to_stop.__registry_tag__ in dependent_task.__class__.__dependency__:
deeper_dependencies.append(dependent_task)
for dependent_task in deeper_dependencies:
stop_dependency(dependent_task)
stop(task_to_stop)
def calculate_requirements(task_to_stop, cross_requirements=False):
requirements = set()
for dependent_task in self.__started:
if dependent_task.__class__.__registry_tag__ in task_to_stop.__class__.__dependency__:
requirements.add(dependent_task)
if cross_requirements is True:
return requirements
result = set()
for task_a in requirements:
requirement_match = False
for task_b in requirements:
if task_a.__class__.__registry_tag__ in task_b.__class__.__dependency__:
requirement_match = True
break
if requirement_match is False:
result.add(task_a)
return result
def calculate_priorities(task_to_stop, *extra_tasks, current_result=None, requirements_left=None):
if current_result is None:
current_result = []
tasks_to_stop = [task_to_stop]
if len(extra_tasks) > 0:
tasks_to_stop.extend(extra_tasks)
current_result.append(list(tasks_to_stop))
all_requirements = calculate_requirements(tasks_to_stop[0], cross_requirements=True)
nested_requirements = calculate_requirements(tasks_to_stop[0])
for dependent_task in tasks_to_stop[1:]:
nested_requirements = nested_requirements.union(calculate_requirements(dependent_task))
all_requirements.update(calculate_requirements(dependent_task, cross_requirements=True))
all_requirements = all_requirements.difference(nested_requirements)
if requirements_left is not None:
requirements_left = requirements_left.difference(all_requirements)
nested_requirements.update(requirements_left)
if len(nested_requirements) == 0:
return current_result
return calculate_priorities(
*list(nested_requirements), current_result=current_result, requirements_left=all_requirements
)
if stop_dependent is True:
stop_dependency(task)
if stop_requirements is True:
for task_list in calculate_priorities(task):
for single_task in task_list:
stop(single_task)
if stop_dependent is not True:
stop(task) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:diffs2persistence; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:rev_docs; 5, default_parameter; 5, 6; 5, 7; 6, identifier:window_size; 7, integer:50; 8, default_parameter; 8, 9; 8, 10; 9, identifier:revert_radius; 10, integer:15; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sunset; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:verbose; 16, False; 17, block; 17, 18; 17, 29; 17, 36; 17, 43; 17, 63; 17, 80; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:rev_docs; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:mwxml; 25, identifier:utilities; 26, identifier:normalize; 27, argument_list; 27, 28; 28, identifier:rev_docs; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:window_size; 32, call; 32, 33; 32, 34; 33, identifier:int; 34, argument_list; 34, 35; 35, identifier:window_size; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:revert_radius; 39, call; 39, 40; 39, 41; 40, identifier:int; 41, argument_list; 41, 42; 42, identifier:revert_radius; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:sunset; 46, conditional_expression:if; 46, 47; 46, 51; 46, 54; 46, 55; 47, call; 47, 48; 47, 49; 48, identifier:Timestamp; 49, argument_list; 49, 50; 50, identifier:sunset; 51, comparison_operator:is; 51, 52; 51, 53; 52, identifier:sunset; 53, None; 54, line_continuation:\; 55, call; 55, 56; 55, 57; 56, identifier:Timestamp; 57, argument_list; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:time; 61, identifier:time; 62, argument_list; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:page_docs; 66, call; 66, 67; 66, 68; 67, identifier:groupby; 68, argument_list; 68, 69; 68, 70; 69, identifier:rev_docs; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:key; 72, lambda; 72, 73; 72, 75; 73, lambda_parameters; 73, 74; 74, identifier:d; 75, subscript; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:d; 78, string:'page'; 79, string:'title'; 80, for_statement; 80, 81; 80, 84; 80, 85; 81, pattern_list; 81, 82; 81, 83; 82, identifier:page_title; 83, identifier:rev_docs; 84, identifier:page_docs; 85, block; 85, 86; 85, 100; 85, 107; 85, 116; 85, 125; 85, 300; 85, 357; 86, if_statement; 86, 87; 86, 88; 87, identifier:verbose; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 96; 91, attribute; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:sys; 94, identifier:stderr; 95, identifier:write; 96, argument_list; 96, 97; 97, binary_operator:+; 97, 98; 97, 99; 98, identifier:page_title; 99, string:": "; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:rev_docs; 103, call; 103, 104; 103, 105; 104, identifier:peekable; 105, argument_list; 105, 106; 106, identifier:rev_docs; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:window; 110, call; 110, 111; 110, 112; 111, identifier:deque; 112, argument_list; 112, 113; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:maxlen; 115, identifier:window_size; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:state; 119, call; 119, 120; 119, 121; 120, identifier:DiffState; 121, argument_list; 121, 122; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:revert_radius; 124, identifier:revert_radius; 125, while_statement; 125, 126; 125, 127; 126, identifier:rev_docs; 127, block; 127, 128; 127, 135; 127, 144; 127, 179; 127, 200; 127, 225; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:rev_doc; 131, call; 131, 132; 131, 133; 132, identifier:next; 133, argument_list; 133, 134; 134, identifier:rev_docs; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:next_doc; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:rev_docs; 141, identifier:peek; 142, argument_list; 142, 143; 143, None; 144, if_statement; 144, 145; 144, 148; 144, 166; 145, comparison_operator:is; 145, 146; 145, 147; 146, identifier:next_doc; 147, None; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:seconds_visible; 152, binary_operator:-; 152, 153; 152, 159; 152, 160; 153, call; 153, 154; 153, 155; 154, identifier:Timestamp; 155, argument_list; 155, 156; 156, subscript; 156, 157; 156, 158; 157, identifier:next_doc; 158, string:'timestamp'; 159, line_continuation:\; 160, call; 160, 161; 160, 162; 161, identifier:Timestamp; 162, argument_list; 162, 163; 163, subscript; 163, 164; 163, 165; 164, identifier:rev_doc; 165, string:'timestamp'; 166, else_clause; 166, 167; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:seconds_visible; 171, binary_operator:-; 171, 172; 171, 173; 172, identifier:sunset; 173, call; 173, 174; 173, 175; 174, identifier:Timestamp; 175, argument_list; 175, 176; 176, subscript; 176, 177; 176, 178; 177, identifier:rev_doc; 178, string:'timestamp'; 179, if_statement; 179, 180; 179, 183; 180, comparison_operator:<; 180, 181; 180, 182; 181, identifier:seconds_visible; 182, integer:0; 183, block; 183, 184; 183, 196; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:logger; 188, identifier:warn; 189, argument_list; 189, 190; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, string:"Seconds visible {0} is less than zero."; 193, identifier:format; 194, argument_list; 194, 195; 195, identifier:seconds_visible; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:seconds_visible; 199, integer:0; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 206; 201, 207; 202, pattern_list; 202, 203; 202, 204; 202, 205; 203, identifier:_; 204, identifier:tokens_added; 205, identifier:_; 206, line_continuation:\; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:state; 210, identifier:update_opdocs; 211, argument_list; 211, 212; 211, 215; 211, 220; 212, subscript; 212, 213; 212, 214; 213, identifier:rev_doc; 214, string:'sha1'; 215, subscript; 215, 216; 215, 219; 216, subscript; 216, 217; 216, 218; 217, identifier:rev_doc; 218, string:'diff'; 219, string:'ops'; 220, tuple; 220, 221; 220, 224; 221, subscript; 221, 222; 221, 223; 222, identifier:rev_doc; 223, string:'user'; 224, identifier:seconds_visible; 225, if_statement; 225, 226; 225, 232; 225, 289; 226, comparison_operator:==; 226, 227; 226, 231; 227, call; 227, 228; 227, 229; 228, identifier:len; 229, argument_list; 229, 230; 230, identifier:window; 231, identifier:window_size; 232, block; 232, 233; 232, 241; 232, 250; 232, 260; 232, 266; 232, 269; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 238; 235, pattern_list; 235, 236; 235, 237; 236, identifier:old_doc; 237, identifier:old_added; 238, subscript; 238, 239; 238, 240; 239, identifier:window; 240, integer:0; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:window; 245, identifier:append; 246, argument_list; 246, 247; 247, tuple; 247, 248; 247, 249; 248, identifier:rev_doc; 249, identifier:tokens_added; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:persistence; 253, call; 253, 254; 253, 255; 254, identifier:token_persistence; 255, argument_list; 255, 256; 255, 257; 255, 258; 255, 259; 256, identifier:old_doc; 257, identifier:old_added; 258, identifier:window; 259, None; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 265; 262, subscript; 262, 263; 262, 264; 263, identifier:old_doc; 264, string:'persistence'; 265, identifier:persistence; 266, expression_statement; 266, 267; 267, yield; 267, 268; 268, identifier:old_doc; 269, if_statement; 269, 270; 269, 271; 270, identifier:verbose; 271, block; 271, 272; 271, 281; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 279; 274, attribute; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:sys; 277, identifier:stderr; 278, identifier:write; 279, argument_list; 279, 280; 280, string:"."; 281, expression_statement; 281, 282; 282, call; 282, 283; 282, 288; 283, attribute; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:sys; 286, identifier:stderr; 287, identifier:flush; 288, argument_list; 289, else_clause; 289, 290; 290, block; 290, 291; 291, expression_statement; 291, 292; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:window; 295, identifier:append; 296, argument_list; 296, 297; 297, tuple; 297, 298; 297, 299; 298, identifier:rev_doc; 299, identifier:tokens_added; 300, while_statement; 300, 301; 300, 307; 301, comparison_operator:>; 301, 302; 301, 306; 302, call; 302, 303; 302, 304; 303, identifier:len; 304, argument_list; 304, 305; 305, identifier:window; 306, integer:0; 307, block; 307, 308; 307, 318; 307, 328; 307, 334; 307, 337; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 313; 310, pattern_list; 310, 311; 310, 312; 311, identifier:old_doc; 312, identifier:old_added; 313, call; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:window; 316, identifier:popleft; 317, argument_list; 318, expression_statement; 318, 319; 319, assignment; 319, 320; 319, 321; 320, identifier:persistence; 321, call; 321, 322; 321, 323; 322, identifier:token_persistence; 323, argument_list; 323, 324; 323, 325; 323, 326; 323, 327; 324, identifier:old_doc; 325, identifier:old_added; 326, identifier:window; 327, identifier:sunset; 328, expression_statement; 328, 329; 329, assignment; 329, 330; 329, 333; 330, subscript; 330, 331; 330, 332; 331, identifier:old_doc; 332, string:'persistence'; 333, identifier:persistence; 334, expression_statement; 334, 335; 335, yield; 335, 336; 336, identifier:old_doc; 337, if_statement; 337, 338; 337, 339; 338, identifier:verbose; 339, block; 339, 340; 339, 349; 340, expression_statement; 340, 341; 341, call; 341, 342; 341, 347; 342, attribute; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:sys; 345, identifier:stderr; 346, identifier:write; 347, argument_list; 347, 348; 348, string:"_"; 349, expression_statement; 349, 350; 350, call; 350, 351; 350, 356; 351, attribute; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:sys; 354, identifier:stderr; 355, identifier:flush; 356, argument_list; 357, if_statement; 357, 358; 357, 359; 358, identifier:verbose; 359, block; 359, 360; 360, expression_statement; 360, 361; 361, call; 361, 362; 361, 367; 362, attribute; 362, 363; 362, 366; 363, attribute; 363, 364; 363, 365; 364, identifier:sys; 365, identifier:stderr; 366, identifier:write; 367, argument_list; 367, 368; 368, string:"\n" | def diffs2persistence(rev_docs, window_size=50, revert_radius=15, sunset=None,
verbose=False):
rev_docs = mwxml.utilities.normalize(rev_docs)
window_size = int(window_size)
revert_radius = int(revert_radius)
sunset = Timestamp(sunset) if sunset is not None \
else Timestamp(time.time())
page_docs = groupby(rev_docs, key=lambda d: d['page']['title'])
for page_title, rev_docs in page_docs:
if verbose:
sys.stderr.write(page_title + ": ")
rev_docs = peekable(rev_docs)
window = deque(maxlen=window_size)
state = DiffState(revert_radius=revert_radius)
while rev_docs:
rev_doc = next(rev_docs)
next_doc = rev_docs.peek(None)
if next_doc is not None:
seconds_visible = Timestamp(next_doc['timestamp']) - \
Timestamp(rev_doc['timestamp'])
else:
seconds_visible = sunset - Timestamp(rev_doc['timestamp'])
if seconds_visible < 0:
logger.warn("Seconds visible {0} is less than zero."
.format(seconds_visible))
seconds_visible = 0
_, tokens_added, _ = \
state.update_opdocs(rev_doc['sha1'], rev_doc['diff']['ops'],
(rev_doc['user'], seconds_visible))
if len(window) == window_size:
old_doc, old_added = window[0]
window.append((rev_doc, tokens_added))
persistence = token_persistence(old_doc, old_added, window,
None)
old_doc['persistence'] = persistence
yield old_doc
if verbose:
sys.stderr.write(".")
sys.stderr.flush()
else:
window.append((rev_doc, tokens_added))
while len(window) > 0:
old_doc, old_added = window.popleft()
persistence = token_persistence(old_doc, old_added, window, sunset)
old_doc['persistence'] = persistence
yield old_doc
if verbose:
sys.stderr.write("_")
sys.stderr.flush()
if verbose:
sys.stderr.write("\n") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:qteAddWidget; 3, parameters; 3, 4; 3, 5; 3, 11; 3, 16; 3, 21; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:widgetObj; 7, type; 7, 8; 8, attribute; 8, 9; 8, 10; 9, identifier:QtGui; 10, identifier:QWidget; 11, typed_default_parameter; 11, 12; 11, 13; 11, 15; 12, identifier:isFocusable; 13, type; 13, 14; 14, identifier:bool; 15, True; 16, typed_default_parameter; 16, 17; 16, 18; 16, 20; 17, identifier:widgetSignature; 18, type; 18, 19; 19, identifier:str; 20, None; 21, typed_default_parameter; 21, 22; 21, 23; 21, 25; 22, identifier:autoBind; 23, type; 23, 24; 24, identifier:bool; 25, True; 26, block; 26, 27; 26, 39; 26, 51; 26, 59; 26, 71; 26, 98; 26, 102; 26, 112; 26, 122; 26, 124; 26, 135; 26, 141; 26, 267; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:widgetObj; 31, identifier:_qteAdmin; 32, call; 32, 33; 32, 34; 33, identifier:QtmacsAdminStructure; 34, argument_list; 34, 35; 34, 36; 35, identifier:self; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:isFocusable; 38, identifier:isFocusable; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:widgetObj; 44, identifier:_qteAdmin; 45, identifier:appletID; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_qteAdmin; 50, identifier:appletID; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:widgetObj; 56, identifier:_qteAdmin; 57, identifier:isQtmacsApplet; 58, False; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 66; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:widgetObj; 64, identifier:_qteAdmin; 65, identifier:appletSignature; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:qteAppletSignature; 70, argument_list; 71, if_statement; 71, 72; 71, 75; 71, 88; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:widgetSignature; 74, None; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:widgetObj; 81, identifier:_qteAdmin; 82, identifier:widgetSignature; 83, attribute; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:widgetObj; 86, identifier:__class__; 87, identifier:__name__; 88, else_clause; 88, 89; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 97; 92, attribute; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:widgetObj; 95, identifier:_qteAdmin; 96, identifier:widgetSignature; 97, identifier:widgetSignature; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:wo; 101, identifier:widgetObj; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:wo; 106, identifier:qteSignature; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:wo; 110, identifier:_qteAdmin; 111, identifier:widgetSignature; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:wo; 116, identifier:qteSetKeyFilterPolicy; 117, attribute; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:wo; 120, identifier:_qteAdmin; 121, identifier:qteSetKeyFilterPolicy; 122, delete_statement; 122, 123; 123, identifier:wo; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 133; 126, attribute; 126, 127; 126, 132; 127, attribute; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:_qteAdmin; 131, identifier:widgetList; 132, identifier:append; 133, argument_list; 133, 134; 134, identifier:widgetObj; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:default_bind; 138, attribute; 138, 139; 138, 140; 139, identifier:qte_global; 140, identifier:default_widget_keybindings; 141, if_statement; 141, 142; 141, 150; 142, boolean_operator:and; 142, 143; 142, 144; 143, identifier:autoBind; 144, parenthesized_expression; 144, 145; 145, comparison_operator:in; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:widgetObj; 148, identifier:qteSignature; 149, identifier:default_bind; 150, block; 150, 151; 150, 159; 150, 196; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:module_name; 154, subscript; 154, 155; 154, 156; 155, identifier:default_bind; 156, attribute; 156, 157; 156, 158; 157, identifier:widgetObj; 158, identifier:qteSignature; 159, try_statement; 159, 160; 159, 170; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:mod; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:importlib; 167, identifier:import_module; 168, argument_list; 168, 169; 169, identifier:module_name; 170, except_clause; 170, 171; 170, 172; 171, identifier:ImportError; 172, block; 172, 173; 172, 183; 172, 195; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:msg; 176, parenthesized_expression; 176, 177; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, string:'Module <b>{}</b> could not be imported.'; 180, identifier:format; 181, argument_list; 181, 182; 182, identifier:module_name; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 190; 185, attribute; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:qteLogger; 189, identifier:exception; 190, argument_list; 190, 191; 190, 192; 191, identifier:msg; 192, keyword_argument; 192, 193; 192, 194; 193, identifier:stack_info; 194, True; 195, return_statement; 196, if_statement; 196, 197; 196, 202; 196, 243; 197, call; 197, 198; 197, 199; 198, identifier:hasattr; 199, argument_list; 199, 200; 199, 201; 200, identifier:mod; 201, string:'install_macros_and_bindings'; 202, block; 202, 203; 203, try_statement; 203, 204; 203, 212; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:mod; 209, identifier:install_macros_and_bindings; 210, argument_list; 210, 211; 211, identifier:widgetObj; 212, except_clause; 212, 213; 212, 214; 213, identifier:Exception; 214, block; 214, 215; 214, 222; 214, 231; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:msg; 218, parenthesized_expression; 218, 219; 219, concatenated_string; 219, 220; 219, 221; 220, string:'<b>install_macros_and_bindings</b> function'; 221, string:' in <b>{}</b> did not execute properly.'; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:msg; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:msg; 228, identifier:format; 229, argument_list; 229, 230; 230, identifier:module_name; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 238; 233, attribute; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:self; 236, identifier:qteLogger; 237, identifier:error; 238, argument_list; 238, 239; 238, 240; 239, identifier:msg; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:stack_info; 242, True; 243, else_clause; 243, 244; 244, block; 244, 245; 244, 258; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:msg; 248, parenthesized_expression; 248, 249; 249, call; 249, 250; 249, 256; 250, attribute; 250, 251; 250, 255; 251, concatenated_string; 251, 252; 251, 253; 251, 254; 252, string:'Module <b>{}</b> has no '; 253, string:'<b>install_macros_and_bindings</b>'; 254, string:' method'; 255, identifier:format; 256, argument_list; 256, 257; 257, identifier:module_name; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 265; 260, attribute; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:self; 263, identifier:qteLogger; 264, identifier:error; 265, argument_list; 265, 266; 266, identifier:msg; 267, return_statement; 267, 268; 268, identifier:widgetObj | def qteAddWidget(self, widgetObj: QtGui.QWidget, isFocusable: bool=True,
widgetSignature: str=None, autoBind: bool=True):
widgetObj._qteAdmin = QtmacsAdminStructure(
self, isFocusable=isFocusable)
widgetObj._qteAdmin.appletID = self._qteAdmin.appletID
widgetObj._qteAdmin.isQtmacsApplet = False
widgetObj._qteAdmin.appletSignature = self.qteAppletSignature()
if widgetSignature is None:
widgetObj._qteAdmin.widgetSignature = widgetObj.__class__.__name__
else:
widgetObj._qteAdmin.widgetSignature = widgetSignature
wo = widgetObj
wo.qteSignature = wo._qteAdmin.widgetSignature
wo.qteSetKeyFilterPolicy = wo._qteAdmin.qteSetKeyFilterPolicy
del wo
self._qteAdmin.widgetList.append(widgetObj)
default_bind = qte_global.default_widget_keybindings
if autoBind and (widgetObj.qteSignature in default_bind):
module_name = default_bind[widgetObj.qteSignature]
try:
mod = importlib.import_module(module_name)
except ImportError:
msg = ('Module <b>{}</b> could not be imported.'.format(
module_name))
self.qteLogger.exception(msg, stack_info=True)
return
if hasattr(mod, 'install_macros_and_bindings'):
try:
mod.install_macros_and_bindings(widgetObj)
except Exception:
msg = ('<b>install_macros_and_bindings</b> function'
' in <b>{}</b> did not execute properly.')
msg = msg.format(module_name)
self.qteLogger.error(msg, stack_info=True)
else:
msg = ('Module <b>{}</b> has no '
'<b>install_macros_and_bindings</b>'
' method'.format(module_name))
self.qteLogger.error(msg)
return widgetObj |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:qteSetWidgetFocusOrder; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:widList; 7, type; 7, 8; 8, identifier:tuple; 9, block; 9, 10; 9, 19; 9, 25; 9, 37; 9, 68; 9, 75; 9, 95; 9, 104; 9, 123; 9, 140; 10, if_statement; 10, 11; 10, 17; 11, comparison_operator:<; 11, 12; 11, 16; 12, call; 12, 13; 12, 14; 13, identifier:len; 14, argument_list; 14, 15; 15, identifier:widList; 16, integer:2; 17, block; 17, 18; 18, return_statement; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:qteAutoremoveDeletedWidgets; 24, argument_list; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:widList; 28, list_comprehension; 28, 29; 28, 30; 28, 33; 29, identifier:_; 30, for_in_clause; 30, 31; 30, 32; 31, identifier:_; 32, identifier:widList; 33, if_clause; 33, 34; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:_; 36, None; 37, for_statement; 37, 38; 37, 39; 37, 40; 38, identifier:wid; 39, identifier:widList; 40, block; 40, 41; 41, if_statement; 41, 42; 41, 49; 42, comparison_operator:not; 42, 43; 42, 44; 43, identifier:wid; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_qteAdmin; 48, identifier:widgetList; 49, block; 49, 50; 49, 54; 49, 58; 49, 67; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:msg; 53, string:'Cannot change focus order because some '; 54, expression_statement; 54, 55; 55, augmented_assignment:+=; 55, 56; 55, 57; 56, identifier:msg; 57, string:'widgets do not exist.'; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:qteLogger; 64, identifier:warning; 65, argument_list; 65, 66; 66, identifier:msg; 67, return_statement; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:newList; 71, list:[widList[0]]; 71, 72; 72, subscript; 72, 73; 72, 74; 73, identifier:widList; 74, integer:0; 75, for_statement; 75, 76; 75, 77; 75, 82; 76, identifier:wid; 77, subscript; 77, 78; 77, 79; 78, identifier:widList; 79, slice; 79, 80; 79, 81; 80, integer:1; 81, colon; 82, block; 82, 83; 83, if_statement; 83, 84; 83, 87; 84, comparison_operator:not; 84, 85; 84, 86; 85, identifier:wid; 86, identifier:newList; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:newList; 92, identifier:append; 93, argument_list; 93, 94; 94, identifier:wid; 95, if_statement; 95, 96; 95, 102; 96, comparison_operator:<; 96, 97; 96, 101; 97, call; 97, 98; 97, 99; 98, identifier:len; 99, argument_list; 99, 100; 100, identifier:newList; 101, integer:2; 102, block; 102, 103; 103, return_statement; 104, for_statement; 104, 105; 104, 106; 104, 111; 105, identifier:wid; 106, subscript; 106, 107; 106, 108; 107, identifier:newList; 108, slice; 108, 109; 108, 110; 109, integer:1; 110, colon; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 121; 114, attribute; 114, 115; 114, 120; 115, attribute; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:_qteAdmin; 119, identifier:widgetList; 120, identifier:remove; 121, argument_list; 121, 122; 122, identifier:wid; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:startIdx; 126, binary_operator:+; 126, 127; 126, 139; 127, call; 127, 128; 127, 135; 128, attribute; 128, 129; 128, 134; 129, attribute; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:_qteAdmin; 133, identifier:widgetList; 134, identifier:index; 135, argument_list; 135, 136; 136, subscript; 136, 137; 136, 138; 137, identifier:newList; 138, integer:0; 139, integer:1; 140, for_statement; 140, 141; 140, 144; 140, 152; 141, pattern_list; 141, 142; 141, 143; 142, identifier:idx; 143, identifier:wid; 144, call; 144, 145; 144, 146; 145, identifier:enumerate; 146, argument_list; 146, 147; 147, subscript; 147, 148; 147, 149; 148, identifier:newList; 149, slice; 149, 150; 149, 151; 150, integer:1; 151, colon; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 162; 155, attribute; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:_qteAdmin; 160, identifier:widgetList; 161, identifier:insert; 162, argument_list; 162, 163; 162, 166; 163, binary_operator:+; 163, 164; 163, 165; 164, identifier:startIdx; 165, identifier:idx; 166, identifier:wid | def qteSetWidgetFocusOrder(self, widList: tuple):
if len(widList) < 2:
return
self.qteAutoremoveDeletedWidgets()
widList = [_ for _ in widList if _ is not None]
for wid in widList:
if wid not in self._qteAdmin.widgetList:
msg = 'Cannot change focus order because some '
msg += 'widgets do not exist.'
self.qteLogger.warning(msg)
return
newList = [widList[0]]
for wid in widList[1:]:
if wid not in newList:
newList.append(wid)
if len(newList) < 2:
return
for wid in newList[1:]:
self._qteAdmin.widgetList.remove(wid)
startIdx = self._qteAdmin.widgetList.index(newList[0]) + 1
for idx, wid in enumerate(newList[1:]):
self._qteAdmin.widgetList.insert(startIdx + idx, wid) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 37; 2, function_name:qteNextWidget; 3, parameters; 3, 4; 3, 5; 3, 10; 3, 17; 3, 22; 3, 27; 3, 32; 4, identifier:self; 5, typed_default_parameter; 5, 6; 5, 7; 5, 9; 6, identifier:numSkip; 7, type; 7, 8; 8, identifier:int; 9, integer:1; 10, typed_default_parameter; 10, 11; 10, 12; 10, 16; 11, identifier:ofsWidget; 12, type; 12, 13; 13, attribute; 13, 14; 13, 15; 14, identifier:QtGui; 15, identifier:QWidget; 16, None; 17, typed_default_parameter; 17, 18; 17, 19; 17, 21; 18, identifier:skipVisible; 19, type; 19, 20; 20, identifier:bool; 21, False; 22, typed_default_parameter; 22, 23; 22, 24; 22, 26; 23, identifier:skipInvisible; 24, type; 24, 25; 25, identifier:bool; 26, True; 27, typed_default_parameter; 27, 28; 27, 29; 27, 31; 28, identifier:skipFocusable; 29, type; 29, 30; 30, identifier:bool; 31, False; 32, typed_default_parameter; 32, 33; 32, 34; 32, 36; 33, identifier:skipUnfocusable; 34, type; 34, 35; 35, identifier:bool; 36, True; 37, block; 37, 38; 37, 64; 37, 70; 37, 81; 37, 106; 37, 123; 37, 141; 37, 159; 37, 176; 37, 185; 37, 196; 37, 215; 37, 233; 37, 245; 38, if_statement; 38, 39; 38, 50; 39, boolean_operator:and; 39, 40; 39, 46; 40, not_operator; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:hasattr; 43, argument_list; 43, 44; 43, 45; 44, identifier:ofsWidget; 45, string:'_qteAdmin'; 46, parenthesized_expression; 46, 47; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:ofsWidget; 49, None; 50, block; 50, 51; 50, 55; 50, 59; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:msg; 54, string:'<ofsWidget> was probably not added with <qteAddWidget>'; 55, expression_statement; 55, 56; 56, augmented_assignment:+=; 56, 57; 56, 58; 57, identifier:msg; 58, string:' method because it lacks the <_qteAdmin> attribute.'; 59, raise_statement; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:QtmacsOtherError; 62, argument_list; 62, 63; 63, identifier:msg; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:qteAutoremoveDeletedWidgets; 69, argument_list; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:widList; 73, call; 73, 74; 73, 75; 74, identifier:list; 75, argument_list; 75, 76; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:_qteAdmin; 80, identifier:widgetList; 81, if_statement; 81, 82; 81, 87; 82, not_operator; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:len; 85, argument_list; 85, 86; 86, identifier:widList; 87, block; 87, 88; 88, if_statement; 88, 89; 88, 97; 88, 102; 89, comparison_operator:is; 89, 90; 89, 96; 90, call; 90, 91; 90, 92; 91, identifier:qteGetAppletFromWidget; 92, argument_list; 92, 93; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:_qteActiveWidget; 96, identifier:self; 97, block; 97, 98; 98, return_statement; 98, 99; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:_qteActiveWidget; 102, else_clause; 102, 103; 103, block; 103, 104; 104, return_statement; 104, 105; 105, None; 106, if_statement; 106, 107; 106, 108; 107, identifier:skipInvisible; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:widList; 112, list_comprehension; 112, 113; 112, 114; 112, 117; 113, identifier:wid; 114, for_in_clause; 114, 115; 114, 116; 115, identifier:wid; 116, identifier:widList; 117, if_clause; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:wid; 121, identifier:isVisible; 122, argument_list; 123, if_statement; 123, 124; 123, 125; 124, identifier:skipVisible; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:widList; 129, list_comprehension; 129, 130; 129, 131; 129, 134; 130, identifier:wid; 131, for_in_clause; 131, 132; 131, 133; 132, identifier:wid; 133, identifier:widList; 134, if_clause; 134, 135; 135, not_operator; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:wid; 139, identifier:isVisible; 140, argument_list; 141, if_statement; 141, 142; 141, 143; 142, identifier:skipFocusable; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:widList; 147, list_comprehension; 147, 148; 147, 149; 147, 152; 148, identifier:wid; 149, for_in_clause; 149, 150; 149, 151; 150, identifier:wid; 151, identifier:widList; 152, if_clause; 152, 153; 153, not_operator; 153, 154; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:wid; 157, identifier:_qteAdmin; 158, identifier:isFocusable; 159, if_statement; 159, 160; 159, 161; 160, identifier:skipUnfocusable; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:widList; 165, list_comprehension; 165, 166; 165, 167; 165, 170; 166, identifier:wid; 167, for_in_clause; 167, 168; 167, 169; 168, identifier:wid; 169, identifier:widList; 170, if_clause; 170, 171; 171, attribute; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:wid; 174, identifier:_qteAdmin; 175, identifier:isFocusable; 176, if_statement; 176, 177; 176, 182; 177, not_operator; 177, 178; 178, call; 178, 179; 178, 180; 179, identifier:len; 180, argument_list; 180, 181; 181, identifier:widList; 182, block; 182, 183; 183, return_statement; 183, 184; 184, None; 185, if_statement; 185, 186; 185, 189; 186, comparison_operator:is; 186, 187; 186, 188; 187, identifier:ofsWidget; 188, None; 189, block; 189, 190; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:ofsWidget; 193, attribute; 193, 194; 193, 195; 194, identifier:self; 195, identifier:_qteActiveWidget; 196, if_statement; 196, 197; 196, 206; 197, boolean_operator:and; 197, 198; 197, 202; 198, parenthesized_expression; 198, 199; 199, comparison_operator:is; 199, 200; 199, 201; 200, identifier:ofsWidget; 201, None; 202, parenthesized_expression; 202, 203; 203, comparison_operator:==; 203, 204; 203, 205; 204, identifier:numSkip; 205, integer:0; 206, block; 206, 207; 207, if_statement; 207, 208; 207, 212; 208, call; 208, 209; 208, 210; 209, identifier:qteIsQtmacsWidget; 210, argument_list; 210, 211; 211, identifier:ofsWidget; 212, block; 212, 213; 213, return_statement; 213, 214; 214, identifier:ofsWidget; 215, try_statement; 215, 216; 215, 226; 216, block; 216, 217; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:ofsIdx; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:widList; 223, identifier:index; 224, argument_list; 224, 225; 225, identifier:ofsWidget; 226, except_clause; 226, 227; 226, 228; 227, identifier:ValueError; 228, block; 228, 229; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:ofsIdx; 232, integer:0; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:ofsIdx; 236, binary_operator:%; 236, 237; 236, 241; 237, parenthesized_expression; 237, 238; 238, binary_operator:+; 238, 239; 238, 240; 239, identifier:ofsIdx; 240, identifier:numSkip; 241, call; 241, 242; 241, 243; 242, identifier:len; 243, argument_list; 243, 244; 244, identifier:widList; 245, return_statement; 245, 246; 246, subscript; 246, 247; 246, 248; 247, identifier:widList; 248, identifier:ofsIdx | def qteNextWidget(self, numSkip: int=1, ofsWidget: QtGui.QWidget=None,
skipVisible: bool=False, skipInvisible: bool=True,
skipFocusable: bool=False,
skipUnfocusable: bool=True):
if not hasattr(ofsWidget, '_qteAdmin') and (ofsWidget is not None):
msg = '<ofsWidget> was probably not added with <qteAddWidget>'
msg += ' method because it lacks the <_qteAdmin> attribute.'
raise QtmacsOtherError(msg)
self.qteAutoremoveDeletedWidgets()
widList = list(self._qteAdmin.widgetList)
if not len(widList):
if qteGetAppletFromWidget(self._qteActiveWidget) is self:
return self._qteActiveWidget
else:
return None
if skipInvisible:
widList = [wid for wid in widList if wid.isVisible()]
if skipVisible:
widList = [wid for wid in widList if not wid.isVisible()]
if skipFocusable:
widList = [wid for wid in widList if not wid._qteAdmin.isFocusable]
if skipUnfocusable:
widList = [wid for wid in widList if wid._qteAdmin.isFocusable]
if not len(widList):
return None
if ofsWidget is None:
ofsWidget = self._qteActiveWidget
if (ofsWidget is not None) and (numSkip == 0):
if qteIsQtmacsWidget(ofsWidget):
return ofsWidget
try:
ofsIdx = widList.index(ofsWidget)
except ValueError:
ofsIdx = 0
ofsIdx = (ofsIdx + numSkip) % len(widList)
return widList[ofsIdx] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:qteMakeWidgetActive; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:widgetObj; 7, type; 7, 8; 8, attribute; 8, 9; 8, 10; 9, identifier:QtGui; 10, identifier:QWidget; 11, block; 11, 12; 11, 24; 11, 41; 11, 56; 11, 70; 11, 76; 11, 108; 11, 119; 12, if_statement; 12, 13; 12, 16; 13, comparison_operator:is; 13, 14; 13, 15; 14, identifier:widgetObj; 15, None; 16, block; 16, 17; 16, 23; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:_qteActiveWidget; 22, None; 23, return_statement; 24, if_statement; 24, 25; 24, 31; 25, comparison_operator:is; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:qteGetAppletFromWidget; 28, argument_list; 28, 29; 29, identifier:widgetObj; 30, identifier:self; 31, block; 31, 32; 31, 36; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:msg; 35, string:'The specified widget is not inside the current applet.'; 36, raise_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:QtmacsOtherError; 39, argument_list; 39, 40; 40, identifier:msg; 41, if_statement; 41, 42; 41, 48; 42, not_operator; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:hasattr; 45, argument_list; 45, 46; 45, 47; 46, identifier:widgetObj; 47, string:'_qteAdmin'; 48, block; 48, 49; 48, 55; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:_qteActiveWidget; 54, identifier:widgetObj; 55, return_statement; 56, if_statement; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:widgetObj; 60, identifier:_qteAdmin; 61, identifier:isQtmacsApplet; 62, block; 62, 63; 62, 69; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:_qteActiveWidget; 68, None; 69, return_statement; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:qteAutoremoveDeletedWidgets; 75, argument_list; 76, if_statement; 76, 77; 76, 84; 77, comparison_operator:not; 77, 78; 77, 79; 78, identifier:widgetObj; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:_qteAdmin; 83, identifier:widgetList; 84, block; 84, 85; 84, 89; 84, 101; 84, 107; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:msg; 88, string:'Widget is not registered for this applet.'; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 96; 91, attribute; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:qteLogger; 95, identifier:error; 96, argument_list; 96, 97; 96, 98; 97, identifier:msg; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:stack_info; 100, True; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:_qteActiveWidget; 106, None; 107, return_statement; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:qteSetWidgetFocusOrder; 113, argument_list; 113, 114; 114, tuple; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:_qteActiveWidget; 118, identifier:widgetObj; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:_qteActiveWidget; 124, identifier:widgetObj | def qteMakeWidgetActive(self, widgetObj: QtGui.QWidget):
if widgetObj is None:
self._qteActiveWidget = None
return
if qteGetAppletFromWidget(widgetObj) is not self:
msg = 'The specified widget is not inside the current applet.'
raise QtmacsOtherError(msg)
if not hasattr(widgetObj, '_qteAdmin'):
self._qteActiveWidget = widgetObj
return
if widgetObj._qteAdmin.isQtmacsApplet:
self._qteActiveWidget = None
return
self.qteAutoremoveDeletedWidgets()
if widgetObj not in self._qteAdmin.widgetList:
msg = 'Widget is not registered for this applet.'
self.qteLogger.error(msg, stack_info=True)
self._qteActiveWidget = None
return
self.qteSetWidgetFocusOrder((self._qteActiveWidget, widgetObj))
self._qteActiveWidget = widgetObj |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:make_result; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 4, identifier:self; 5, identifier:result_class; 6, default_parameter; 6, 7; 6, 8; 7, identifier:node; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:prev_node; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:remember; 14, True; 15, default_parameter; 15, 16; 15, 17; 16, identifier:key_chunks; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:notify; 20, True; 21, dictionary_splat_pattern; 21, 22; 22, identifier:kwargs; 23, block; 23, 24; 23, 44; 23, 50; 23, 69; 23, 75; 23, 100; 23, 111; 23, 131; 23, 138; 23, 174; 23, 206; 24, function_definition; 24, 25; 24, 26; 24, 30; 25, function_name:canonicalize; 26, parameters; 26, 27; 26, 28; 27, identifier:node; 28, dictionary_splat_pattern; 28, 29; 29, identifier:kwargs; 30, block; 30, 31; 31, return_statement; 31, 32; 32, conditional_expression:if; 32, 33; 32, 34; 32, 37; 33, None; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:node; 36, None; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:node; 40, identifier:canonicalize; 41, argument_list; 41, 42; 42, dictionary_splat; 42, 43; 43, identifier:kwargs; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:index; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:index; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:result; 53, call; 53, 54; 53, 55; 54, identifier:result_class; 55, argument_list; 55, 56; 55, 62; 55, 68; 56, call; 56, 57; 56, 58; 57, identifier:canonicalize; 58, argument_list; 58, 59; 58, 60; 59, identifier:node; 60, dictionary_splat; 60, 61; 61, identifier:kwargs; 62, call; 62, 63; 62, 64; 63, identifier:canonicalize; 64, argument_list; 64, 65; 64, 66; 65, identifier:prev_node; 66, dictionary_splat; 66, 67; 67, identifier:kwargs; 68, identifier:index; 69, if_statement; 69, 70; 69, 72; 70, not_operator; 70, 71; 71, identifier:remember; 72, block; 72, 73; 73, return_statement; 73, 74; 74, identifier:result; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 82; 77, subscript; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:history; 81, identifier:index; 82, call; 82, 83; 82, 84; 83, identifier:result_class; 84, argument_list; 84, 85; 84, 92; 84, 99; 85, call; 85, 86; 85, 87; 86, identifier:canonicalize; 87, argument_list; 87, 88; 87, 89; 88, identifier:node; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:include_nodes; 91, False; 92, call; 92, 93; 92, 94; 93, identifier:canonicalize; 94, argument_list; 94, 95; 94, 96; 95, identifier:prev_node; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:include_nodes; 98, False; 99, identifier:index; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:key_chunks; 103, boolean_operator:or; 103, 104; 103, 105; 104, identifier:key_chunks; 105, call; 105, 106; 105, 107; 106, identifier:split_key; 107, argument_list; 107, 108; 108, attribute; 108, 109; 108, 110; 109, identifier:node; 110, identifier:key; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:asymptotic_key_chunks; 114, generator_expression; 114, 115; 114, 122; 115, subscript; 115, 116; 115, 117; 116, identifier:key_chunks; 117, slice; 117, 118; 117, 119; 118, colon; 119, binary_operator:+; 119, 120; 119, 121; 120, identifier:x; 121, integer:1; 122, for_in_clause; 122, 123; 122, 124; 123, identifier:x; 124, call; 124, 125; 124, 126; 125, identifier:xrange; 126, argument_list; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:len; 129, argument_list; 129, 130; 130, identifier:key_chunks; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:event_keys; 134, list:[(False, key_chunks)]; 134, 135; 135, tuple; 135, 136; 135, 137; 136, False; 137, identifier:key_chunks; 138, for_statement; 138, 139; 138, 140; 138, 141; 139, identifier:_key_chunks; 140, identifier:asymptotic_key_chunks; 141, block; 141, 142; 141, 148; 141, 165; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:exact; 145, comparison_operator:==; 145, 146; 145, 147; 146, identifier:_key_chunks; 147, identifier:key_chunks; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 161; 150, attribute; 150, 151; 150, 160; 151, call; 151, 152; 151, 157; 152, attribute; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:indices; 156, identifier:setdefault; 157, argument_list; 157, 158; 157, 159; 158, identifier:_key_chunks; 159, list:[]; 160, identifier:append; 161, argument_list; 161, 162; 162, tuple; 162, 163; 162, 164; 163, identifier:index; 164, identifier:exact; 165, expression_statement; 165, 166; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:event_keys; 169, identifier:append; 170, argument_list; 170, 171; 171, tuple; 171, 172; 171, 173; 172, True; 173, identifier:_key_chunks; 174, if_statement; 174, 175; 174, 176; 175, identifier:notify; 176, block; 176, 177; 177, for_statement; 177, 178; 177, 179; 177, 180; 178, identifier:event_key; 179, identifier:event_keys; 180, block; 180, 181; 181, try_statement; 181, 182; 181, 194; 181, 198; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:event; 186, call; 186, 187; 186, 192; 187, attribute; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:self; 190, identifier:events; 191, identifier:pop; 192, argument_list; 192, 193; 193, identifier:event_key; 194, except_clause; 194, 195; 194, 196; 195, identifier:KeyError; 196, block; 196, 197; 197, pass_statement; 198, else_clause; 198, 199; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:event; 204, identifier:set; 205, argument_list; 206, return_statement; 206, 207; 207, identifier:result | def make_result(self, result_class, node=None, prev_node=None,
remember=True, key_chunks=None, notify=True, **kwargs):
def canonicalize(node, **kwargs):
return None if node is None else node.canonicalize(**kwargs)
index = self.index
result = result_class(canonicalize(node, **kwargs),
canonicalize(prev_node, **kwargs), index)
if not remember:
return result
self.history[index] = result_class(
canonicalize(node, include_nodes=False),
canonicalize(prev_node, include_nodes=False), index)
key_chunks = key_chunks or split_key(node.key)
asymptotic_key_chunks = (key_chunks[:x + 1]
for x in xrange(len(key_chunks)))
event_keys = [(False, key_chunks)]
for _key_chunks in asymptotic_key_chunks:
exact = _key_chunks == key_chunks
self.indices.setdefault(_key_chunks, []).append((index, exact))
event_keys.append((True, _key_chunks))
if notify:
for event_key in event_keys:
try:
event = self.events.pop(event_key)
except KeyError:
pass
else:
event.set()
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_class_frame_source; 3, parameters; 3, 4; 4, identifier:class_name; 5, block; 5, 6; 5, 181; 6, for_statement; 6, 7; 6, 8; 6, 13; 7, identifier:frame_info; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:inspect; 11, identifier:stack; 12, argument_list; 13, block; 13, 14; 13, 54; 14, try_statement; 14, 15; 14, 50; 15, block; 15, 16; 16, with_statement; 16, 17; 16, 28; 17, with_clause; 17, 18; 18, with_item; 18, 19; 19, as_pattern; 19, 20; 19, 26; 20, call; 20, 21; 20, 22; 21, identifier:open; 22, argument_list; 22, 23; 23, subscript; 23, 24; 23, 25; 24, identifier:frame_info; 25, integer:1; 26, as_pattern_target; 26, 27; 27, identifier:fp; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:src; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, string:""; 35, identifier:join; 36, argument_list; 36, 37; 37, subscript; 37, 38; 37, 43; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:fp; 41, identifier:readlines; 42, argument_list; 43, slice; 43, 44; 43, 49; 44, binary_operator:-; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:frame_info; 47, integer:2; 48, integer:1; 49, colon; 50, except_clause; 50, 51; 50, 52; 51, identifier:IOError; 52, block; 52, 53; 53, continue_statement; 54, if_statement; 54, 55; 54, 67; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:re; 58, identifier:search; 59, argument_list; 59, 60; 59, 66; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, string:r"\bclass\b\s+\b{}\b"; 63, identifier:format; 64, argument_list; 64, 65; 65, identifier:class_name; 66, identifier:src; 67, block; 67, 68; 67, 79; 67, 88; 67, 92; 67, 96; 67, 100; 67, 104; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:reader; 71, attribute; 71, 72; 71, 78; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:six; 75, identifier:StringIO; 76, argument_list; 76, 77; 77, identifier:src; 78, identifier:readline; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:tokens; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:tokenize; 85, identifier:generate_tokens; 86, argument_list; 86, 87; 87, identifier:reader; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:source_tokens; 91, list:[]; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:indent_level; 95, integer:0; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:base_indent_level; 99, integer:0; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:has_base_level; 103, False; 104, for_statement; 104, 105; 104, 111; 104, 112; 105, pattern_list; 105, 106; 105, 107; 105, 108; 105, 109; 105, 110; 106, identifier:token; 107, identifier:value; 108, identifier:_; 109, identifier:_; 110, identifier:_; 111, identifier:tokens; 112, block; 112, 113; 112, 122; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:source_tokens; 117, identifier:append; 118, argument_list; 118, 119; 119, tuple; 119, 120; 119, 121; 120, identifier:token; 121, identifier:value; 122, if_statement; 122, 123; 122, 128; 122, 133; 122, 169; 123, comparison_operator:==; 123, 124; 123, 125; 124, identifier:token; 125, attribute; 125, 126; 125, 127; 126, identifier:tokenize; 127, identifier:INDENT; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, augmented_assignment:+=; 130, 131; 130, 132; 131, identifier:indent_level; 132, integer:1; 133, elif_clause; 133, 134; 133, 139; 134, comparison_operator:==; 134, 135; 134, 136; 135, identifier:token; 136, attribute; 136, 137; 136, 138; 137, identifier:tokenize; 138, identifier:DEDENT; 139, block; 139, 140; 139, 144; 140, expression_statement; 140, 141; 141, augmented_assignment:-=; 141, 142; 141, 143; 142, identifier:indent_level; 143, integer:1; 144, if_statement; 144, 145; 144, 150; 145, boolean_operator:and; 145, 146; 145, 147; 146, identifier:has_base_level; 147, comparison_operator:<=; 147, 148; 147, 149; 148, identifier:indent_level; 149, identifier:base_indent_level; 150, block; 150, 151; 151, return_statement; 151, 152; 152, tuple; 152, 153; 152, 159; 152, 164; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:tokenize; 156, identifier:untokenize; 157, argument_list; 157, 158; 158, identifier:source_tokens; 159, attribute; 159, 160; 159, 163; 160, subscript; 160, 161; 160, 162; 161, identifier:frame_info; 162, integer:0; 163, identifier:f_globals; 164, attribute; 164, 165; 164, 168; 165, subscript; 165, 166; 165, 167; 166, identifier:frame_info; 167, integer:0; 168, identifier:f_locals; 169, elif_clause; 169, 170; 169, 172; 170, not_operator; 170, 171; 171, identifier:has_base_level; 172, block; 172, 173; 172, 177; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:has_base_level; 176, True; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:base_indent_level; 180, identifier:indent_level; 181, raise_statement; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:TypeError; 184, argument_list; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, string:'Unable to retrieve source for class "{}"'; 188, identifier:format; 189, argument_list; 189, 190; 190, identifier:class_name | def _get_class_frame_source(class_name):
for frame_info in inspect.stack():
try:
with open(frame_info[1]) as fp:
src = "".join(fp.readlines()[frame_info[2] - 1 :])
except IOError:
continue
if re.search(r"\bclass\b\s+\b{}\b".format(class_name), src):
reader = six.StringIO(src).readline
tokens = tokenize.generate_tokens(reader)
source_tokens = []
indent_level = 0
base_indent_level = 0
has_base_level = False
for token, value, _, _, _ in tokens:
source_tokens.append((token, value))
if token == tokenize.INDENT:
indent_level += 1
elif token == tokenize.DEDENT:
indent_level -= 1
if has_base_level and indent_level <= base_indent_level:
return (
tokenize.untokenize(source_tokens),
frame_info[0].f_globals,
frame_info[0].f_locals,
)
elif not has_base_level:
has_base_level = True
base_indent_level = indent_level
raise TypeError(
'Unable to retrieve source for class "{}"'.format(class_name)
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_create_typed_object_meta; 3, parameters; 3, 4; 4, identifier:get_fset; 5, block; 5, 6; 5, 45; 5, 282; 6, function_definition; 6, 7; 6, 8; 6, 12; 7, function_name:_get_fget; 8, parameters; 8, 9; 8, 10; 8, 11; 9, identifier:attr; 10, identifier:private_attr; 11, identifier:type_; 12, block; 12, 13; 12, 43; 13, function_definition; 13, 14; 13, 15; 13, 17; 14, function_name:_fget; 15, parameters; 15, 16; 16, identifier:self; 17, block; 17, 18; 18, try_statement; 18, 19; 18, 26; 19, block; 19, 20; 20, return_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:getattr; 23, argument_list; 23, 24; 23, 25; 24, identifier:self; 25, identifier:private_attr; 26, except_clause; 26, 27; 26, 28; 27, identifier:AttributeError; 28, block; 28, 29; 29, raise_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:AttributeError; 32, argument_list; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, string:"'{}' object has no attribute '{}'"; 36, identifier:format; 37, argument_list; 37, 38; 37, 42; 38, call; 38, 39; 38, 40; 39, identifier:_get_type_name; 40, argument_list; 40, 41; 41, identifier:type_; 42, identifier:attr; 43, return_statement; 43, 44; 44, identifier:_fget; 45, class_definition; 45, 46; 45, 47; 45, 49; 46, identifier:_AnnotatedObjectMeta; 47, argument_list; 47, 48; 48, identifier:type; 49, block; 49, 50; 50, function_definition; 50, 51; 50, 52; 50, 59; 51, function_name:__new__; 52, parameters; 52, 53; 52, 54; 52, 55; 52, 56; 52, 57; 53, identifier:mcs; 54, identifier:name; 55, identifier:bases; 56, identifier:attrs; 57, dictionary_splat_pattern; 57, 58; 58, identifier:kwargs; 59, block; 59, 60; 59, 70; 59, 85; 59, 103; 59, 115; 59, 119; 59, 210; 59, 226; 59, 232; 59, 266; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:annotations; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:attrs; 66, identifier:get; 67, argument_list; 67, 68; 67, 69; 68, string:"__annotations__"; 69, dictionary; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:use_comment_type_hints; 73, parenthesized_expression; 73, 74; 74, boolean_operator:and; 74, 75; 74, 77; 75, not_operator; 75, 76; 76, identifier:annotations; 77, comparison_operator:!=; 77, 78; 77, 84; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:attrs; 81, identifier:get; 82, argument_list; 82, 83; 83, string:"__module__"; 84, identifier:__name__; 85, if_statement; 85, 86; 85, 87; 86, identifier:use_comment_type_hints; 87, block; 87, 88; 87, 95; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:frame_source; 91, call; 91, 92; 91, 93; 92, identifier:_get_class_frame_source; 93, argument_list; 93, 94; 94, identifier:name; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:annotations; 98, call; 98, 99; 98, 100; 99, identifier:get_type_hints; 100, argument_list; 100, 101; 101, list_splat; 101, 102; 102, identifier:frame_source; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:names; 106, binary_operator:+; 106, 107; 106, 111; 107, call; 107, 108; 107, 109; 108, identifier:list; 109, argument_list; 109, 110; 110, identifier:attrs; 111, call; 111, 112; 111, 113; 112, identifier:list; 113, argument_list; 113, 114; 114, identifier:annotations; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:typed_attrs; 118, dictionary; 119, for_statement; 119, 120; 119, 121; 119, 122; 120, identifier:attr; 121, identifier:names; 122, block; 122, 123; 122, 134; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:typed_attrs; 127, identifier:attr; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:attrs; 131, identifier:get; 132, argument_list; 132, 133; 133, identifier:attr; 134, if_statement; 134, 135; 134, 142; 135, call; 135, 136; 135, 137; 136, identifier:_is_propertyable; 137, argument_list; 137, 138; 137, 139; 137, 140; 137, 141; 138, identifier:names; 139, identifier:attrs; 140, identifier:annotations; 141, identifier:attr; 142, block; 142, 143; 142, 152; 142, 165; 142, 190; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:private_attr; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, string:"__{}"; 149, identifier:format; 150, argument_list; 150, 151; 151, identifier:attr; 152, if_statement; 152, 153; 152, 156; 153, comparison_operator:in; 153, 154; 153, 155; 154, identifier:attr; 155, identifier:attrs; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 162; 159, subscript; 159, 160; 159, 161; 160, identifier:typed_attrs; 161, identifier:private_attr; 162, subscript; 162, 163; 162, 164; 163, identifier:attrs; 164, identifier:attr; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:type_; 168, parenthesized_expression; 168, 169; 169, conditional_expression:if; 169, 170; 169, 175; 169, 187; 170, subscript; 170, 171; 170, 172; 171, identifier:Optional; 172, subscript; 172, 173; 172, 174; 173, identifier:annotations; 174, identifier:attr; 175, boolean_operator:and; 175, 176; 175, 182; 176, boolean_operator:and; 176, 177; 176, 179; 177, not_operator; 177, 178; 178, identifier:use_comment_type_hints; 179, comparison_operator:in; 179, 180; 179, 181; 180, identifier:attr; 181, identifier:attrs; 182, comparison_operator:is; 182, 183; 182, 186; 183, subscript; 183, 184; 183, 185; 184, identifier:attrs; 185, identifier:attr; 186, None; 187, subscript; 187, 188; 187, 189; 188, identifier:annotations; 189, identifier:attr; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 195; 192, subscript; 192, 193; 192, 194; 193, identifier:typed_attrs; 194, identifier:attr; 195, call; 195, 196; 195, 197; 196, identifier:property; 197, argument_list; 197, 198; 197, 204; 198, call; 198, 199; 198, 200; 199, identifier:_get_fget; 200, argument_list; 200, 201; 200, 202; 200, 203; 201, identifier:attr; 202, identifier:private_attr; 203, identifier:type_; 204, call; 204, 205; 204, 206; 205, identifier:get_fset; 206, argument_list; 206, 207; 206, 208; 206, 209; 207, identifier:attr; 208, identifier:private_attr; 209, identifier:type_; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:properties; 213, list_comprehension; 213, 214; 213, 215; 213, 218; 214, identifier:attr; 215, for_in_clause; 215, 216; 215, 217; 216, identifier:attr; 217, identifier:annotations; 218, if_clause; 218, 219; 219, call; 219, 220; 219, 221; 220, identifier:_is_propertyable; 221, argument_list; 221, 222; 221, 223; 221, 224; 221, 225; 222, identifier:names; 223, identifier:attrs; 224, identifier:annotations; 225, identifier:attr; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 231; 228, subscript; 228, 229; 228, 230; 229, identifier:typed_attrs; 230, string:"_tp__typed_properties"; 231, identifier:properties; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 237; 234, subscript; 234, 235; 234, 236; 235, identifier:typed_attrs; 236, string:"_tp__required_typed_properties"; 237, list_comprehension; 237, 238; 237, 239; 237, 242; 238, identifier:attr; 239, for_in_clause; 239, 240; 239, 241; 240, identifier:attr; 241, identifier:properties; 242, if_clause; 242, 243; 243, boolean_operator:and; 243, 244; 243, 256; 244, parenthesized_expression; 244, 245; 245, boolean_operator:or; 245, 246; 245, 249; 246, comparison_operator:not; 246, 247; 246, 248; 247, identifier:attr; 248, identifier:attrs; 249, boolean_operator:and; 249, 250; 249, 255; 250, comparison_operator:is; 250, 251; 250, 254; 251, subscript; 251, 252; 251, 253; 252, identifier:attrs; 253, identifier:attr; 254, None; 255, identifier:use_comment_type_hints; 256, comparison_operator:not; 256, 257; 256, 258; 257, identifier:NoneType; 258, call; 258, 259; 258, 260; 259, identifier:getattr; 260, argument_list; 260, 261; 260, 264; 260, 265; 261, subscript; 261, 262; 261, 263; 262, identifier:annotations; 263, identifier:attr; 264, string:"__args__"; 265, tuple; 266, return_statement; 266, 267; 267, call; 267, 268; 267, 275; 268, attribute; 268, 269; 268, 274; 269, call; 269, 270; 269, 271; 270, identifier:super; 271, argument_list; 271, 272; 271, 273; 272, identifier:_AnnotatedObjectMeta; 273, identifier:mcs; 274, identifier:__new__; 275, argument_list; 275, 276; 275, 277; 275, 278; 275, 279; 275, 280; 276, identifier:mcs; 277, identifier:name; 278, identifier:bases; 279, identifier:typed_attrs; 280, dictionary_splat; 280, 281; 281, identifier:kwargs; 282, return_statement; 282, 283; 283, identifier:_AnnotatedObjectMeta | def _create_typed_object_meta(get_fset):
def _get_fget(attr, private_attr, type_):
def _fget(self):
try:
return getattr(self, private_attr)
except AttributeError:
raise AttributeError(
"'{}' object has no attribute '{}'".format(
_get_type_name(type_), attr
)
)
return _fget
class _AnnotatedObjectMeta(type):
def __new__(
mcs,
name,
bases,
attrs,
**kwargs
):
annotations = attrs.get("__annotations__", {})
use_comment_type_hints = (
not annotations and attrs.get("__module__") != __name__
)
if use_comment_type_hints:
frame_source = _get_class_frame_source(name)
annotations = get_type_hints(*frame_source)
names = list(attrs) + list(annotations)
typed_attrs = {}
for attr in names:
typed_attrs[attr] = attrs.get(attr)
if _is_propertyable(names, attrs, annotations, attr):
private_attr = "__{}".format(attr)
if attr in attrs:
typed_attrs[private_attr] = attrs[attr]
type_ = (
Optional[annotations[attr]]
if not use_comment_type_hints
and attr in attrs
and attrs[attr] is None
else annotations[attr]
)
typed_attrs[attr] = property(
_get_fget(attr, private_attr, type_),
get_fset(attr, private_attr, type_),
)
properties = [
attr
for attr in annotations
if _is_propertyable(names, attrs, annotations, attr)
]
typed_attrs["_tp__typed_properties"] = properties
typed_attrs["_tp__required_typed_properties"] = [
attr
for attr in properties
if (
attr not in attrs
or attrs[attr] is None
and use_comment_type_hints
)
and NoneType not in getattr(annotations[attr], "__args__", ())
]
return super(_AnnotatedObjectMeta, mcs).__new__(
mcs, name, bases, typed_attrs, **kwargs
)
return _AnnotatedObjectMeta |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_build_module_db; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 16; 5, 72; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:tdict; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:collections; 12, identifier:defaultdict; 13, argument_list; 13, 14; 14, lambda; 14, 15; 15, list:[]; 16, for_statement; 16, 17; 16, 20; 16, 29; 17, pattern_list; 17, 18; 17, 19; 18, identifier:callable_name; 19, identifier:callable_dict; 20, call; 20, 21; 20, 28; 21, attribute; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:_exh_obj; 26, identifier:callables_db; 27, identifier:items; 28, argument_list; 29, block; 29, 30; 29, 38; 29, 57; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, pattern_list; 32, 33; 32, 34; 33, identifier:fname; 34, identifier:line_no; 35, subscript; 35, 36; 35, 37; 36, identifier:callable_dict; 37, string:"code_id"; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:cname; 41, parenthesized_expression; 41, 42; 42, conditional_expression:if; 42, 43; 42, 51; 42, 56; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, string:"{cls_name}.__init__"; 46, identifier:format; 47, argument_list; 47, 48; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:cls_name; 50, identifier:callable_name; 51, comparison_operator:==; 51, 52; 51, 55; 52, subscript; 52, 53; 52, 54; 53, identifier:callable_dict; 54, string:"type"; 55, string:"class"; 56, identifier:callable_name; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, subscript; 60, 61; 60, 62; 61, identifier:tdict; 62, identifier:fname; 63, identifier:append; 64, argument_list; 64, 65; 65, dictionary; 65, 66; 65, 69; 66, pair; 66, 67; 66, 68; 67, string:"name"; 68, identifier:cname; 69, pair; 69, 70; 69, 71; 70, string:"line"; 71, identifier:line_no; 72, for_statement; 72, 73; 72, 74; 72, 79; 73, identifier:fname; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:tdict; 77, identifier:keys; 78, argument_list; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 87; 82, subscript; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:_module_obj_db; 86, identifier:fname; 87, call; 87, 88; 87, 89; 88, identifier:sorted; 89, argument_list; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:tdict; 92, identifier:fname; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:key; 95, lambda; 95, 96; 95, 98; 96, lambda_parameters; 96, 97; 97, identifier:idict; 98, subscript; 98, 99; 98, 100; 99, identifier:idict; 100, string:"line" | def _build_module_db(self):
tdict = collections.defaultdict(lambda: [])
for callable_name, callable_dict in self._exh_obj.callables_db.items():
fname, line_no = callable_dict["code_id"]
cname = (
"{cls_name}.__init__".format(cls_name=callable_name)
if callable_dict["type"] == "class"
else callable_name
)
tdict[fname].append({"name": cname, "line": line_no})
for fname in tdict.keys():
self._module_obj_db[fname] = sorted(
tdict[fname], key=lambda idict: idict["line"]
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:merge; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:cls; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 23; 9, 35; 9, 69; 9, 75; 9, 84; 9, 185; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:newkeys; 13, call; 13, 14; 13, 15; 14, identifier:bool; 15, argument_list; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:kwargs; 19, identifier:get; 20, argument_list; 20, 21; 20, 22; 21, string:'newkeys'; 22, False; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:ignore; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:kwargs; 29, identifier:get; 30, argument_list; 30, 31; 30, 32; 31, string:'ignore'; 32, call; 32, 33; 32, 34; 33, identifier:list; 34, argument_list; 35, if_statement; 35, 36; 35, 42; 35, 48; 36, comparison_operator:<; 36, 37; 36, 41; 37, call; 37, 38; 37, 39; 38, identifier:len; 39, argument_list; 39, 40; 40, identifier:args; 41, integer:1; 42, block; 42, 43; 43, raise_statement; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:ValueError; 46, argument_list; 46, 47; 47, string:'no ents given to Ent.merge()'; 48, elif_clause; 48, 49; 48, 61; 49, not_operator; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:all; 52, generator_expression; 52, 53; 52, 58; 53, call; 53, 54; 53, 55; 54, identifier:isinstance; 55, argument_list; 55, 56; 55, 57; 56, identifier:s; 57, identifier:Ent; 58, for_in_clause; 58, 59; 58, 60; 59, identifier:s; 60, identifier:args; 61, block; 61, 62; 62, raise_statement; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:ValueError; 65, argument_list; 65, 66; 66, concatenated_string; 66, 67; 66, 68; 67, string:'all positional arguments to Ent.merge() must '; 68, string:'be instances of Ent'; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:ent; 72, subscript; 72, 73; 72, 74; 73, identifier:args; 74, integer:0; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:data; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:cls; 81, identifier:load; 82, argument_list; 82, 83; 83, identifier:ent; 84, for_statement; 84, 85; 84, 86; 84, 91; 85, identifier:ent; 86, subscript; 86, 87; 86, 88; 87, identifier:args; 88, slice; 88, 89; 88, 90; 89, integer:1; 90, colon; 91, block; 91, 92; 92, for_statement; 92, 93; 92, 96; 92, 103; 93, pattern_list; 93, 94; 93, 95; 94, identifier:key; 95, identifier:value; 96, call; 96, 97; 96, 102; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:ent; 100, identifier:__dict__; 101, identifier:items; 102, argument_list; 103, block; 103, 104; 103, 110; 104, if_statement; 104, 105; 104, 108; 105, comparison_operator:in; 105, 106; 105, 107; 106, identifier:key; 107, identifier:ignore; 108, block; 108, 109; 109, continue_statement; 110, if_statement; 110, 111; 110, 116; 110, 174; 111, comparison_operator:in; 111, 112; 111, 113; 112, identifier:key; 113, attribute; 113, 114; 113, 115; 114, identifier:data; 115, identifier:__dict__; 116, block; 116, 117; 116, 125; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:v1; 120, subscript; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:data; 123, identifier:__dict__; 124, identifier:key; 125, if_statement; 125, 126; 125, 135; 126, comparison_operator:==; 126, 127; 126, 131; 127, call; 127, 128; 127, 129; 128, identifier:type; 129, argument_list; 129, 130; 130, identifier:value; 131, call; 131, 132; 131, 133; 132, identifier:type; 133, argument_list; 133, 134; 134, identifier:v1; 135, block; 135, 136; 136, if_statement; 136, 137; 136, 142; 136, 159; 137, call; 137, 138; 137, 139; 138, identifier:isinstance; 139, argument_list; 139, 140; 139, 141; 140, identifier:v1; 141, identifier:Ent; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 150; 145, subscript; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:data; 148, identifier:__dict__; 149, identifier:key; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:cls; 153, identifier:merge; 154, argument_list; 154, 155; 154, 156; 154, 157; 155, identifier:v1; 156, identifier:value; 157, dictionary_splat; 157, 158; 158, identifier:kwargs; 159, else_clause; 159, 160; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 168; 163, subscript; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:data; 166, identifier:__dict__; 167, identifier:key; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:cls; 171, identifier:load; 172, argument_list; 172, 173; 173, identifier:value; 174, elif_clause; 174, 175; 174, 176; 175, identifier:newkeys; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 184; 179, subscript; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:data; 182, identifier:__dict__; 183, identifier:key; 184, identifier:value; 185, return_statement; 185, 186; 186, identifier:data | def merge(cls, *args, **kwargs):
newkeys = bool(kwargs.get('newkeys', False))
ignore = kwargs.get('ignore', list())
if len(args) < 1:
raise ValueError('no ents given to Ent.merge()')
elif not all(isinstance(s, Ent) for s in args):
raise ValueError('all positional arguments to Ent.merge() must '
'be instances of Ent')
ent = args[0]
data = cls.load(ent)
for ent in args[1:]:
for key, value in ent.__dict__.items():
if key in ignore:
continue
if key in data.__dict__:
v1 = data.__dict__[key]
if type(value) == type(v1):
if isinstance(v1, Ent):
data.__dict__[key] = cls.merge(v1, value, **kwargs)
else:
data.__dict__[key] = cls.load(value)
elif newkeys:
data.__dict__[key] = value
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:diff; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:cls; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 23; 9, 35; 9, 69; 9, 75; 9, 81; 9, 206; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:newkeys; 13, call; 13, 14; 13, 15; 14, identifier:bool; 15, argument_list; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:kwargs; 19, identifier:get; 20, argument_list; 20, 21; 20, 22; 21, string:'newkeys'; 22, False; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:ignore; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:kwargs; 29, identifier:get; 30, argument_list; 30, 31; 30, 32; 31, string:'ignore'; 32, call; 32, 33; 32, 34; 33, identifier:list; 34, argument_list; 35, if_statement; 35, 36; 35, 42; 35, 48; 36, comparison_operator:<; 36, 37; 36, 41; 37, call; 37, 38; 37, 39; 38, identifier:len; 39, argument_list; 39, 40; 40, identifier:args; 41, integer:2; 42, block; 42, 43; 43, raise_statement; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:ValueError; 46, argument_list; 46, 47; 47, string:'less than two ents given to Ent.diff()'; 48, elif_clause; 48, 49; 48, 61; 49, not_operator; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:all; 52, generator_expression; 52, 53; 52, 58; 53, call; 53, 54; 53, 55; 54, identifier:isinstance; 55, argument_list; 55, 56; 55, 57; 56, identifier:s; 57, identifier:Ent; 58, for_in_clause; 58, 59; 58, 60; 59, identifier:s; 60, identifier:args; 61, block; 61, 62; 62, raise_statement; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:ValueError; 65, argument_list; 65, 66; 66, concatenated_string; 66, 67; 66, 68; 67, string:'all positional arguments to Ent.diff() must '; 68, string:'be instances of Ent'; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:s1; 72, subscript; 72, 73; 72, 74; 73, identifier:args; 74, integer:0; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:differences; 78, call; 78, 79; 78, 80; 79, identifier:Ent; 80, argument_list; 81, for_statement; 81, 82; 81, 83; 81, 88; 82, identifier:s2; 83, subscript; 83, 84; 83, 85; 84, identifier:args; 85, slice; 85, 86; 85, 87; 86, integer:1; 87, colon; 88, block; 88, 89; 88, 202; 89, for_statement; 89, 90; 89, 93; 89, 100; 90, pattern_list; 90, 91; 90, 92; 91, identifier:key; 92, identifier:value; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:s2; 97, identifier:__dict__; 98, identifier:items; 99, argument_list; 100, block; 100, 101; 100, 107; 101, if_statement; 101, 102; 101, 105; 102, comparison_operator:in; 102, 103; 102, 104; 103, identifier:key; 104, identifier:ignore; 105, block; 105, 106; 106, continue_statement; 107, if_statement; 107, 108; 107, 113; 107, 186; 108, comparison_operator:in; 108, 109; 108, 110; 109, identifier:key; 110, attribute; 110, 111; 110, 112; 111, identifier:s1; 112, identifier:__dict__; 113, block; 113, 114; 113, 122; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:v1; 117, subscript; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:s1; 120, identifier:__dict__; 121, identifier:key; 122, if_statement; 122, 123; 122, 132; 123, comparison_operator:==; 123, 124; 123, 128; 124, call; 124, 125; 124, 126; 125, identifier:type; 126, argument_list; 126, 127; 127, identifier:value; 128, call; 128, 129; 128, 130; 129, identifier:type; 130, argument_list; 130, 131; 131, identifier:v1; 132, block; 132, 133; 133, if_statement; 133, 134; 133, 139; 133, 168; 134, call; 134, 135; 134, 136; 135, identifier:isinstance; 136, argument_list; 136, 137; 136, 138; 137, identifier:v1; 138, identifier:Ent; 139, block; 139, 140; 139, 152; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:delta; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:cls; 146, identifier:diff; 147, argument_list; 147, 148; 147, 149; 147, 150; 148, identifier:v1; 149, identifier:value; 150, dictionary_splat; 150, 151; 151, identifier:kwargs; 152, if_statement; 152, 153; 152, 159; 153, call; 153, 154; 153, 155; 154, identifier:len; 155, argument_list; 155, 156; 156, attribute; 156, 157; 156, 158; 157, identifier:delta; 158, identifier:__dict__; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 167; 162, subscript; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:differences; 165, identifier:__dict__; 166, identifier:key; 167, identifier:delta; 168, elif_clause; 168, 169; 168, 172; 169, comparison_operator:!=; 169, 170; 169, 171; 170, identifier:v1; 171, identifier:value; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 180; 175, subscript; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:differences; 178, identifier:__dict__; 179, identifier:key; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:cls; 183, identifier:load; 184, argument_list; 184, 185; 185, identifier:value; 186, elif_clause; 186, 187; 186, 188; 187, identifier:newkeys; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 196; 191, subscript; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:differences; 194, identifier:__dict__; 195, identifier:key; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:cls; 199, identifier:load; 200, argument_list; 200, 201; 201, identifier:value; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:s1; 205, identifier:s2; 206, return_statement; 206, 207; 207, identifier:differences | def diff(cls, *args, **kwargs):
newkeys = bool(kwargs.get('newkeys', False))
ignore = kwargs.get('ignore', list())
if len(args) < 2:
raise ValueError('less than two ents given to Ent.diff()')
elif not all(isinstance(s, Ent) for s in args):
raise ValueError('all positional arguments to Ent.diff() must '
'be instances of Ent')
s1 = args[0]
differences = Ent()
for s2 in args[1:]:
for key, value in s2.__dict__.items():
if key in ignore:
continue
if key in s1.__dict__:
v1 = s1.__dict__[key]
if type(value) == type(v1):
if isinstance(v1, Ent):
delta = cls.diff(v1, value, **kwargs)
if len(delta.__dict__):
differences.__dict__[key] = delta
elif v1 != value:
differences.__dict__[key] = cls.load(value)
elif newkeys:
differences.__dict__[key] = cls.load(value)
s1 = s2
return differences |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sorted_keys_items; 3, parameters; 3, 4; 4, identifier:dobj; 5, block; 5, 6; 5, 17; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:keys; 9, call; 9, 10; 9, 11; 10, identifier:sorted; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:dobj; 15, identifier:keys; 16, argument_list; 17, for_statement; 17, 18; 17, 19; 17, 20; 18, identifier:key; 19, identifier:keys; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, yield; 22, 23; 23, expression_list; 23, 24; 23, 25; 24, identifier:key; 25, subscript; 25, 26; 25, 27; 26, identifier:dobj; 27, identifier:key | def _sorted_keys_items(dobj):
keys = sorted(dobj.keys())
for key in keys:
yield key, dobj[key] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:get_or_create_exh_obj; 3, parameters; 3, 4; 3, 7; 3, 10; 4, default_parameter; 4, 5; 4, 6; 5, identifier:full_cname; 6, False; 7, default_parameter; 7, 8; 7, 9; 8, identifier:exclude; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:callables_fname; 12, None; 13, block; 13, 14; 13, 16; 13, 40; 14, expression_statement; 14, 15; 15, identifier:r; 16, if_statement; 16, 17; 16, 23; 17, not_operator; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:hasattr; 20, argument_list; 20, 21; 20, 22; 21, identifier:__builtin__; 22, string:"_EXH"; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:set_exh_obj; 27, argument_list; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:ExHandle; 30, argument_list; 30, 31; 30, 34; 30, 37; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:full_cname; 33, identifier:full_cname; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:exclude; 36, identifier:exclude; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:callables_fname; 39, identifier:callables_fname; 40, return_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:get_exh_obj; 43, argument_list | def get_or_create_exh_obj(full_cname=False, exclude=None, callables_fname=None):
r
if not hasattr(__builtin__, "_EXH"):
set_exh_obj(
ExHandle(
full_cname=full_cname, exclude=exclude, callables_fname=callables_fname
)
)
return get_exh_obj() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_property_search; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:fobj; 6, block; 6, 7; 6, 19; 6, 30; 6, 41; 6, 64; 6, 75; 6, 90; 6, 109; 6, 113; 6, 202; 6, 211; 6, 224; 6, 283; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:scontext; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:fobj; 14, identifier:f_locals; 15, identifier:get; 16, argument_list; 16, 17; 16, 18; 17, string:"self"; 18, None; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:class_obj; 22, conditional_expression:if; 22, 23; 22, 26; 22, 29; 23, attribute; 23, 24; 23, 25; 24, identifier:scontext; 25, identifier:__class__; 26, comparison_operator:is; 26, 27; 26, 28; 27, identifier:scontext; 28, None; 29, None; 30, if_statement; 30, 31; 30, 33; 31, not_operator; 31, 32; 32, identifier:class_obj; 33, block; 33, 34; 33, 39; 34, delete_statement; 34, 35; 35, expression_list; 35, 36; 35, 37; 35, 38; 36, identifier:fobj; 37, identifier:scontext; 38, identifier:class_obj; 39, return_statement; 39, 40; 40, None; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:class_props; 44, list_comprehension; 44, 45; 44, 48; 44, 58; 45, tuple; 45, 46; 45, 47; 46, identifier:member_name; 47, identifier:member_obj; 48, for_in_clause; 48, 49; 48, 52; 49, pattern_list; 49, 50; 49, 51; 50, identifier:member_name; 51, identifier:member_obj; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:inspect; 55, identifier:getmembers; 56, argument_list; 56, 57; 57, identifier:class_obj; 58, if_clause; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:isinstance; 61, argument_list; 61, 62; 61, 63; 62, identifier:member_obj; 63, identifier:property; 64, if_statement; 64, 65; 64, 67; 65, not_operator; 65, 66; 66, identifier:class_props; 67, block; 67, 68; 67, 73; 68, delete_statement; 68, 69; 69, expression_list; 69, 70; 69, 71; 69, 72; 70, identifier:fobj; 71, identifier:scontext; 72, identifier:class_obj; 73, return_statement; 73, 74; 74, None; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:class_file; 78, call; 78, 79; 78, 87; 79, attribute; 79, 80; 79, 86; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:inspect; 83, identifier:getfile; 84, argument_list; 84, 85; 85, identifier:class_obj; 86, identifier:replace; 87, argument_list; 87, 88; 87, 89; 88, string:".pyc"; 89, string:".py"; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:class_name; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:_callables_obj; 98, identifier:get_callable_from_line; 99, argument_list; 99, 100; 99, 101; 100, identifier:class_file; 101, subscript; 101, 102; 101, 108; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:inspect; 105, identifier:getsourcelines; 106, argument_list; 106, 107; 107, identifier:class_obj; 108, integer:1; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:prop_actions_dicts; 112, dictionary; 113, for_statement; 113, 114; 113, 117; 113, 118; 114, pattern_list; 114, 115; 114, 116; 115, identifier:prop_name; 116, identifier:prop_obj; 117, identifier:class_props; 118, block; 118, 119; 118, 132; 118, 196; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:prop_dict; 122, dictionary; 122, 123; 122, 126; 122, 129; 123, pair; 123, 124; 123, 125; 124, string:"fdel"; 125, None; 126, pair; 126, 127; 126, 128; 127, string:"fget"; 128, None; 129, pair; 129, 130; 129, 131; 130, string:"fset"; 131, None; 132, for_statement; 132, 133; 132, 134; 132, 135; 133, identifier:action; 134, identifier:prop_dict; 135, block; 135, 136; 135, 144; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:action_obj; 139, call; 139, 140; 139, 141; 140, identifier:getattr; 141, argument_list; 141, 142; 141, 143; 142, identifier:prop_obj; 143, identifier:action; 144, if_statement; 144, 145; 144, 146; 145, identifier:action_obj; 146, block; 146, 147; 146, 160; 146, 176; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 152; 149, pattern_list; 149, 150; 149, 151; 150, identifier:prev_func_obj; 151, identifier:next_func_obj; 152, tuple; 152, 153; 152, 154; 153, identifier:action_obj; 154, call; 154, 155; 154, 156; 155, identifier:getattr; 156, argument_list; 156, 157; 156, 158; 156, 159; 157, identifier:action_obj; 158, string:"__wrapped__"; 159, None; 160, while_statement; 160, 161; 160, 162; 161, identifier:next_func_obj; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 168; 165, pattern_list; 165, 166; 165, 167; 166, identifier:prev_func_obj; 167, identifier:next_func_obj; 168, tuple; 168, 169; 168, 170; 169, identifier:next_func_obj; 170, call; 170, 171; 170, 172; 171, identifier:getattr; 172, argument_list; 172, 173; 172, 174; 172, 175; 173, identifier:next_func_obj; 174, string:"__wrapped__"; 175, None; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 181; 178, subscript; 178, 179; 178, 180; 179, identifier:prop_dict; 180, identifier:action; 181, list:[
id(_get_func_code(action_obj)),
id(_get_func_code(prev_func_obj)),
]; 181, 182; 181, 189; 182, call; 182, 183; 182, 184; 183, identifier:id; 184, argument_list; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:_get_func_code; 187, argument_list; 187, 188; 188, identifier:action_obj; 189, call; 189, 190; 189, 191; 190, identifier:id; 191, argument_list; 191, 192; 192, call; 192, 193; 192, 194; 193, identifier:_get_func_code; 194, argument_list; 194, 195; 195, identifier:prev_func_obj; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:prop_actions_dicts; 200, identifier:prop_name; 201, identifier:prop_dict; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:func_id; 205, call; 205, 206; 205, 207; 206, identifier:id; 207, argument_list; 207, 208; 208, attribute; 208, 209; 208, 210; 209, identifier:fobj; 210, identifier:f_code; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:desc_dict; 214, dictionary; 214, 215; 214, 218; 214, 221; 215, pair; 215, 216; 215, 217; 216, string:"fget"; 217, string:"getter"; 218, pair; 218, 219; 218, 220; 219, string:"fset"; 220, string:"setter"; 221, pair; 221, 222; 221, 223; 222, string:"fdel"; 223, string:"deleter"; 224, for_statement; 224, 225; 224, 228; 224, 233; 225, pattern_list; 225, 226; 225, 227; 226, identifier:prop_name; 227, identifier:prop_actions_dict; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:prop_actions_dicts; 231, identifier:items; 232, argument_list; 233, block; 233, 234; 234, for_statement; 234, 235; 234, 238; 234, 243; 235, pattern_list; 235, 236; 235, 237; 236, identifier:action_name; 237, identifier:action_id_list; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:prop_actions_dict; 241, identifier:items; 242, argument_list; 243, block; 243, 244; 244, if_statement; 244, 245; 244, 251; 245, boolean_operator:and; 245, 246; 245, 247; 246, identifier:action_id_list; 247, parenthesized_expression; 247, 248; 248, comparison_operator:in; 248, 249; 248, 250; 249, identifier:func_id; 250, identifier:action_id_list; 251, block; 251, 252; 251, 263; 251, 269; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:prop_name; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, string:"."; 258, identifier:join; 259, argument_list; 259, 260; 260, list:[class_name, prop_name]; 260, 261; 260, 262; 261, identifier:class_name; 262, identifier:prop_name; 263, delete_statement; 263, 264; 264, expression_list; 264, 265; 264, 266; 264, 267; 264, 268; 265, identifier:fobj; 266, identifier:scontext; 267, identifier:class_obj; 268, identifier:class_props; 269, return_statement; 269, 270; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, string:"{prop_name}({prop_action})"; 273, identifier:format; 274, argument_list; 274, 275; 274, 278; 275, keyword_argument; 275, 276; 275, 277; 276, identifier:prop_name; 277, identifier:prop_name; 278, keyword_argument; 278, 279; 278, 280; 279, identifier:prop_action; 280, subscript; 280, 281; 280, 282; 281, identifier:desc_dict; 282, identifier:action_name; 283, return_statement; 283, 284; 284, None | def _property_search(self, fobj):
scontext = fobj.f_locals.get("self", None)
class_obj = scontext.__class__ if scontext is not None else None
if not class_obj:
del fobj, scontext, class_obj
return None
class_props = [
(member_name, member_obj)
for member_name, member_obj in inspect.getmembers(class_obj)
if isinstance(member_obj, property)
]
if not class_props:
del fobj, scontext, class_obj
return None
class_file = inspect.getfile(class_obj).replace(".pyc", ".py")
class_name = self._callables_obj.get_callable_from_line(
class_file, inspect.getsourcelines(class_obj)[1]
)
prop_actions_dicts = {}
for prop_name, prop_obj in class_props:
prop_dict = {"fdel": None, "fget": None, "fset": None}
for action in prop_dict:
action_obj = getattr(prop_obj, action)
if action_obj:
prev_func_obj, next_func_obj = (
action_obj,
getattr(action_obj, "__wrapped__", None),
)
while next_func_obj:
prev_func_obj, next_func_obj = (
next_func_obj,
getattr(next_func_obj, "__wrapped__", None),
)
prop_dict[action] = [
id(_get_func_code(action_obj)),
id(_get_func_code(prev_func_obj)),
]
prop_actions_dicts[prop_name] = prop_dict
func_id = id(fobj.f_code)
desc_dict = {"fget": "getter", "fset": "setter", "fdel": "deleter"}
for prop_name, prop_actions_dict in prop_actions_dicts.items():
for action_name, action_id_list in prop_actions_dict.items():
if action_id_list and (func_id in action_id_list):
prop_name = ".".join([class_name, prop_name])
del fobj, scontext, class_obj, class_props
return "{prop_name}({prop_action})".format(
prop_name=prop_name, prop_action=desc_dict[action_name]
)
return None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_execute; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:request; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 317; 8, 326; 8, 354; 8, 360; 8, 411; 9, try_statement; 9, 10; 9, 117; 9, 177; 9, 214; 9, 240; 9, 266; 10, block; 10, 11; 10, 18; 10, 24; 10, 30; 10, 36; 10, 65; 10, 76; 10, 105; 10, 111; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:_create_context; 16, argument_list; 16, 17; 17, identifier:request; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_authenticate; 23, argument_list; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:context; 27, call; 27, 28; 27, 29; 28, identifier:get_current_context; 29, argument_list; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_parse_args; 35, argument_list; 36, if_statement; 36, 37; 36, 53; 37, boolean_operator:and; 37, 38; 37, 43; 37, 44; 38, call; 38, 39; 38, 40; 39, identifier:hasattr; 40, argument_list; 40, 41; 40, 42; 41, identifier:self; 42, string:'_before_handlers'; 43, line_continuation:\; 44, call; 44, 45; 44, 46; 45, identifier:isinstance; 46, argument_list; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_before_handlers; 50, tuple; 50, 51; 50, 52; 51, identifier:list; 52, identifier:tuple; 53, block; 53, 54; 54, for_statement; 54, 55; 54, 56; 54, 59; 55, identifier:handler; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_before_handlers; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:handler; 63, argument_list; 63, 64; 64, identifier:context; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:context; 69, identifier:handler_result; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:_handle; 74, argument_list; 74, 75; 75, identifier:context; 76, if_statement; 76, 77; 76, 93; 77, boolean_operator:and; 77, 78; 77, 83; 77, 84; 78, call; 78, 79; 78, 80; 79, identifier:hasattr; 80, argument_list; 80, 81; 80, 82; 81, identifier:self; 82, string:'_after_handlers'; 83, line_continuation:\; 84, call; 84, 85; 84, 86; 85, identifier:isinstance; 86, argument_list; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:_after_handlers; 90, tuple; 90, 91; 90, 92; 91, identifier:list; 92, identifier:tuple; 93, block; 93, 94; 94, for_statement; 94, 95; 94, 96; 94, 99; 95, identifier:handler; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:_after_handlers; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 103; 102, identifier:handler; 103, argument_list; 103, 104; 104, identifier:context; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:_render; 110, argument_list; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:response; 114, attribute; 114, 115; 114, 116; 115, identifier:context; 116, identifier:response; 117, except_clause; 117, 118; 117, 122; 118, as_pattern; 118, 119; 118, 120; 119, identifier:AuthenticationError; 120, as_pattern_target; 120, 121; 121, identifier:e; 122, block; 122, 123; 122, 148; 122, 157; 122, 169; 123, if_statement; 123, 124; 123, 135; 123, 142; 124, boolean_operator:and; 124, 125; 124, 130; 125, call; 125, 126; 125, 127; 126, identifier:hasattr; 127, argument_list; 127, 128; 127, 129; 128, identifier:e; 129, string:'message'; 130, comparison_operator:is; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:e; 133, identifier:message; 134, None; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:message; 139, attribute; 139, 140; 139, 141; 140, identifier:e; 141, identifier:message; 142, else_clause; 142, 143; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:message; 147, string:"You don't have permission to do that."; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:err; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:APIError; 154, identifier:Forbidden; 155, argument_list; 155, 156; 156, identifier:message; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:response; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:self; 163, identifier:_response_class; 164, argument_list; 164, 165; 165, list_splat; 165, 166; 166, attribute; 166, 167; 166, 168; 167, identifier:err; 168, identifier:response; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 176; 171, subscript; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:response; 174, identifier:headers; 175, string:"Content-Type"; 176, string:'application/json'; 177, except_clause; 177, 178; 177, 182; 178, as_pattern; 178, 179; 178, 180; 179, identifier:ArgumentError; 180, as_pattern_target; 180, 181; 181, identifier:e; 182, block; 182, 183; 182, 194; 182, 206; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:err; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:APIError; 189, identifier:UnprocessableEntity; 190, argument_list; 190, 191; 191, attribute; 191, 192; 191, 193; 192, identifier:e; 193, identifier:message; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:response; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:_response_class; 201, argument_list; 201, 202; 202, list_splat; 202, 203; 203, attribute; 203, 204; 203, 205; 204, identifier:err; 205, identifier:response; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 213; 208, subscript; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:response; 211, identifier:headers; 212, string:"Content-Type"; 213, string:'application/json'; 214, except_clause; 214, 215; 214, 219; 215, as_pattern; 215, 216; 215, 217; 216, identifier:APIError; 217, as_pattern_target; 217, 218; 218, identifier:e; 219, block; 219, 220; 219, 232; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:response; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:self; 226, identifier:_response_class; 227, argument_list; 227, 228; 228, list_splat; 228, 229; 229, attribute; 229, 230; 229, 231; 230, identifier:e; 231, identifier:response; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 239; 234, subscript; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:response; 237, identifier:headers; 238, string:"Content-Type"; 239, string:'application/json'; 240, except_clause; 240, 241; 240, 245; 241, as_pattern; 241, 242; 241, 243; 242, identifier:PaleRaisedResponse; 243, as_pattern_target; 243, 244; 244, identifier:r; 245, block; 245, 246; 245, 258; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:response; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:self; 252, identifier:_response_class; 253, argument_list; 253, 254; 254, list_splat; 254, 255; 255, attribute; 255, 256; 255, 257; 256, identifier:r; 257, identifier:response; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 265; 260, subscript; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:response; 263, identifier:headers; 264, string:"Content-Type"; 265, string:'application/json'; 266, except_clause; 266, 267; 266, 271; 267, as_pattern; 267, 268; 267, 269; 268, identifier:Exception; 269, as_pattern_target; 269, 270; 270, identifier:e; 271, block; 271, 272; 271, 285; 271, 297; 271, 309; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:logging; 276, identifier:exception; 277, argument_list; 277, 278; 277, 279; 277, 284; 278, string:"Failed to handle Pale Endpoint %s: %r"; 279, attribute; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:self; 282, identifier:__class__; 283, identifier:__name__; 284, identifier:e; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:err; 288, call; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:APIError; 291, identifier:Exception; 292, argument_list; 292, 293; 293, call; 293, 294; 293, 295; 294, identifier:repr; 295, argument_list; 295, 296; 296, identifier:e; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:response; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:self; 303, identifier:_response_class; 304, argument_list; 304, 305; 305, list_splat; 305, 306; 306, attribute; 306, 307; 306, 308; 307, identifier:err; 308, identifier:response; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 316; 311, subscript; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:response; 314, identifier:headers; 315, string:"Content-Type"; 316, string:'application/json'; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 320; 319, identifier:allow_cors; 320, call; 320, 321; 320, 322; 321, identifier:getattr; 322, argument_list; 322, 323; 322, 324; 322, 325; 323, identifier:self; 324, string:"_allow_cors"; 325, None; 326, if_statement; 326, 327; 326, 330; 326, 339; 327, comparison_operator:is; 327, 328; 327, 329; 328, identifier:allow_cors; 329, True; 330, block; 330, 331; 331, expression_statement; 331, 332; 332, assignment; 332, 333; 332, 338; 333, subscript; 333, 334; 333, 337; 334, attribute; 334, 335; 334, 336; 335, identifier:response; 336, identifier:headers; 337, string:'Access-Control-Allow-Origin'; 338, string:'*'; 339, elif_clause; 339, 340; 339, 345; 340, call; 340, 341; 340, 342; 341, identifier:isinstance; 342, argument_list; 342, 343; 342, 344; 343, identifier:allow_cors; 344, identifier:basestring; 345, block; 345, 346; 346, expression_statement; 346, 347; 347, assignment; 347, 348; 347, 353; 348, subscript; 348, 349; 348, 352; 349, attribute; 349, 350; 349, 351; 350, identifier:response; 351, identifier:headers; 352, string:'Access-Control-Allow-Origin'; 353, identifier:allow_cors; 354, expression_statement; 354, 355; 355, assignment; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, identifier:context; 358, identifier:response; 359, identifier:response; 360, try_statement; 360, 361; 360, 392; 361, block; 361, 362; 362, if_statement; 362, 363; 362, 379; 363, boolean_operator:and; 363, 364; 363, 369; 363, 370; 364, call; 364, 365; 364, 366; 365, identifier:hasattr; 366, argument_list; 366, 367; 366, 368; 367, identifier:self; 368, string:'_after_response_handlers'; 369, line_continuation:\; 370, call; 370, 371; 370, 372; 371, identifier:isinstance; 372, argument_list; 372, 373; 372, 376; 373, attribute; 373, 374; 373, 375; 374, identifier:self; 375, identifier:_after_response_handlers; 376, tuple; 376, 377; 376, 378; 377, identifier:list; 378, identifier:tuple; 379, block; 379, 380; 380, for_statement; 380, 381; 380, 382; 380, 385; 381, identifier:handler; 382, attribute; 382, 383; 382, 384; 383, identifier:self; 384, identifier:_after_response_handlers; 385, block; 385, 386; 386, expression_statement; 386, 387; 387, call; 387, 388; 387, 389; 388, identifier:handler; 389, argument_list; 389, 390; 389, 391; 390, identifier:context; 391, identifier:response; 392, except_clause; 392, 393; 392, 397; 393, as_pattern; 393, 394; 393, 395; 394, identifier:Exception; 395, as_pattern_target; 395, 396; 396, identifier:e; 397, block; 397, 398; 397, 410; 398, expression_statement; 398, 399; 399, call; 399, 400; 399, 403; 400, attribute; 400, 401; 400, 402; 401, identifier:logging; 402, identifier:exception; 403, argument_list; 403, 404; 403, 405; 404, string:"Failed to process _after_response_handlers for Endpoint %s"; 405, attribute; 405, 406; 405, 409; 406, attribute; 406, 407; 406, 408; 407, identifier:self; 408, identifier:__class__; 409, identifier:__name__; 410, raise_statement; 411, return_statement; 411, 412; 412, identifier:response | def _execute(self, request, **kwargs):
try:
self._create_context(request)
self._authenticate()
context = get_current_context()
self._parse_args()
if hasattr(self, '_before_handlers') and \
isinstance(self._before_handlers, (list, tuple)):
for handler in self._before_handlers:
handler(context)
context.handler_result = self._handle(context)
if hasattr(self, '_after_handlers') and \
isinstance(self._after_handlers, (list, tuple)):
for handler in self._after_handlers:
handler(context)
self._render()
response = context.response
except AuthenticationError as e:
if hasattr(e, 'message') and e.message is not None:
message = e.message
else:
message = "You don't have permission to do that."
err = APIError.Forbidden(message)
response = self._response_class(*err.response)
response.headers["Content-Type"] = 'application/json'
except ArgumentError as e:
err = APIError.UnprocessableEntity(e.message)
response = self._response_class(*err.response)
response.headers["Content-Type"] = 'application/json'
except APIError as e:
response = self._response_class(*e.response)
response.headers["Content-Type"] = 'application/json'
except PaleRaisedResponse as r:
response = self._response_class(*r.response)
response.headers["Content-Type"] = 'application/json'
except Exception as e:
logging.exception("Failed to handle Pale Endpoint %s: %r", self.__class__.__name__,
e)
err = APIError.Exception(repr(e))
response = self._response_class(*err.response)
response.headers["Content-Type"] = 'application/json'
allow_cors = getattr(self, "_allow_cors", None)
if allow_cors is True:
response.headers['Access-Control-Allow-Origin'] = '*'
elif isinstance(allow_cors, basestring):
response.headers['Access-Control-Allow-Origin'] = allow_cors
context.response = response
try:
if hasattr(self, '_after_response_handlers') and \
isinstance(self._after_response_handlers, (list, tuple)):
for handler in self._after_response_handlers:
handler(context, response)
except Exception as e:
logging.exception(
"Failed to process _after_response_handlers for Endpoint %s",
self.__class__.__name__)
raise
return response |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:add_entity_errors; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:property_name; 6, default_parameter; 6, 7; 6, 8; 7, identifier:direct_errors; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:schema_errors; 11, None; 12, block; 12, 13; 12, 24; 12, 119; 12, 203; 13, if_statement; 13, 14; 13, 21; 14, boolean_operator:and; 14, 15; 14, 18; 15, comparison_operator:is; 15, 16; 15, 17; 16, identifier:direct_errors; 17, None; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:schema_errors; 20, None; 21, block; 21, 22; 22, return_statement; 22, 23; 23, identifier:self; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:direct_errors; 27, None; 28, block; 28, 29; 28, 46; 28, 65; 28, 78; 29, if_statement; 29, 30; 29, 35; 30, comparison_operator:not; 30, 31; 30, 32; 31, identifier:property_name; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:errors; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 43; 38, subscript; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:errors; 42, identifier:property_name; 43, call; 43, 44; 43, 45; 44, identifier:dict; 45, argument_list; 46, if_statement; 46, 47; 46, 54; 47, comparison_operator:not; 47, 48; 47, 49; 48, string:'direct'; 49, subscript; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:errors; 53, identifier:property_name; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 64; 57, subscript; 57, 58; 57, 63; 58, subscript; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:errors; 62, identifier:property_name; 63, string:'direct'; 64, list:[]; 65, if_statement; 65, 66; 65, 72; 66, comparison_operator:is; 66, 67; 66, 71; 67, call; 67, 68; 67, 69; 68, identifier:type; 69, argument_list; 69, 70; 70, identifier:direct_errors; 71, identifier:list; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:direct_errors; 76, list:[direct_errors]; 76, 77; 77, identifier:direct_errors; 78, for_statement; 78, 79; 78, 80; 78, 81; 79, identifier:error; 80, identifier:direct_errors; 81, block; 81, 82; 81, 106; 82, if_statement; 82, 83; 82, 89; 83, not_operator; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:isinstance; 86, argument_list; 86, 87; 86, 88; 87, identifier:error; 88, identifier:Error; 89, block; 89, 90; 89, 94; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:err; 93, string:'Error must be of type {}'; 94, raise_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:x; 98, identifier:InvalidErrorType; 99, argument_list; 99, 100; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:err; 103, identifier:format; 104, argument_list; 104, 105; 105, identifier:Error; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 117; 108, attribute; 108, 109; 108, 116; 109, subscript; 109, 110; 109, 115; 110, subscript; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:errors; 114, identifier:property_name; 115, string:'direct'; 116, identifier:append; 117, argument_list; 117, 118; 118, identifier:error; 119, if_statement; 119, 120; 119, 123; 120, comparison_operator:is; 120, 121; 120, 122; 121, identifier:schema_errors; 122, None; 123, block; 123, 124; 123, 137; 123, 143; 123, 160; 124, if_statement; 124, 125; 124, 130; 125, call; 125, 126; 125, 127; 126, identifier:isinstance; 127, argument_list; 127, 128; 127, 129; 128, identifier:schema_errors; 129, identifier:Result; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:schema_errors; 134, attribute; 134, 135; 134, 136; 135, identifier:schema_errors; 136, identifier:errors; 137, if_statement; 137, 138; 137, 140; 138, not_operator; 138, 139; 139, identifier:schema_errors; 140, block; 140, 141; 141, return_statement; 141, 142; 142, identifier:self; 143, if_statement; 143, 144; 143, 149; 144, comparison_operator:not; 144, 145; 144, 146; 145, identifier:property_name; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:errors; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 157; 152, subscript; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:errors; 156, identifier:property_name; 157, call; 157, 158; 157, 159; 158, identifier:dict; 159, argument_list; 160, if_statement; 160, 161; 160, 168; 160, 179; 161, comparison_operator:not; 161, 162; 161, 163; 162, string:'schema'; 163, subscript; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:errors; 167, identifier:property_name; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 178; 171, subscript; 171, 172; 171, 177; 172, subscript; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:errors; 176, identifier:property_name; 177, string:'schema'; 178, identifier:schema_errors; 179, else_clause; 179, 180; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 190; 183, subscript; 183, 184; 183, 189; 184, subscript; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:errors; 188, identifier:property_name; 189, string:'schema'; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:self; 193, identifier:merge_errors; 194, argument_list; 194, 195; 194, 202; 195, subscript; 195, 196; 195, 201; 196, subscript; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:self; 199, identifier:errors; 200, identifier:property_name; 201, string:'schema'; 202, identifier:schema_errors; 203, return_statement; 203, 204; 204, identifier:self | def add_entity_errors(
self,
property_name,
direct_errors=None,
schema_errors=None
):
if direct_errors is None and schema_errors is None:
return self
if direct_errors is not None:
if property_name not in self.errors:
self.errors[property_name] = dict()
if 'direct' not in self.errors[property_name]:
self.errors[property_name]['direct'] = []
if type(direct_errors) is not list:
direct_errors = [direct_errors]
for error in direct_errors:
if not isinstance(error, Error):
err = 'Error must be of type {}'
raise x.InvalidErrorType(err.format(Error))
self.errors[property_name]['direct'].append(error)
if schema_errors is not None:
if isinstance(schema_errors, Result):
schema_errors = schema_errors.errors
if not schema_errors:
return self
if property_name not in self.errors:
self.errors[property_name] = dict()
if 'schema' not in self.errors[property_name]:
self.errors[property_name]['schema'] = schema_errors
else:
self.errors[property_name]['schema'] = self.merge_errors(
self.errors[property_name]['schema'],
schema_errors
)
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:add_collection_errors; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:property_name; 6, default_parameter; 6, 7; 6, 8; 7, identifier:direct_errors; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:collection_errors; 11, None; 12, block; 12, 13; 12, 24; 12, 119; 12, 264; 13, if_statement; 13, 14; 13, 21; 14, boolean_operator:and; 14, 15; 14, 18; 15, comparison_operator:is; 15, 16; 15, 17; 16, identifier:direct_errors; 17, None; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:collection_errors; 20, None; 21, block; 21, 22; 22, return_statement; 22, 23; 23, identifier:self; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:direct_errors; 27, None; 28, block; 28, 29; 28, 42; 28, 59; 28, 78; 29, if_statement; 29, 30; 29, 36; 30, comparison_operator:is; 30, 31; 30, 35; 31, call; 31, 32; 31, 33; 32, identifier:type; 33, argument_list; 33, 34; 34, identifier:direct_errors; 35, identifier:list; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:direct_errors; 40, list:[direct_errors]; 40, 41; 41, identifier:direct_errors; 42, if_statement; 42, 43; 42, 48; 43, comparison_operator:not; 43, 44; 43, 45; 44, identifier:property_name; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:errors; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 56; 51, subscript; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:errors; 55, identifier:property_name; 56, call; 56, 57; 56, 58; 57, identifier:dict; 58, argument_list; 59, if_statement; 59, 60; 59, 67; 60, comparison_operator:not; 60, 61; 60, 62; 61, string:'direct'; 62, subscript; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:errors; 66, identifier:property_name; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 77; 70, subscript; 70, 71; 70, 76; 71, subscript; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:errors; 75, identifier:property_name; 76, string:'direct'; 77, list:[]; 78, for_statement; 78, 79; 78, 80; 78, 81; 79, identifier:error; 80, identifier:direct_errors; 81, block; 81, 82; 81, 106; 82, if_statement; 82, 83; 82, 89; 83, not_operator; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:isinstance; 86, argument_list; 86, 87; 86, 88; 87, identifier:error; 88, identifier:Error; 89, block; 89, 90; 89, 94; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:err; 93, string:'Error must be of type {}'; 94, raise_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:x; 98, identifier:InvalidErrorType; 99, argument_list; 99, 100; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:err; 103, identifier:format; 104, argument_list; 104, 105; 105, identifier:Error; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 117; 108, attribute; 108, 109; 108, 116; 109, subscript; 109, 110; 109, 115; 110, subscript; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:errors; 114, identifier:property_name; 115, string:'direct'; 116, identifier:append; 117, argument_list; 117, 118; 118, identifier:error; 119, if_statement; 119, 120; 119, 121; 120, identifier:collection_errors; 121, block; 121, 122; 121, 129; 121, 147; 121, 153; 121, 170; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:enum; 125, call; 125, 126; 125, 127; 126, identifier:enumerate; 127, argument_list; 127, 128; 128, identifier:collection_errors; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:errors_dict; 132, dictionary_comprehension; 132, 133; 132, 136; 132, 141; 133, pair; 133, 134; 133, 135; 134, identifier:i; 135, identifier:e; 136, for_in_clause; 136, 137; 136, 140; 137, pattern_list; 137, 138; 137, 139; 138, identifier:i; 139, identifier:e; 140, identifier:enum; 141, if_clause; 141, 142; 142, not_operator; 142, 143; 143, call; 143, 144; 143, 145; 144, identifier:bool; 145, argument_list; 145, 146; 146, identifier:e; 147, if_statement; 147, 148; 147, 150; 148, not_operator; 148, 149; 149, identifier:errors_dict; 150, block; 150, 151; 151, return_statement; 151, 152; 152, identifier:self; 153, if_statement; 153, 154; 153, 159; 154, comparison_operator:not; 154, 155; 154, 156; 155, identifier:property_name; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:errors; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 167; 162, subscript; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:errors; 166, identifier:property_name; 167, call; 167, 168; 167, 169; 168, identifier:dict; 169, argument_list; 170, if_statement; 170, 171; 170, 178; 170, 189; 171, comparison_operator:not; 171, 172; 171, 173; 172, string:'collection'; 173, subscript; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:self; 176, identifier:errors; 177, identifier:property_name; 178, block; 178, 179; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 188; 181, subscript; 181, 182; 181, 187; 182, subscript; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:errors; 186, identifier:property_name; 187, string:'collection'; 188, identifier:errors_dict; 189, else_clause; 189, 190; 190, block; 190, 191; 190, 201; 190, 205; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:local; 194, subscript; 194, 195; 194, 200; 195, subscript; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:errors; 199, identifier:property_name; 200, string:'collection'; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:remote; 204, identifier:errors_dict; 205, for_statement; 205, 206; 205, 209; 205, 214; 206, pattern_list; 206, 207; 206, 208; 207, identifier:index; 208, identifier:result; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:remote; 212, identifier:items; 213, argument_list; 214, block; 214, 215; 215, if_statement; 215, 216; 215, 219; 215, 232; 216, comparison_operator:not; 216, 217; 216, 218; 217, identifier:index; 218, identifier:local; 219, block; 219, 220; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 231; 222, subscript; 222, 223; 222, 230; 223, subscript; 223, 224; 223, 229; 224, subscript; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:self; 227, identifier:errors; 228, identifier:property_name; 229, string:'collection'; 230, identifier:index; 231, identifier:result; 232, else_clause; 232, 233; 233, block; 233, 234; 233, 252; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:merged; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:self; 240, identifier:merge_errors; 241, argument_list; 241, 242; 241, 247; 242, attribute; 242, 243; 242, 246; 243, subscript; 243, 244; 243, 245; 244, identifier:local; 245, identifier:index; 246, identifier:errors; 247, attribute; 247, 248; 247, 251; 248, subscript; 248, 249; 248, 250; 249, identifier:remote; 250, identifier:index; 251, identifier:errors; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 263; 254, subscript; 254, 255; 254, 262; 255, subscript; 255, 256; 255, 261; 256, subscript; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:self; 259, identifier:errors; 260, identifier:property_name; 261, string:'collection'; 262, identifier:index; 263, identifier:merged; 264, return_statement; 264, 265; 265, identifier:self | def add_collection_errors(
self,
property_name,
direct_errors=None,
collection_errors=None
):
if direct_errors is None and collection_errors is None:
return self
if direct_errors is not None:
if type(direct_errors) is not list:
direct_errors = [direct_errors]
if property_name not in self.errors:
self.errors[property_name] = dict()
if 'direct' not in self.errors[property_name]:
self.errors[property_name]['direct'] = []
for error in direct_errors:
if not isinstance(error, Error):
err = 'Error must be of type {}'
raise x.InvalidErrorType(err.format(Error))
self.errors[property_name]['direct'].append(error)
if collection_errors:
enum = enumerate(collection_errors)
errors_dict = {i: e for i, e in enum if not bool(e)}
if not errors_dict:
return self
if property_name not in self.errors:
self.errors[property_name] = dict()
if 'collection' not in self.errors[property_name]:
self.errors[property_name]['collection'] = errors_dict
else:
local = self.errors[property_name]['collection']
remote = errors_dict
for index, result in remote.items():
if index not in local:
self.errors[property_name]['collection'][index] = result
else:
merged = self.merge_errors(
local[index].errors,
remote[index].errors
)
self.errors[property_name]['collection'][index] = merged
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:merge_errors; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:errors_local; 6, identifier:errors_remote; 7, block; 7, 8; 7, 304; 8, for_statement; 8, 9; 8, 10; 8, 11; 9, identifier:prop; 10, identifier:errors_remote; 11, block; 11, 12; 11, 26; 11, 32; 11, 45; 11, 51; 11, 64; 11, 109; 11, 113; 11, 117; 11, 138; 11, 159; 11, 177; 11, 199; 11, 228; 12, if_statement; 12, 13; 12, 16; 13, comparison_operator:not; 13, 14; 13, 15; 14, identifier:prop; 15, identifier:errors_local; 16, block; 16, 17; 16, 25; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 22; 19, subscript; 19, 20; 19, 21; 20, identifier:errors_local; 21, identifier:prop; 22, subscript; 22, 23; 22, 24; 23, identifier:errors_remote; 24, identifier:prop; 25, continue_statement; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:local; 29, subscript; 29, 30; 29, 31; 30, identifier:errors_local; 31, identifier:prop; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:local; 35, conditional_expression:if; 35, 36; 35, 39; 35, 44; 36, attribute; 36, 37; 36, 38; 37, identifier:local; 38, identifier:errors; 39, call; 39, 40; 39, 41; 40, identifier:isinstance; 41, argument_list; 41, 42; 41, 43; 42, identifier:local; 43, identifier:Result; 44, identifier:local; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:remote; 48, subscript; 48, 49; 48, 50; 49, identifier:errors_remote; 50, identifier:prop; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:remote; 54, conditional_expression:if; 54, 55; 54, 58; 54, 63; 55, attribute; 55, 56; 55, 57; 56, identifier:remote; 57, identifier:errors; 58, call; 58, 59; 58, 60; 59, identifier:isinstance; 60, argument_list; 60, 61; 60, 62; 61, identifier:remote; 62, identifier:Result; 63, identifier:remote; 64, if_statement; 64, 65; 64, 74; 65, not_operator; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:isinstance; 68, argument_list; 68, 69; 68, 70; 69, identifier:local; 70, call; 70, 71; 70, 72; 71, identifier:type; 72, argument_list; 72, 73; 73, identifier:remote; 74, block; 74, 75; 74, 79; 74, 83; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:msg; 78, string:'Type mismatch on property [{}] when merging errors. '; 79, expression_statement; 79, 80; 80, augmented_assignment:+=; 80, 81; 80, 82; 81, identifier:msg; 82, string:'Unable to merge [{}] into [{}]'; 83, raise_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:x; 87, identifier:UnableToMergeResultsType; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:msg; 92, identifier:format; 93, argument_list; 93, 94; 93, 95; 93, 101; 94, identifier:prop; 95, call; 95, 96; 95, 97; 96, identifier:type; 97, argument_list; 97, 98; 98, subscript; 98, 99; 98, 100; 99, identifier:errors_remote; 100, identifier:prop; 101, call; 101, 102; 101, 103; 102, identifier:type; 103, argument_list; 103, 104; 104, subscript; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:errors; 108, identifier:prop; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:mismatch; 112, string:'Unable to merge nested entity errors with nested '; 113, expression_statement; 113, 114; 114, augmented_assignment:+=; 114, 115; 114, 116; 115, identifier:mismatch; 116, string:'collection errors on property [{}]'; 117, if_statement; 117, 118; 117, 125; 118, boolean_operator:and; 118, 119; 118, 122; 119, comparison_operator:in; 119, 120; 119, 121; 120, string:'schema'; 121, identifier:local; 122, comparison_operator:in; 122, 123; 122, 124; 123, string:'collection'; 124, identifier:remote; 125, block; 125, 126; 126, raise_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:x; 130, identifier:UnableToMergeResultsType; 131, argument_list; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:mismatch; 135, identifier:format; 136, argument_list; 136, 137; 137, identifier:prop; 138, if_statement; 138, 139; 138, 146; 139, boolean_operator:and; 139, 140; 139, 143; 140, comparison_operator:in; 140, 141; 140, 142; 141, string:'collection'; 142, identifier:local; 143, comparison_operator:in; 143, 144; 143, 145; 144, string:'schema'; 145, identifier:remote; 146, block; 146, 147; 147, raise_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:x; 151, identifier:UnableToMergeResultsType; 152, argument_list; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:mismatch; 156, identifier:format; 157, argument_list; 157, 158; 158, identifier:prop; 159, if_statement; 159, 160; 159, 166; 160, comparison_operator:is; 160, 161; 160, 165; 161, call; 161, 162; 161, 163; 162, identifier:type; 163, argument_list; 163, 164; 164, identifier:remote; 165, identifier:list; 166, block; 166, 167; 166, 176; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 174; 169, attribute; 169, 170; 169, 173; 170, subscript; 170, 171; 170, 172; 171, identifier:errors_local; 172, identifier:prop; 173, identifier:extend; 174, argument_list; 174, 175; 175, identifier:remote; 176, continue_statement; 177, if_statement; 177, 178; 177, 185; 178, boolean_operator:and; 178, 179; 178, 182; 179, comparison_operator:in; 179, 180; 179, 181; 180, string:'direct'; 181, identifier:remote; 182, comparison_operator:in; 182, 183; 182, 184; 183, string:'direct'; 184, identifier:local; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, call; 187, 188; 187, 195; 188, attribute; 188, 189; 188, 194; 189, subscript; 189, 190; 189, 193; 190, subscript; 190, 191; 190, 192; 191, identifier:errors_local; 192, identifier:prop; 193, string:'direct'; 194, identifier:extend; 195, argument_list; 195, 196; 196, subscript; 196, 197; 196, 198; 197, identifier:remote; 198, string:'direct'; 199, if_statement; 199, 200; 199, 207; 200, boolean_operator:and; 200, 201; 200, 204; 201, comparison_operator:in; 201, 202; 201, 203; 202, string:'schema'; 203, identifier:remote; 204, comparison_operator:in; 204, 205; 204, 206; 205, string:'schema'; 206, identifier:local; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 215; 210, subscript; 210, 211; 210, 214; 211, subscript; 211, 212; 211, 213; 212, identifier:errors_local; 213, identifier:prop; 214, string:'schema'; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:merge_errors; 219, argument_list; 219, 220; 219, 225; 220, subscript; 220, 221; 220, 224; 221, subscript; 221, 222; 221, 223; 222, identifier:errors_local; 223, identifier:prop; 224, string:'schema'; 225, subscript; 225, 226; 225, 227; 226, identifier:remote; 227, string:'schema'; 228, if_statement; 228, 229; 228, 236; 229, boolean_operator:and; 229, 230; 229, 233; 230, comparison_operator:in; 230, 231; 230, 232; 231, string:'collection'; 232, identifier:remote; 233, comparison_operator:in; 233, 234; 233, 235; 234, string:'collection'; 235, identifier:local; 236, block; 236, 237; 237, for_statement; 237, 238; 237, 241; 237, 248; 238, pattern_list; 238, 239; 238, 240; 239, identifier:index; 240, identifier:result; 241, call; 241, 242; 241, 247; 242, attribute; 242, 243; 242, 246; 243, subscript; 243, 244; 243, 245; 244, identifier:remote; 245, string:'collection'; 246, identifier:items; 247, argument_list; 248, block; 248, 249; 249, if_statement; 249, 250; 249, 255; 249, 266; 250, comparison_operator:not; 250, 251; 250, 252; 251, identifier:index; 252, subscript; 252, 253; 252, 254; 253, identifier:local; 254, string:'collection'; 255, block; 255, 256; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 265; 258, subscript; 258, 259; 258, 264; 259, subscript; 259, 260; 259, 263; 260, subscript; 260, 261; 260, 262; 261, identifier:errors_local; 262, identifier:prop; 263, string:'collection'; 264, identifier:index; 265, identifier:result; 266, else_clause; 266, 267; 267, block; 267, 268; 267, 294; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:merged; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:self; 274, identifier:merge_errors; 275, argument_list; 275, 276; 275, 285; 276, attribute; 276, 277; 276, 284; 277, subscript; 277, 278; 277, 283; 278, subscript; 278, 279; 278, 282; 279, subscript; 279, 280; 279, 281; 280, identifier:errors_local; 281, identifier:prop; 282, string:'collection'; 283, identifier:index; 284, identifier:errors; 285, attribute; 285, 286; 285, 293; 286, subscript; 286, 287; 286, 292; 287, subscript; 287, 288; 287, 291; 288, subscript; 288, 289; 288, 290; 289, identifier:errors_remote; 290, identifier:prop; 291, string:'collection'; 292, identifier:index; 293, identifier:errors; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 303; 296, subscript; 296, 297; 296, 302; 297, subscript; 297, 298; 297, 301; 298, subscript; 298, 299; 298, 300; 299, identifier:errors_local; 300, identifier:prop; 301, string:'collection'; 302, identifier:index; 303, identifier:merged; 304, return_statement; 304, 305; 305, identifier:errors_local | def merge_errors(self, errors_local, errors_remote):
for prop in errors_remote:
if prop not in errors_local:
errors_local[prop] = errors_remote[prop]
continue
local = errors_local[prop]
local = local.errors if isinstance(local, Result) else local
remote = errors_remote[prop]
remote = remote.errors if isinstance(remote, Result) else remote
if not isinstance(local, type(remote)):
msg = 'Type mismatch on property [{}] when merging errors. '
msg += 'Unable to merge [{}] into [{}]'
raise x.UnableToMergeResultsType(msg.format(
prop,
type(errors_remote[prop]),
type(self.errors[prop])
))
mismatch = 'Unable to merge nested entity errors with nested '
mismatch += 'collection errors on property [{}]'
if 'schema' in local and 'collection' in remote:
raise x.UnableToMergeResultsType(mismatch.format(prop))
if 'collection' in local and 'schema' in remote:
raise x.UnableToMergeResultsType(mismatch.format(prop))
if type(remote) is list:
errors_local[prop].extend(remote)
continue
if 'direct' in remote and 'direct' in local:
errors_local[prop]['direct'].extend(remote['direct'])
if 'schema' in remote and 'schema' in local:
errors_local[prop]['schema'] = self.merge_errors(
errors_local[prop]['schema'],
remote['schema']
)
if 'collection' in remote and 'collection' in local:
for index, result in remote['collection'].items():
if index not in local['collection']:
errors_local[prop]['collection'][index] = result
else:
merged = self.merge_errors(
errors_local[prop]['collection'][index].errors,
errors_remote[prop]['collection'][index].errors,
)
errors_local[prop]['collection'][index] = merged
return errors_local |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:cursorPositionChangedEvent; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 22; 5, 30; 5, 41; 5, 48; 5, 59; 5, 84; 5, 92; 5, 103; 5, 161; 5, 179; 5, 188; 5, 196; 5, 202; 5, 210; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:qteWidget; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:sender; 13, argument_list; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:tc; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:qteWidget; 20, identifier:textCursor; 21, argument_list; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:origin; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:tc; 28, identifier:position; 29, argument_list; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:qteWidget; 35, identifier:cursorPositionChanged; 36, identifier:disconnect; 37, argument_list; 37, 38; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:cursorPositionChangedEvent; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:qteRemoveHighlighting; 46, argument_list; 46, 47; 47, identifier:qteWidget; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:qteWidget; 53, identifier:cursorPositionChanged; 54, identifier:connect; 55, argument_list; 55, 56; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:cursorPositionChangedEvent; 59, if_statement; 59, 60; 59, 70; 59, 72; 60, comparison_operator:>=; 60, 61; 60, 62; 61, identifier:origin; 62, call; 62, 63; 62, 64; 63, identifier:len; 64, argument_list; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:qteWidget; 68, identifier:toPlainText; 69, argument_list; 70, block; 70, 71; 71, return_statement; 72, else_clause; 72, 73; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:char; 77, subscript; 77, 78; 77, 83; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:qteWidget; 81, identifier:toPlainText; 82, argument_list; 83, identifier:origin; 84, if_statement; 84, 85; 84, 90; 85, comparison_operator:not; 85, 86; 85, 87; 86, identifier:char; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:charToHighlight; 90, block; 90, 91; 91, return_statement; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:qteWidget; 97, identifier:cursorPositionChanged; 98, identifier:disconnect; 99, argument_list; 99, 100; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:cursorPositionChangedEvent; 103, if_statement; 103, 104; 103, 111; 103, 136; 104, comparison_operator:==; 104, 105; 104, 106; 105, identifier:char; 106, subscript; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:charToHighlight; 110, integer:0; 111, block; 111, 112; 111, 116; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:start; 115, identifier:origin; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:stop; 119, call; 119, 120; 119, 127; 120, attribute; 120, 121; 120, 126; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:qteWidget; 124, identifier:toPlainText; 125, argument_list; 126, identifier:find; 127, argument_list; 127, 128; 127, 133; 128, subscript; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:charToHighlight; 132, integer:1; 133, binary_operator:+; 133, 134; 133, 135; 134, identifier:start; 135, integer:1; 136, else_clause; 136, 137; 137, block; 137, 138; 137, 142; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:stop; 141, identifier:origin; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:start; 145, call; 145, 146; 145, 153; 146, attribute; 146, 147; 146, 152; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:qteWidget; 150, identifier:toPlainText; 151, argument_list; 152, identifier:rfind; 153, argument_list; 153, 154; 153, 159; 153, 160; 154, subscript; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:charToHighlight; 158, integer:0; 159, integer:0; 160, identifier:stop; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:oldCharFormats; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:highlightCharacters; 168, argument_list; 168, 169; 168, 170; 168, 173; 168, 178; 169, identifier:qteWidget; 170, tuple; 170, 171; 170, 172; 171, identifier:start; 172, identifier:stop; 173, attribute; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:QtCore; 176, identifier:Qt; 177, identifier:blue; 178, integer:100; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:data; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:qteMacroData; 186, argument_list; 186, 187; 187, identifier:qteWidget; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:data; 192, identifier:matchingPositions; 193, tuple; 193, 194; 193, 195; 194, identifier:start; 195, identifier:stop; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:data; 200, identifier:oldCharFormats; 201, identifier:oldCharFormats; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:self; 206, identifier:qteSaveMacroData; 207, argument_list; 207, 208; 207, 209; 208, identifier:data; 209, identifier:qteWidget; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 217; 212, attribute; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:qteWidget; 215, identifier:cursorPositionChanged; 216, identifier:connect; 217, argument_list; 217, 218; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:cursorPositionChangedEvent | def cursorPositionChangedEvent(self):
qteWidget = self.sender()
tc = qteWidget.textCursor()
origin = tc.position()
qteWidget.cursorPositionChanged.disconnect(
self.cursorPositionChangedEvent)
self.qteRemoveHighlighting(qteWidget)
qteWidget.cursorPositionChanged.connect(
self.cursorPositionChangedEvent)
if origin >= len(qteWidget.toPlainText()):
return
else:
char = qteWidget.toPlainText()[origin]
if char not in self.charToHighlight:
return
qteWidget.cursorPositionChanged.disconnect(
self.cursorPositionChangedEvent)
if char == self.charToHighlight[0]:
start = origin
stop = qteWidget.toPlainText().find(self.charToHighlight[1],
start + 1)
else:
stop = origin
start = qteWidget.toPlainText().rfind(self.charToHighlight[0],
0, stop)
oldCharFormats = self.highlightCharacters(qteWidget, (start, stop),
QtCore.Qt.blue, 100)
data = self.qteMacroData(qteWidget)
data.matchingPositions = (start, stop)
data.oldCharFormats = oldCharFormats
self.qteSaveMacroData(data, qteWidget)
qteWidget.cursorPositionChanged.connect(
self.cursorPositionChangedEvent) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:scenarios; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:generate_seed; 7, False; 8, block; 8, 9; 8, 16; 8, 28; 8, 75; 8, 79; 8, 83; 8, 142; 8, 157; 8, 186; 8, 190; 8, 254; 8, 262; 8, 270; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:seed; 12, call; 12, 13; 12, 14; 13, identifier:prime_numbers; 14, argument_list; 14, 15; 15, integer:1000; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:sweeps_all; 19, call; 19, 20; 19, 27; 20, attribute; 20, 21; 20, 26; 21, subscript; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:experiment; 25, string:"sweeps"; 26, identifier:keys; 27, argument_list; 28, if_statement; 28, 29; 28, 34; 28, 67; 29, comparison_operator:in; 29, 30; 29, 31; 30, string:"combinations"; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:experiment; 34, block; 34, 35; 35, if_statement; 35, 36; 35, 45; 35, 57; 36, call; 36, 37; 36, 38; 37, identifier:isinstance; 38, argument_list; 38, 39; 38, 44; 39, subscript; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:experiment; 43, string:"combinations"; 44, identifier:list; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:combinations_in_experiment; 49, dictionary; 49, 50; 50, pair; 50, 51; 50, 52; 51, string:" "; 52, subscript; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:experiment; 56, string:"combinations"; 57, else_clause; 57, 58; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:combinations_in_experiment; 62, subscript; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:experiment; 66, string:"combinations"; 67, else_clause; 67, 68; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:combinations_in_experiment; 72, call; 72, 73; 72, 74; 73, identifier:dict; 74, argument_list; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:all_combinations_sweeps; 78, list:[]; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:all_combinations; 82, list:[]; 83, for_statement; 83, 84; 83, 87; 83, 92; 84, pattern_list; 84, 85; 84, 86; 85, identifier:key; 86, identifier:combinations_; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:combinations_in_experiment; 90, identifier:items; 91, argument_list; 92, block; 92, 93; 92, 122; 92, 133; 93, if_statement; 93, 94; 93, 96; 93, 106; 94, not_operator; 94, 95; 95, identifier:combinations_; 96, block; 96, 97; 96, 101; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:combinations_sweeps; 100, list:[]; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:combinations; 104, list:[[]]; 104, 105; 105, list:[]; 106, else_clause; 106, 107; 107, block; 107, 108; 107, 114; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:combinations_sweeps; 111, subscript; 111, 112; 111, 113; 112, identifier:combinations_; 113, integer:0; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:combinations; 117, subscript; 117, 118; 117, 119; 118, identifier:combinations_; 119, slice; 119, 120; 119, 121; 120, integer:1; 121, colon; 122, for_statement; 122, 123; 122, 124; 122, 125; 123, identifier:item; 124, identifier:combinations_sweeps; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:all_combinations_sweeps; 130, identifier:append; 131, argument_list; 131, 132; 132, identifier:item; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:all_combinations; 137, identifier:append; 138, argument_list; 138, 139; 139, tuple; 139, 140; 139, 141; 140, identifier:combinations_sweeps; 141, identifier:combinations; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:sweeps_fully_factorial; 145, call; 145, 146; 145, 147; 146, identifier:list; 147, argument_list; 147, 148; 148, binary_operator:-; 148, 149; 148, 153; 149, call; 149, 150; 149, 151; 150, identifier:set; 151, argument_list; 151, 152; 152, identifier:sweeps_all; 153, call; 153, 154; 153, 155; 154, identifier:set; 155, argument_list; 155, 156; 156, identifier:all_combinations_sweeps; 157, for_statement; 157, 158; 157, 159; 157, 160; 158, identifier:sweep; 159, identifier:sweeps_fully_factorial; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:all_combinations; 165, identifier:append; 166, argument_list; 166, 167; 167, tuple; 167, 168; 167, 170; 168, list:[sweep]; 168, 169; 169, identifier:sweep; 170, list_comprehension; 170, 171; 170, 173; 171, list:[x]; 171, 172; 172, identifier:x; 173, for_in_clause; 173, 174; 173, 175; 174, identifier:x; 175, call; 175, 176; 175, 185; 176, attribute; 176, 177; 176, 184; 177, subscript; 177, 178; 177, 183; 178, subscript; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:self; 181, identifier:experiment; 182, string:"sweeps"; 183, identifier:sweep; 184, identifier:keys; 185, argument_list; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:red_iter; 189, integer:0; 190, while_statement; 190, 191; 190, 197; 191, comparison_operator:>; 191, 192; 191, 196; 192, call; 192, 193; 192, 194; 193, identifier:len; 194, argument_list; 194, 195; 195, identifier:all_combinations; 196, integer:1; 197, block; 197, 198; 197, 204; 197, 210; 197, 220; 197, 237; 197, 250; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:comb1; 201, subscript; 201, 202; 201, 203; 202, identifier:all_combinations; 203, integer:0; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:comb2; 207, subscript; 207, 208; 207, 209; 208, identifier:all_combinations; 209, integer:1; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:new_sweeps; 213, binary_operator:+; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:comb1; 216, integer:0; 217, subscript; 217, 218; 217, 219; 218, identifier:comb2; 219, integer:0; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:new_combinations; 223, list_comprehension; 223, 224; 223, 227; 223, 232; 224, binary_operator:+; 224, 225; 224, 226; 225, identifier:x; 226, identifier:y; 227, for_in_clause; 227, 228; 227, 229; 228, identifier:x; 229, subscript; 229, 230; 229, 231; 230, identifier:comb1; 231, integer:1; 232, for_in_clause; 232, 233; 232, 234; 233, identifier:y; 234, subscript; 234, 235; 234, 236; 235, identifier:comb2; 236, integer:1; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:all_combinations; 240, binary_operator:+; 240, 241; 240, 245; 241, list:[(new_sweeps, new_combinations)]; 241, 242; 242, tuple; 242, 243; 242, 244; 243, identifier:new_sweeps; 244, identifier:new_combinations; 245, subscript; 245, 246; 245, 247; 246, identifier:all_combinations; 247, slice; 247, 248; 247, 249; 248, integer:2; 249, colon; 250, expression_statement; 250, 251; 251, augmented_assignment:+=; 251, 252; 251, 253; 252, identifier:red_iter; 253, integer:1; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:sweep_names; 257, subscript; 257, 258; 257, 261; 258, subscript; 258, 259; 258, 260; 259, identifier:all_combinations; 260, integer:0; 261, integer:0; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:combinations; 265, subscript; 265, 266; 265, 269; 266, subscript; 266, 267; 266, 268; 267, identifier:all_combinations; 268, integer:0; 269, integer:1; 270, for_statement; 270, 271; 270, 272; 270, 273; 271, identifier:combination; 272, identifier:combinations; 273, block; 273, 274; 273, 292; 273, 305; 273, 343; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:scenario; 277, call; 277, 278; 277, 279; 278, identifier:Scenario; 279, argument_list; 279, 280; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:self; 283, identifier:_apply_combination; 284, argument_list; 284, 285; 284, 290; 284, 291; 285, subscript; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:self; 288, identifier:experiment; 289, string:"base"; 290, identifier:sweep_names; 291, identifier:combination; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:scenario; 296, identifier:parameters; 297, call; 297, 298; 297, 299; 298, identifier:dict; 299, argument_list; 299, 300; 300, call; 300, 301; 300, 302; 301, identifier:zip; 302, argument_list; 302, 303; 302, 304; 303, identifier:sweep_names; 304, identifier:combination; 305, if_statement; 305, 306; 305, 307; 306, identifier:generate_seed; 307, block; 307, 308; 308, if_statement; 308, 309; 308, 314; 308, 335; 309, comparison_operator:in; 309, 310; 309, 311; 310, string:"@seed@"; 311, attribute; 311, 312; 311, 313; 312, identifier:scenario; 313, identifier:xml; 314, block; 314, 315; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:scenario; 319, identifier:xml; 320, call; 320, 321; 320, 326; 321, attribute; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, identifier:scenario; 324, identifier:xml; 325, identifier:replace; 326, argument_list; 326, 327; 326, 328; 327, string:"@seed@"; 328, call; 328, 329; 328, 330; 329, identifier:str; 330, argument_list; 330, 331; 331, call; 331, 332; 331, 333; 332, identifier:next; 333, argument_list; 333, 334; 334, identifier:seed; 335, else_clause; 335, 336; 336, block; 336, 337; 337, raise_statement; 337, 338; 338, parenthesized_expression; 338, 339; 339, call; 339, 340; 339, 341; 340, identifier:RuntimeError; 341, argument_list; 341, 342; 342, string:"@seed@ placeholder is not found"; 343, expression_statement; 343, 344; 344, yield; 344, 345; 345, identifier:scenario | def scenarios(self, generate_seed=False):
seed = prime_numbers(1000)
sweeps_all = self.experiment["sweeps"].keys()
if "combinations" in self.experiment:
if isinstance(self.experiment["combinations"], list):
combinations_in_experiment = {" ": self.experiment["combinations"]}
else:
combinations_in_experiment = self.experiment["combinations"]
else:
combinations_in_experiment = dict()
all_combinations_sweeps = []
all_combinations = []
for key, combinations_ in combinations_in_experiment.items():
if not combinations_:
combinations_sweeps = []
combinations = [[]]
else:
combinations_sweeps = combinations_[0]
combinations = combinations_[1:]
for item in combinations_sweeps:
all_combinations_sweeps.append(item)
all_combinations.append((combinations_sweeps, combinations))
sweeps_fully_factorial = list(set(sweeps_all) - set(all_combinations_sweeps))
for sweep in sweeps_fully_factorial:
all_combinations.append(([sweep], [[x] for x in self.experiment["sweeps"][sweep].keys()]))
red_iter = 0
while len(all_combinations) > 1:
comb1 = all_combinations[0]
comb2 = all_combinations[1]
new_sweeps = comb1[0] + comb2[0]
new_combinations = [x+y for x in comb1[1] for y in comb2[1]]
all_combinations = [(new_sweeps, new_combinations)] + all_combinations[2:]
red_iter += 1
sweep_names = all_combinations[0][0]
combinations = all_combinations[0][1]
for combination in combinations:
scenario = Scenario(self._apply_combination(self.experiment["base"], sweep_names, combination))
scenario.parameters = dict(zip(sweep_names, combination))
if generate_seed:
if "@seed@" in scenario.xml:
scenario.xml = scenario.xml.replace("@seed@", str(next(seed)))
else:
raise(RuntimeError("@seed@ placeholder is not found"))
yield scenario |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:subdict_by_keys; 3, parameters; 3, 4; 3, 5; 4, identifier:dict_obj; 5, identifier:keys; 6, block; 6, 7; 7, return_statement; 7, 8; 8, dictionary_comprehension; 8, 9; 8, 14; 9, pair; 9, 10; 9, 11; 10, identifier:k; 11, subscript; 11, 12; 11, 13; 12, identifier:dict_obj; 13, identifier:k; 14, for_in_clause; 14, 15; 14, 16; 15, identifier:k; 16, call; 16, 17; 16, 23; 17, attribute; 17, 18; 17, 22; 18, call; 18, 19; 18, 20; 19, identifier:set; 20, argument_list; 20, 21; 21, identifier:keys; 22, identifier:intersection; 23, argument_list; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:dict_obj; 27, identifier:keys; 28, argument_list | def subdict_by_keys(dict_obj, keys):
return {k: dict_obj[k] for k in set(keys).intersection(dict_obj.keys())} |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:deep_merge_dict; 3, parameters; 3, 4; 3, 5; 4, identifier:base; 5, identifier:priority; 6, block; 6, 7; 6, 24; 6, 33; 6, 70; 7, if_statement; 7, 8; 7, 21; 8, boolean_operator:or; 8, 9; 8, 15; 9, not_operator; 9, 10; 10, call; 10, 11; 10, 12; 11, identifier:isinstance; 12, argument_list; 12, 13; 12, 14; 13, identifier:base; 14, identifier:dict; 15, not_operator; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:isinstance; 18, argument_list; 18, 19; 18, 20; 19, identifier:priority; 20, identifier:dict; 21, block; 21, 22; 22, return_statement; 22, 23; 23, identifier:priority; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:result; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:copy; 30, identifier:deepcopy; 31, argument_list; 31, 32; 32, identifier:base; 33, for_statement; 33, 34; 33, 35; 33, 40; 34, identifier:key; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:priority; 38, identifier:keys; 39, argument_list; 40, block; 40, 41; 41, if_statement; 41, 42; 41, 45; 41, 60; 42, comparison_operator:in; 42, 43; 42, 44; 43, identifier:key; 44, identifier:base; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 51; 48, subscript; 48, 49; 48, 50; 49, identifier:result; 50, identifier:key; 51, call; 51, 52; 51, 53; 52, identifier:deep_merge_dict; 53, argument_list; 53, 54; 53, 57; 54, subscript; 54, 55; 54, 56; 55, identifier:base; 56, identifier:key; 57, subscript; 57, 58; 57, 59; 58, identifier:priority; 59, identifier:key; 60, else_clause; 60, 61; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:result; 66, identifier:key; 67, subscript; 67, 68; 67, 69; 68, identifier:priority; 69, identifier:key; 70, return_statement; 70, 71; 71, identifier:result | def deep_merge_dict(base, priority):
if not isinstance(base, dict) or not isinstance(priority, dict):
return priority
result = copy.deepcopy(base)
for key in priority.keys():
if key in base:
result[key] = deep_merge_dict(base[key], priority[key])
else:
result[key] = priority[key]
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:norm_int_dict; 3, parameters; 3, 4; 4, identifier:int_dict; 5, block; 5, 6; 5, 14; 5, 25; 5, 39; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:norm_dict; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:int_dict; 12, identifier:copy; 13, argument_list; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:val_sum; 17, call; 17, 18; 17, 19; 18, identifier:sum; 19, argument_list; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:norm_dict; 23, identifier:values; 24, argument_list; 25, for_statement; 25, 26; 25, 27; 25, 28; 26, identifier:key; 27, identifier:norm_dict; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, subscript; 31, 32; 31, 33; 32, identifier:norm_dict; 33, identifier:key; 34, binary_operator:/; 34, 35; 34, 38; 35, subscript; 35, 36; 35, 37; 36, identifier:norm_dict; 37, identifier:key; 38, identifier:val_sum; 39, return_statement; 39, 40; 40, identifier:norm_dict | def norm_int_dict(int_dict):
norm_dict = int_dict.copy()
val_sum = sum(norm_dict.values())
for key in norm_dict:
norm_dict[key] = norm_dict[key] / val_sum
return norm_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sum_num_dicts; 3, parameters; 3, 4; 3, 5; 4, identifier:dicts; 5, default_parameter; 5, 6; 5, 7; 6, identifier:normalize; 7, False; 8, block; 8, 9; 8, 13; 8, 37; 8, 45; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:sum_dict; 12, dictionary; 13, for_statement; 13, 14; 13, 15; 13, 16; 14, identifier:dicti; 15, identifier:dicts; 16, block; 16, 17; 17, for_statement; 17, 18; 17, 19; 17, 20; 18, identifier:key; 19, identifier:dicti; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 26; 23, subscript; 23, 24; 23, 25; 24, identifier:sum_dict; 25, identifier:key; 26, binary_operator:+; 26, 27; 26, 34; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:sum_dict; 30, identifier:get; 31, argument_list; 31, 32; 31, 33; 32, identifier:key; 33, integer:0; 34, subscript; 34, 35; 34, 36; 35, identifier:dicti; 36, identifier:key; 37, if_statement; 37, 38; 37, 39; 38, identifier:normalize; 39, block; 39, 40; 40, return_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:norm_int_dict; 43, argument_list; 43, 44; 44, identifier:sum_dict; 45, return_statement; 45, 46; 46, identifier:sum_dict | def sum_num_dicts(dicts, normalize=False):
sum_dict = {}
for dicti in dicts:
for key in dicti:
sum_dict[key] = sum_dict.get(key, 0) + dicti[key]
if normalize:
return norm_int_dict(sum_dict)
return sum_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:reverse_dict; 3, parameters; 3, 4; 4, identifier:dict_obj; 5, block; 5, 6; 5, 10; 5, 29; 5, 47; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:new_dict; 9, dictionary; 10, for_statement; 10, 11; 10, 12; 10, 13; 11, identifier:key; 12, identifier:dict_obj; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:add_to_dict_val_set; 17, argument_list; 17, 18; 17, 21; 17, 26; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:dict_obj; 20, identifier:new_dict; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:key; 23, subscript; 23, 24; 23, 25; 24, identifier:dict_obj; 25, identifier:key; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:val; 28, identifier:key; 29, for_statement; 29, 30; 29, 31; 29, 32; 30, identifier:key; 31, identifier:new_dict; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, subscript; 35, 36; 35, 37; 36, identifier:new_dict; 37, identifier:key; 38, call; 38, 39; 38, 40; 39, identifier:sorted; 40, argument_list; 40, 41; 40, 44; 41, subscript; 41, 42; 41, 43; 42, identifier:new_dict; 43, identifier:key; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:reverse; 46, False; 47, return_statement; 47, 48; 48, identifier:new_dict | def reverse_dict(dict_obj):
new_dict = {}
for key in dict_obj:
add_to_dict_val_set(dict_obj=new_dict, key=dict_obj[key], val=key)
for key in new_dict:
new_dict[key] = sorted(new_dict[key], reverse=False)
return new_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:flatten_dict; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:dict_obj; 5, default_parameter; 5, 6; 5, 7; 6, identifier:separator; 7, string:'.'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:flatten_lists; 10, False; 11, block; 11, 12; 11, 19; 11, 23; 11, 55; 11, 115; 11, 120; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:reducer; 15, call; 15, 16; 15, 17; 16, identifier:_get_key_reducer; 17, argument_list; 17, 18; 18, identifier:separator; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:flat; 22, dictionary; 23, function_definition; 23, 24; 23, 25; 23, 29; 24, function_name:_flatten_key_val; 25, parameters; 25, 26; 25, 27; 25, 28; 26, identifier:key; 27, identifier:val; 28, identifier:parent; 29, block; 29, 30; 29, 38; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:flat_key; 33, call; 33, 34; 33, 35; 34, identifier:reducer; 35, argument_list; 35, 36; 35, 37; 36, identifier:parent; 37, identifier:key; 38, try_statement; 38, 39; 38, 46; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:_flatten; 43, argument_list; 43, 44; 43, 45; 44, identifier:val; 45, identifier:flat_key; 46, except_clause; 46, 47; 46, 48; 47, identifier:TypeError; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 54; 51, subscript; 51, 52; 51, 53; 52, identifier:flat; 53, identifier:flat_key; 54, identifier:val; 55, function_definition; 55, 56; 55, 57; 55, 62; 56, function_name:_flatten; 57, parameters; 57, 58; 57, 59; 58, identifier:d; 59, default_parameter; 59, 60; 59, 61; 60, identifier:parent; 61, None; 62, block; 62, 63; 63, try_statement; 63, 64; 63, 82; 64, block; 64, 65; 65, for_statement; 65, 66; 65, 69; 65, 74; 66, pattern_list; 66, 67; 66, 68; 67, identifier:key; 68, identifier:val; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:d; 72, identifier:items; 73, argument_list; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:_flatten_key_val; 78, argument_list; 78, 79; 78, 80; 78, 81; 79, identifier:key; 80, identifier:val; 81, identifier:parent; 82, except_clause; 82, 83; 82, 84; 83, identifier:AttributeError; 84, block; 84, 85; 84, 96; 85, if_statement; 85, 86; 85, 93; 86, call; 86, 87; 86, 88; 87, identifier:isinstance; 88, argument_list; 88, 89; 88, 90; 89, identifier:d; 90, tuple; 90, 91; 90, 92; 91, identifier:str; 92, identifier:bytes; 93, block; 93, 94; 94, raise_statement; 94, 95; 95, identifier:TypeError; 96, for_statement; 96, 97; 96, 100; 96, 104; 97, pattern_list; 97, 98; 97, 99; 98, identifier:i; 99, identifier:value; 100, call; 100, 101; 100, 102; 101, identifier:enumerate; 102, argument_list; 102, 103; 103, identifier:d; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 108; 107, identifier:_flatten_key_val; 108, argument_list; 108, 109; 108, 113; 108, 114; 109, call; 109, 110; 109, 111; 110, identifier:str; 111, argument_list; 111, 112; 112, identifier:i; 113, identifier:value; 114, identifier:parent; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:_flatten; 118, argument_list; 118, 119; 119, identifier:dict_obj; 120, return_statement; 120, 121; 121, identifier:flat | def flatten_dict(dict_obj, separator='.', flatten_lists=False):
reducer = _get_key_reducer(separator)
flat = {}
def _flatten_key_val(key, val, parent):
flat_key = reducer(parent, key)
try:
_flatten(val, flat_key)
except TypeError:
flat[flat_key] = val
def _flatten(d, parent=None):
try:
for key, val in d.items():
_flatten_key_val(key, val, parent)
except AttributeError:
if isinstance(d, (str, bytes)):
raise TypeError
for i, value in enumerate(d):
_flatten_key_val(str(i), value, parent)
_flatten(dict_obj)
return flat |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:key_value_nested_generator; 3, parameters; 3, 4; 4, identifier:dict_obj; 5, block; 5, 6; 6, for_statement; 6, 7; 6, 10; 6, 15; 7, pattern_list; 7, 8; 7, 9; 8, identifier:key; 9, identifier:value; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:dict_obj; 13, identifier:items; 14, argument_list; 15, block; 15, 16; 16, if_statement; 16, 17; 16, 22; 16, 37; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 21; 20, identifier:value; 21, identifier:dict; 22, block; 22, 23; 23, for_statement; 23, 24; 23, 27; 23, 31; 24, pattern_list; 24, 25; 24, 26; 25, identifier:key; 26, identifier:value; 27, call; 27, 28; 27, 29; 28, identifier:key_value_nested_generator; 29, argument_list; 29, 30; 30, identifier:value; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, yield; 33, 34; 34, expression_list; 34, 35; 34, 36; 35, identifier:key; 36, identifier:value; 37, else_clause; 37, 38; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, yield; 40, 41; 41, expression_list; 41, 42; 41, 43; 42, identifier:key; 43, identifier:value | def key_value_nested_generator(dict_obj):
for key, value in dict_obj.items():
if isinstance(value, dict):
for key, value in key_value_nested_generator(value):
yield key, value
else:
yield key, value |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:key_tuple_value_nested_generator; 3, parameters; 3, 4; 4, identifier:dict_obj; 5, block; 5, 6; 6, for_statement; 6, 7; 6, 10; 6, 15; 7, pattern_list; 7, 8; 7, 9; 8, identifier:key; 9, identifier:value; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:dict_obj; 13, identifier:items; 14, argument_list; 15, block; 15, 16; 16, if_statement; 16, 17; 16, 22; 16, 43; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 21; 20, identifier:value; 21, identifier:dict; 22, block; 22, 23; 23, for_statement; 23, 24; 23, 27; 23, 31; 24, pattern_list; 24, 25; 24, 26; 25, identifier:nested_key; 26, identifier:value; 27, call; 27, 28; 27, 29; 28, identifier:key_tuple_value_nested_generator; 29, argument_list; 29, 30; 30, identifier:value; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, yield; 33, 34; 34, expression_list; 34, 35; 34, 42; 35, binary_operator:+; 35, 36; 35, 41; 36, call; 36, 37; 36, 38; 37, identifier:tuple; 38, argument_list; 38, 39; 39, list:[key]; 39, 40; 40, identifier:key; 41, identifier:nested_key; 42, identifier:value; 43, else_clause; 43, 44; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, yield; 46, 47; 47, expression_list; 47, 48; 47, 53; 48, call; 48, 49; 48, 50; 49, identifier:tuple; 50, argument_list; 50, 51; 51, list:[key]; 51, 52; 52, identifier:key; 53, identifier:value | def key_tuple_value_nested_generator(dict_obj):
for key, value in dict_obj.items():
if isinstance(value, dict):
for nested_key, value in key_tuple_value_nested_generator(value):
yield tuple([key]) + nested_key, value
else:
yield tuple([key]), value |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:release_lock; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:verbose; 7, identifier:VERBOSE; 8, default_parameter; 8, 9; 8, 10; 9, identifier:raiseError; 10, identifier:RAISE_ERROR; 11, block; 11, 12; 11, 241; 11, 333; 12, if_statement; 12, 13; 12, 24; 12, 33; 13, not_operator; 13, 14; 14, call; 14, 15; 14, 20; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:os; 18, identifier:path; 19, identifier:isfile; 20, argument_list; 20, 21; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:__lockPath; 24, block; 24, 25; 24, 29; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:released; 28, True; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:code; 32, integer:0; 33, else_clause; 33, 34; 34, block; 34, 35; 35, try_statement; 35, 36; 35, 59; 35, 101; 36, block; 36, 37; 37, with_statement; 37, 38; 37, 50; 38, with_clause; 38, 39; 39, with_item; 39, 40; 40, as_pattern; 40, 41; 40, 48; 41, call; 41, 42; 41, 43; 42, identifier:open; 43, argument_list; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:__lockPath; 47, string:'rb'; 48, as_pattern_target; 48, 49; 49, identifier:fd; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:lock; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:fd; 57, identifier:readlines; 58, argument_list; 59, except_clause; 59, 60; 59, 64; 60, as_pattern; 60, 61; 60, 62; 61, identifier:Exception; 62, as_pattern_target; 62, 63; 63, identifier:err; 64, block; 64, 65; 64, 81; 64, 85; 64, 96; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:code; 68, call; 68, 69; 68, 70; 69, identifier:Exception; 70, argument_list; 70, 71; 71, binary_operator:%; 71, 72; 71, 73; 72, string:"Unable to read release lock file '%s' (%s)"; 73, tuple; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:__lockPath; 77, call; 77, 78; 77, 79; 78, identifier:str; 79, argument_list; 79, 80; 80, identifier:err; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:released; 84, False; 85, if_statement; 85, 86; 85, 87; 86, identifier:verbose; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:print; 91, argument_list; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:str; 94, argument_list; 94, 95; 95, identifier:code; 96, if_statement; 96, 97; 96, 98; 97, identifier:raiseError; 98, block; 98, 99; 99, raise_statement; 99, 100; 100, identifier:code; 101, else_clause; 101, 102; 102, block; 102, 103; 103, if_statement; 103, 104; 103, 109; 103, 118; 103, 231; 104, not_operator; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:len; 107, argument_list; 107, 108; 108, identifier:lock; 109, block; 109, 110; 109, 114; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:code; 113, integer:1; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:released; 117, True; 118, elif_clause; 118, 119; 118, 134; 119, comparison_operator:==; 119, 120; 119, 127; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:lock; 124, integer:0; 125, identifier:rstrip; 126, argument_list; 127, call; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:__lockPass; 132, identifier:encode; 133, argument_list; 134, block; 134, 135; 135, try_statement; 135, 136; 135, 179; 135, 221; 136, block; 136, 137; 137, with_statement; 137, 138; 137, 150; 138, with_clause; 138, 139; 139, with_item; 139, 140; 140, as_pattern; 140, 141; 140, 148; 141, call; 141, 142; 141, 143; 142, identifier:open; 143, argument_list; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:__lockPath; 147, string:'wb'; 148, as_pattern_target; 148, 149; 149, identifier:f; 150, block; 150, 151; 150, 162; 150, 168; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:f; 155, identifier:write; 156, argument_list; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, string:''; 160, identifier:encode; 161, argument_list; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:f; 166, identifier:flush; 167, argument_list; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:os; 172, identifier:fsync; 173, argument_list; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:f; 177, identifier:fileno; 178, argument_list; 179, except_clause; 179, 180; 179, 184; 180, as_pattern; 180, 181; 180, 182; 181, identifier:Exception; 182, as_pattern_target; 182, 183; 183, identifier:err; 184, block; 184, 185; 184, 189; 184, 205; 184, 216; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:released; 188, False; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:code; 192, call; 192, 193; 192, 194; 193, identifier:Exception; 194, argument_list; 194, 195; 195, binary_operator:%; 195, 196; 195, 197; 196, string:"Unable to write release lock file '%s' (%s)"; 197, tuple; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:__lockPath; 201, call; 201, 202; 201, 203; 202, identifier:str; 203, argument_list; 203, 204; 204, identifier:err; 205, if_statement; 205, 206; 205, 207; 206, identifier:verbose; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, call; 209, 210; 209, 211; 210, identifier:print; 211, argument_list; 211, 212; 212, call; 212, 213; 212, 214; 213, identifier:str; 214, argument_list; 214, 215; 215, identifier:code; 216, if_statement; 216, 217; 216, 218; 217, identifier:raiseError; 218, block; 218, 219; 219, raise_statement; 219, 220; 220, identifier:code; 221, else_clause; 221, 222; 222, block; 222, 223; 222, 227; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:released; 226, True; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:code; 230, integer:2; 231, else_clause; 231, 232; 232, block; 232, 233; 232, 237; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:code; 236, integer:4; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:released; 240, False; 241, if_statement; 241, 242; 241, 249; 242, boolean_operator:and; 242, 243; 242, 244; 243, identifier:released; 244, comparison_operator:is; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:self; 247, identifier:__fd; 248, None; 249, block; 249, 250; 250, try_statement; 250, 251; 250, 289; 250, 327; 251, block; 251, 252; 252, if_statement; 252, 253; 252, 259; 253, not_operator; 253, 254; 254, attribute; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:self; 257, identifier:__fd; 258, identifier:closed; 259, block; 259, 260; 259, 268; 259, 281; 260, expression_statement; 260, 261; 261, call; 261, 262; 261, 267; 262, attribute; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:self; 265, identifier:__fd; 266, identifier:flush; 267, argument_list; 268, expression_statement; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:os; 272, identifier:fsync; 273, argument_list; 273, 274; 274, call; 274, 275; 274, 280; 275, attribute; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:self; 278, identifier:__fd; 279, identifier:fileno; 280, argument_list; 281, expression_statement; 281, 282; 282, call; 282, 283; 282, 288; 283, attribute; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:self; 286, identifier:__fd; 287, identifier:close; 288, argument_list; 289, except_clause; 289, 290; 289, 294; 290, as_pattern; 290, 291; 290, 292; 291, identifier:Exception; 292, as_pattern_target; 292, 293; 293, identifier:err; 294, block; 294, 295; 294, 311; 294, 322; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:code; 298, call; 298, 299; 298, 300; 299, identifier:Exception; 300, argument_list; 300, 301; 301, binary_operator:%; 301, 302; 301, 303; 302, string:"Unable to close file descriptor of locked file '%s' (%s)"; 303, tuple; 303, 304; 303, 307; 304, attribute; 304, 305; 304, 306; 305, identifier:self; 306, identifier:__filePath; 307, call; 307, 308; 307, 309; 308, identifier:str; 309, argument_list; 309, 310; 310, identifier:err; 311, if_statement; 311, 312; 311, 313; 312, identifier:verbose; 313, block; 313, 314; 314, expression_statement; 314, 315; 315, call; 315, 316; 315, 317; 316, identifier:print; 317, argument_list; 317, 318; 318, call; 318, 319; 318, 320; 319, identifier:str; 320, argument_list; 320, 321; 321, identifier:code; 322, if_statement; 322, 323; 322, 324; 323, identifier:raiseError; 324, block; 324, 325; 325, raise_statement; 325, 326; 326, identifier:code; 327, else_clause; 327, 328; 328, block; 328, 329; 329, expression_statement; 329, 330; 330, assignment; 330, 331; 330, 332; 331, identifier:code; 332, integer:3; 333, return_statement; 333, 334; 334, expression_list; 334, 335; 334, 336; 335, identifier:released; 336, identifier:code | def release_lock(self, verbose=VERBOSE, raiseError=RAISE_ERROR):
if not os.path.isfile(self.__lockPath):
released = True
code = 0
else:
try:
with open(self.__lockPath, 'rb') as fd:
lock = fd.readlines()
except Exception as err:
code = Exception( "Unable to read release lock file '%s' (%s)"%(self.__lockPath,str(err)) )
released = False
if verbose: print(str(code))
if raiseError: raise code
else:
if not len(lock):
code = 1
released = True
elif lock[0].rstrip() == self.__lockPass.encode():
try:
with open(self.__lockPath, 'wb') as f:
f.write( ''.encode() )
f.flush()
os.fsync(f.fileno())
except Exception as err:
released = False
code = Exception( "Unable to write release lock file '%s' (%s)"%(self.__lockPath,str(err)) )
if verbose: print(str(code))
if raiseError: raise code
else:
released = True
code = 2
else:
code = 4
released = False
if released and self.__fd is not None:
try:
if not self.__fd.closed:
self.__fd.flush()
os.fsync(self.__fd.fileno())
self.__fd.close()
except Exception as err:
code = Exception( "Unable to close file descriptor of locked file '%s' (%s)"%(self.__filePath,str(err)) )
if verbose: print(str(code))
if raiseError: raise code
else:
code = 3
return released, code |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:guess_codec; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:file; 5, default_parameter; 5, 6; 5, 7; 6, identifier:errors; 7, string:"strict"; 8, default_parameter; 8, 9; 8, 10; 9, identifier:require_char; 10, False; 11, block; 11, 12; 11, 19; 11, 26; 11, 34; 11, 40; 11, 216; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:gedcom_char_to_codec; 15, dictionary; 15, 16; 16, pair; 16, 17; 16, 18; 17, string:'ansel'; 18, string:'gedcom'; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:bom_codec; 22, call; 22, 23; 22, 24; 23, identifier:check_bom; 24, argument_list; 24, 25; 25, identifier:file; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:bom_size; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:file; 32, identifier:tell; 33, argument_list; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:codec; 37, boolean_operator:or; 37, 38; 37, 39; 38, identifier:bom_codec; 39, string:'gedcom'; 40, while_statement; 40, 41; 40, 42; 41, True; 42, block; 42, 43; 42, 51; 42, 60; 42, 73; 42, 81; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:line; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:file; 49, identifier:readline; 50, argument_list; 51, if_statement; 51, 52; 51, 54; 52, not_operator; 52, 53; 53, identifier:line; 54, block; 54, 55; 55, raise_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:IOError; 58, argument_list; 58, 59; 59, string:"Unexpected EOF while reading GEDCOM header"; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:line; 63, call; 63, 64; 63, 71; 64, attribute; 64, 65; 64, 70; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:line; 68, identifier:lstrip; 69, argument_list; 70, identifier:rstrip; 71, argument_list; 71, 72; 72, string:b"\r\n"; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:words; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:line; 79, identifier:split; 80, argument_list; 81, if_statement; 81, 82; 81, 100; 81, 112; 82, boolean_operator:and; 82, 83; 82, 95; 83, boolean_operator:and; 83, 84; 83, 90; 84, comparison_operator:>=; 84, 85; 84, 89; 85, call; 85, 86; 85, 87; 86, identifier:len; 87, argument_list; 87, 88; 88, identifier:words; 89, integer:2; 90, comparison_operator:==; 90, 91; 90, 94; 91, subscript; 91, 92; 91, 93; 92, identifier:words; 93, integer:0; 94, string:b"0"; 95, comparison_operator:!=; 95, 96; 95, 99; 96, subscript; 96, 97; 96, 98; 97, identifier:words; 98, integer:1; 99, string:b"HEAD"; 100, block; 100, 101; 101, if_statement; 101, 102; 101, 103; 101, 109; 102, identifier:require_char; 103, block; 103, 104; 104, raise_statement; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:CodecError; 107, argument_list; 107, 108; 108, string:"GEDCOM header does not have CHAR record"; 109, else_clause; 109, 110; 110, block; 110, 111; 111, break_statement; 112, elif_clause; 112, 113; 112, 131; 113, boolean_operator:and; 113, 114; 113, 126; 114, boolean_operator:and; 114, 115; 114, 121; 115, comparison_operator:>=; 115, 116; 115, 120; 116, call; 116, 117; 116, 118; 117, identifier:len; 118, argument_list; 118, 119; 119, identifier:words; 120, integer:3; 121, comparison_operator:==; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:words; 124, integer:0; 125, string:b"1"; 126, comparison_operator:==; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:words; 129, integer:1; 130, string:b"CHAR"; 131, block; 131, 132; 131, 188; 131, 215; 132, try_statement; 132, 133; 132, 175; 133, block; 133, 134; 133, 146; 133, 164; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:encoding; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:words; 141, integer:2; 142, identifier:decode; 143, argument_list; 143, 144; 143, 145; 144, identifier:codec; 145, identifier:errors; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:encoding; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:gedcom_char_to_codec; 152, identifier:get; 153, argument_list; 153, 154; 153, 159; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:encoding; 157, identifier:lower; 158, argument_list; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:encoding; 162, identifier:lower; 163, argument_list; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:new_codec; 167, attribute; 167, 168; 167, 174; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:codecs; 171, identifier:lookup; 172, argument_list; 172, 173; 173, identifier:encoding; 174, identifier:name; 175, except_clause; 175, 176; 175, 177; 176, identifier:LookupError; 177, block; 177, 178; 178, raise_statement; 178, 179; 179, call; 179, 180; 179, 181; 180, identifier:CodecError; 181, argument_list; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, string:"Unknown codec name {0}"; 185, identifier:format; 186, argument_list; 186, 187; 187, identifier:encoding; 188, if_statement; 188, 189; 188, 192; 188, 197; 189, comparison_operator:is; 189, 190; 189, 191; 190, identifier:bom_codec; 191, None; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:codec; 196, identifier:new_codec; 197, elif_clause; 197, 198; 197, 201; 198, comparison_operator:!=; 198, 199; 198, 200; 199, identifier:new_codec; 200, identifier:bom_codec; 201, block; 201, 202; 202, raise_statement; 202, 203; 203, call; 203, 204; 203, 205; 204, identifier:CodecError; 205, argument_list; 205, 206; 206, call; 206, 207; 206, 212; 207, attribute; 207, 208; 207, 211; 208, concatenated_string; 208, 209; 208, 210; 209, string:"CHAR codec {0} is different from BOM "; 210, string:"codec {1}"; 211, identifier:format; 212, argument_list; 212, 213; 212, 214; 213, identifier:new_codec; 214, identifier:bom_codec; 215, break_statement; 216, return_statement; 216, 217; 217, expression_list; 217, 218; 217, 219; 218, identifier:codec; 219, identifier:bom_size | def guess_codec(file, errors="strict", require_char=False):
gedcom_char_to_codec = {
'ansel': 'gedcom',
}
bom_codec = check_bom(file)
bom_size = file.tell()
codec = bom_codec or 'gedcom'
while True:
line = file.readline()
if not line:
raise IOError("Unexpected EOF while reading GEDCOM header")
line = line.lstrip().rstrip(b"\r\n")
words = line.split()
if len(words) >= 2 and words[0] == b"0" and words[1] != b"HEAD":
if require_char:
raise CodecError("GEDCOM header does not have CHAR record")
else:
break
elif len(words) >= 3 and words[0] == b"1" and words[1] == b"CHAR":
try:
encoding = words[2].decode(codec, errors)
encoding = gedcom_char_to_codec.get(encoding.lower(),
encoding.lower())
new_codec = codecs.lookup(encoding).name
except LookupError:
raise CodecError("Unknown codec name {0}".format(encoding))
if bom_codec is None:
codec = new_codec
elif new_codec != bom_codec:
raise CodecError("CHAR codec {0} is different from BOM "
"codec {1}".format(new_codec, bom_codec))
break
return codec, bom_size |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:read_record; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:offset; 6, block; 6, 7; 6, 15; 6, 19; 6, 23; 6, 161; 6, 214; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:_log; 11, identifier:debug; 12, argument_list; 12, 13; 12, 14; 13, string:"in read_record(%s)"; 14, identifier:offset; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:stack; 18, list:[]; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:reclevel; 22, None; 23, for_statement; 23, 24; 23, 25; 23, 31; 24, identifier:gline; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:gedcom_lines; 29, argument_list; 29, 30; 30, identifier:offset; 31, block; 31, 32; 31, 40; 31, 46; 31, 61; 31, 106; 31, 114; 31, 132; 31, 145; 31, 155; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:_log; 36, identifier:debug; 37, argument_list; 37, 38; 37, 39; 38, string:" read_record, gline: %s"; 39, identifier:gline; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:level; 43, attribute; 43, 44; 43, 45; 44, identifier:gline; 45, identifier:level; 46, if_statement; 46, 47; 46, 50; 46, 55; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:reclevel; 49, None; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:reclevel; 54, identifier:level; 55, elif_clause; 55, 56; 55, 59; 56, comparison_operator:<=; 56, 57; 56, 58; 57, identifier:level; 58, identifier:reclevel; 59, block; 59, 60; 60, break_statement; 61, for_statement; 61, 62; 61, 63; 61, 71; 62, identifier:rec; 63, call; 63, 64; 63, 65; 64, identifier:reversed; 65, argument_list; 65, 66; 66, subscript; 66, 67; 66, 68; 67, identifier:stack; 68, slice; 68, 69; 68, 70; 69, identifier:level; 70, colon; 71, block; 71, 72; 72, if_statement; 72, 73; 72, 74; 73, identifier:rec; 74, block; 74, 75; 74, 100; 75, if_statement; 75, 76; 75, 81; 76, comparison_operator:is; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:rec; 79, identifier:value; 80, None; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:rec; 86, identifier:value; 87, call; 87, 88; 87, 93; 88, attribute; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:rec; 91, identifier:value; 92, identifier:decode; 93, argument_list; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:_encoding; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:_errors; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:rec; 104, identifier:freeze; 105, argument_list; 106, delete_statement; 106, 107; 107, subscript; 107, 108; 107, 109; 108, identifier:stack; 109, slice; 109, 110; 109, 113; 110, binary_operator:+; 110, 111; 110, 112; 111, identifier:level; 112, integer:1; 113, colon; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:stack; 118, identifier:extend; 119, argument_list; 119, 120; 120, binary_operator:*; 120, 121; 120, 123; 121, list:[None]; 121, 122; 122, None; 123, parenthesized_expression; 123, 124; 124, binary_operator:-; 124, 125; 124, 128; 125, binary_operator:+; 125, 126; 125, 127; 126, identifier:level; 127, integer:1; 128, call; 128, 129; 128, 130; 129, identifier:len; 130, argument_list; 130, 131; 131, identifier:stack; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:parent; 135, conditional_expression:if; 135, 136; 135, 141; 135, 144; 136, subscript; 136, 137; 136, 138; 137, identifier:stack; 138, binary_operator:-; 138, 139; 138, 140; 139, identifier:level; 140, integer:1; 141, comparison_operator:>; 141, 142; 141, 143; 142, identifier:level; 143, integer:0; 144, None; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:rec; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:_make_record; 152, argument_list; 152, 153; 152, 154; 153, identifier:parent; 154, identifier:gline; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:stack; 159, identifier:level; 160, identifier:rec; 161, for_statement; 161, 162; 161, 163; 161, 171; 162, identifier:rec; 163, call; 163, 164; 163, 165; 164, identifier:reversed; 165, argument_list; 165, 166; 166, subscript; 166, 167; 166, 168; 167, identifier:stack; 168, slice; 168, 169; 168, 170; 169, identifier:reclevel; 170, colon; 171, block; 171, 172; 172, if_statement; 172, 173; 172, 174; 173, identifier:rec; 174, block; 174, 175; 174, 200; 174, 206; 175, if_statement; 175, 176; 175, 181; 176, comparison_operator:is; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:rec; 179, identifier:value; 180, None; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:rec; 186, identifier:value; 187, call; 187, 188; 187, 193; 188, attribute; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:rec; 191, identifier:value; 192, identifier:decode; 193, argument_list; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:self; 196, identifier:_encoding; 197, attribute; 197, 198; 197, 199; 198, identifier:self; 199, identifier:_errors; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:rec; 204, identifier:freeze; 205, argument_list; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:_log; 210, identifier:debug; 211, argument_list; 211, 212; 211, 213; 212, string:" read_record, rec: %s"; 213, identifier:rec; 214, return_statement; 214, 215; 215, conditional_expression:if; 215, 216; 215, 219; 215, 220; 216, subscript; 216, 217; 216, 218; 217, identifier:stack; 218, identifier:reclevel; 219, identifier:stack; 220, None | def read_record(self, offset):
_log.debug("in read_record(%s)", offset)
stack = []
reclevel = None
for gline in self.gedcom_lines(offset):
_log.debug(" read_record, gline: %s", gline)
level = gline.level
if reclevel is None:
reclevel = level
elif level <= reclevel:
break
for rec in reversed(stack[level:]):
if rec:
if rec.value is not None:
rec.value = rec.value.decode(self._encoding,
self._errors)
rec.freeze()
del stack[level + 1:]
stack.extend([None] * (level + 1 - len(stack)))
parent = stack[level - 1] if level > 0 else None
rec = self._make_record(parent, gline)
stack[level] = rec
for rec in reversed(stack[reclevel:]):
if rec:
if rec.value is not None:
rec.value = rec.value.decode(self._encoding, self._errors)
rec.freeze()
_log.debug(" read_record, rec: %s", rec)
return stack[reclevel] if stack else None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_make_record; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:parent; 6, identifier:gline; 7, block; 7, 8; 7, 68; 7, 74; 7, 99; 7, 141; 7, 153; 8, if_statement; 8, 9; 8, 18; 9, boolean_operator:and; 9, 10; 9, 11; 10, identifier:parent; 11, comparison_operator:in; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:gline; 14, identifier:tag; 15, tuple; 15, 16; 15, 17; 16, string:"CONT"; 17, string:"CONC"; 18, block; 18, 19; 18, 66; 19, if_statement; 19, 20; 19, 25; 20, comparison_operator:!=; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:parent; 23, identifier:tag; 24, string:"BLOB"; 25, block; 25, 26; 25, 32; 25, 48; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:value; 29, attribute; 29, 30; 29, 31; 30, identifier:gline; 31, identifier:value; 32, if_statement; 32, 33; 32, 38; 33, comparison_operator:==; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:gline; 36, identifier:tag; 37, string:"CONT"; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:value; 42, binary_operator:+; 42, 43; 42, 44; 43, string:b"\n"; 44, parenthesized_expression; 44, 45; 45, boolean_operator:or; 45, 46; 45, 47; 46, identifier:value; 47, string:b""; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:value; 51, None; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:parent; 57, identifier:value; 58, binary_operator:+; 58, 59; 58, 65; 59, parenthesized_expression; 59, 60; 60, boolean_operator:or; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:parent; 63, identifier:value; 64, string:b""; 65, identifier:value; 66, return_statement; 66, 67; 67, None; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:dialect; 71, attribute; 71, 72; 71, 73; 72, identifier:model; 73, identifier:DIALECT_DEFAULT; 74, if_statement; 74, 75; 74, 92; 75, boolean_operator:and; 75, 76; 75, 89; 76, not_operator; 76, 77; 77, parenthesized_expression; 77, 78; 78, boolean_operator:and; 78, 79; 78, 84; 79, comparison_operator:==; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:gline; 82, identifier:level; 83, integer:0; 84, comparison_operator:==; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:gline; 87, identifier:tag; 88, string:"HEAD"; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:_header; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:dialect; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:dialect; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:rec; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:model; 105, identifier:make_record; 106, argument_list; 106, 107; 106, 112; 106, 117; 106, 122; 106, 127; 106, 130; 106, 135; 106, 138; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:level; 109, attribute; 109, 110; 109, 111; 110, identifier:gline; 111, identifier:level; 112, keyword_argument; 112, 113; 112, 114; 113, identifier:xref_id; 114, attribute; 114, 115; 114, 116; 115, identifier:gline; 116, identifier:xref_id; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:tag; 119, attribute; 119, 120; 119, 121; 120, identifier:gline; 121, identifier:tag; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:value; 124, attribute; 124, 125; 124, 126; 125, identifier:gline; 126, identifier:value; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:sub_records; 129, list:[]; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:offset; 132, attribute; 132, 133; 132, 134; 133, identifier:gline; 134, identifier:offset; 135, keyword_argument; 135, 136; 135, 137; 136, identifier:dialect; 137, identifier:dialect; 138, keyword_argument; 138, 139; 138, 140; 139, identifier:parser; 140, identifier:self; 141, if_statement; 141, 142; 141, 143; 142, identifier:parent; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 151; 146, attribute; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:parent; 149, identifier:sub_records; 150, identifier:append; 151, argument_list; 151, 152; 152, identifier:rec; 153, return_statement; 153, 154; 154, identifier:rec | def _make_record(self, parent, gline):
if parent and gline.tag in ("CONT", "CONC"):
if parent.tag != "BLOB":
value = gline.value
if gline.tag == "CONT":
value = b"\n" + (value or b"")
if value is not None:
parent.value = (parent.value or b"") + value
return None
dialect = model.DIALECT_DEFAULT
if not (gline.level == 0 and gline.tag == "HEAD") and self._header:
dialect = self.dialect
rec = model.make_record(level=gline.level, xref_id=gline.xref_id,
tag=gline.tag, value=gline.value,
sub_records=[], offset=gline.offset,
dialect=dialect, parser=self)
if parent:
parent.sub_records.append(rec)
return rec |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:parse; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:cls; 5, identifier:gvid; 6, default_parameter; 6, 7; 6, 8; 7, identifier:exception; 8, True; 9, block; 9, 10; 9, 25; 9, 34; 9, 57; 9, 143; 9, 182; 9, 193; 9, 210; 9, 218; 9, 224; 9, 245; 9, 264; 9, 274; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:==; 11, 12; 11, 13; 12, identifier:gvid; 13, string:'invalid'; 14, block; 14, 15; 15, return_statement; 15, 16; 16, call; 16, 17; 16, 23; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:cls; 20, identifier:get_class; 21, argument_list; 21, 22; 22, string:'null'; 23, argument_list; 23, 24; 24, integer:0; 25, if_statement; 25, 26; 25, 31; 26, not_operator; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:bool; 29, argument_list; 29, 30; 30, identifier:gvid; 31, block; 31, 32; 32, return_statement; 32, 33; 33, None; 34, if_statement; 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:gvid; 40, attribute; 40, 41; 40, 42; 41, identifier:six; 42, identifier:string_types; 43, block; 43, 44; 44, raise_statement; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:TypeError; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, string:"Can't parse; not a string. Got a '{}' "; 51, identifier:format; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:type; 55, argument_list; 55, 56; 56, identifier:gvid; 57, try_statement; 57, 58; 57, 108; 58, block; 58, 59; 59, if_statement; 59, 60; 59, 64; 59, 100; 60, not_operator; 60, 61; 61, attribute; 61, 62; 61, 63; 62, identifier:cls; 63, identifier:sl; 64, block; 64, 65; 64, 86; 65, if_statement; 65, 66; 65, 69; 65, 76; 66, attribute; 66, 67; 66, 68; 67, identifier:six; 68, identifier:PY3; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:fn; 73, attribute; 73, 74; 73, 75; 74, identifier:cls; 75, identifier:decode; 76, else_clause; 76, 77; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:fn; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:cls; 84, identifier:decode; 85, identifier:__func__; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:sl; 89, call; 89, 90; 89, 91; 90, identifier:fn; 91, argument_list; 91, 92; 92, subscript; 92, 93; 92, 94; 93, identifier:gvid; 94, slice; 94, 95; 94, 96; 94, 97; 95, integer:0; 96, colon; 97, attribute; 97, 98; 97, 99; 98, identifier:cls; 99, identifier:sl_width; 100, else_clause; 100, 101; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:sl; 105, attribute; 105, 106; 105, 107; 106, identifier:cls; 107, identifier:sl; 108, except_clause; 108, 109; 108, 113; 109, as_pattern; 109, 110; 109, 111; 110, identifier:ValueError; 111, as_pattern_target; 111, 112; 112, identifier:e; 113, block; 113, 114; 114, if_statement; 114, 115; 114, 116; 114, 131; 115, identifier:exception; 116, block; 116, 117; 117, raise_statement; 117, 118; 118, call; 118, 119; 118, 120; 119, identifier:ValueError; 120, argument_list; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, string:"Failed to parse gvid '{}': {}"; 124, identifier:format; 125, argument_list; 125, 126; 125, 127; 126, identifier:gvid; 127, call; 127, 128; 127, 129; 128, identifier:str; 129, argument_list; 129, 130; 130, identifier:e; 131, else_clause; 131, 132; 132, block; 132, 133; 133, return_statement; 133, 134; 134, call; 134, 135; 134, 141; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:cls; 138, identifier:get_class; 139, argument_list; 139, 140; 140, string:'null'; 141, argument_list; 141, 142; 142, integer:0; 143, try_statement; 143, 144; 143, 153; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:cls; 148, subscript; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:cls; 151, identifier:sl_map; 152, identifier:sl; 153, except_clause; 153, 154; 153, 155; 154, identifier:KeyError; 155, block; 155, 156; 156, if_statement; 156, 157; 156, 158; 156, 170; 157, identifier:exception; 158, block; 158, 159; 159, raise_statement; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:ValueError; 162, argument_list; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, string:"Failed to parse gvid '{}': Unknown summary level '{}' "; 166, identifier:format; 167, argument_list; 167, 168; 167, 169; 168, identifier:gvid; 169, identifier:sl; 170, else_clause; 170, 171; 171, block; 171, 172; 172, return_statement; 172, 173; 173, call; 173, 174; 173, 180; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:cls; 177, identifier:get_class; 178, argument_list; 178, 179; 179, string:'null'; 180, argument_list; 180, 181; 181, integer:0; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:m; 185, call; 185, 186; 185, 191; 186, attribute; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:cls; 189, identifier:regex; 190, identifier:match; 191, argument_list; 191, 192; 192, identifier:gvid; 193, if_statement; 193, 194; 193, 196; 194, not_operator; 194, 195; 195, identifier:m; 196, block; 196, 197; 197, raise_statement; 197, 198; 198, call; 198, 199; 198, 200; 199, identifier:ValueError; 200, argument_list; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, string:"Failed to match '{}' to '{}' "; 204, identifier:format; 205, argument_list; 205, 206; 205, 207; 206, identifier:gvid; 207, attribute; 207, 208; 207, 209; 208, identifier:cls; 209, identifier:regex_str; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:d; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:m; 216, identifier:groupdict; 217, argument_list; 218, if_statement; 218, 219; 218, 221; 219, not_operator; 219, 220; 220, identifier:d; 221, block; 221, 222; 222, return_statement; 222, 223; 223, None; 224, if_statement; 224, 225; 224, 228; 224, 235; 225, attribute; 225, 226; 225, 227; 226, identifier:six; 227, identifier:PY3; 228, block; 228, 229; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:fn; 232, attribute; 232, 233; 232, 234; 233, identifier:cls; 234, identifier:decode; 235, else_clause; 235, 236; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:fn; 240, attribute; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:cls; 243, identifier:decode; 244, identifier:__func__; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:d; 248, dictionary_comprehension; 248, 249; 248, 255; 249, pair; 249, 250; 249, 251; 250, identifier:k; 251, call; 251, 252; 251, 253; 252, identifier:fn; 253, argument_list; 253, 254; 254, identifier:v; 255, for_in_clause; 255, 256; 255, 259; 256, pattern_list; 256, 257; 256, 258; 257, identifier:k; 258, identifier:v; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:d; 262, identifier:items; 263, argument_list; 264, try_statement; 264, 265; 264, 270; 265, block; 265, 266; 266, delete_statement; 266, 267; 267, subscript; 267, 268; 267, 269; 268, identifier:d; 269, string:'sl'; 270, except_clause; 270, 271; 270, 272; 271, identifier:KeyError; 272, block; 272, 273; 273, pass_statement; 274, return_statement; 274, 275; 275, call; 275, 276; 275, 277; 276, identifier:cls; 277, argument_list; 277, 278; 278, dictionary_splat; 278, 279; 279, identifier:d | def parse(cls, gvid, exception=True):
if gvid == 'invalid':
return cls.get_class('null')(0)
if not bool(gvid):
return None
if not isinstance(gvid, six.string_types):
raise TypeError("Can't parse; not a string. Got a '{}' ".format(type(gvid)))
try:
if not cls.sl:
if six.PY3:
fn = cls.decode
else:
fn = cls.decode.__func__
sl = fn(gvid[0:cls.sl_width])
else:
sl = cls.sl
except ValueError as e:
if exception:
raise ValueError("Failed to parse gvid '{}': {}".format(gvid, str(e)))
else:
return cls.get_class('null')(0)
try:
cls = cls.sl_map[sl]
except KeyError:
if exception:
raise ValueError("Failed to parse gvid '{}': Unknown summary level '{}' ".format(gvid, sl))
else:
return cls.get_class('null')(0)
m = cls.regex.match(gvid)
if not m:
raise ValueError("Failed to match '{}' to '{}' ".format(gvid, cls.regex_str))
d = m.groupdict()
if not d:
return None
if six.PY3:
fn = cls.decode
else:
fn = cls.decode.__func__
d = {k: fn(v) for k, v in d.items()}
try:
del d['sl']
except KeyError:
pass
return cls(**d) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:filter_pastdate; 3, parameters; 3, 4; 3, 5; 4, identifier:string; 5, default_parameter; 5, 6; 5, 7; 6, identifier:default; 7, None; 8, block; 8, 9; 8, 19; 8, 29; 8, 53; 8, 73; 8, 116; 8, 172; 8, 178; 9, if_statement; 9, 10; 9, 16; 10, boolean_operator:and; 10, 11; 10, 13; 11, not_operator; 11, 12; 12, identifier:string; 13, comparison_operator:is; 13, 14; 13, 15; 14, identifier:default; 15, None; 16, block; 16, 17; 17, return_statement; 17, 18; 18, identifier:default; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:today; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:datetime; 26, identifier:date; 27, identifier:today; 28, argument_list; 29, try_statement; 29, 30; 29, 45; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:parts; 34, call; 34, 35; 34, 36; 35, identifier:map; 36, argument_list; 36, 37; 36, 38; 37, identifier:int; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:re; 41, identifier:split; 42, argument_list; 42, 43; 42, 44; 43, string:'\D+'; 44, identifier:string; 45, except_clause; 45, 46; 45, 47; 46, identifier:ValueError; 47, block; 47, 48; 48, raise_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:InvalidInputError; 51, argument_list; 51, 52; 52, string:"invalid date; use format: DD [MM [YYYY]]"; 53, if_statement; 53, 54; 53, 67; 54, boolean_operator:or; 54, 55; 54, 61; 55, comparison_operator:<; 55, 56; 55, 60; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, identifier:parts; 60, integer:1; 61, comparison_operator:>; 61, 62; 61, 66; 62, call; 62, 63; 62, 64; 63, identifier:len; 64, argument_list; 64, 65; 65, identifier:parts; 66, integer:3; 67, block; 67, 68; 68, raise_statement; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:InvalidInputError; 71, argument_list; 71, 72; 72, string:"invalid date; use format: DD [MM [YYYY]]"; 73, if_statement; 73, 74; 73, 80; 74, comparison_operator:==; 74, 75; 74, 79; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, identifier:parts; 79, integer:1; 80, block; 80, 81; 80, 103; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:parts; 85, identifier:append; 86, argument_list; 86, 87; 87, conditional_expression:if; 87, 88; 87, 93; 87, 100; 88, binary_operator:-; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:today; 91, identifier:month; 92, integer:1; 93, comparison_operator:>; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:parts; 96, integer:0; 97, attribute; 97, 98; 97, 99; 98, identifier:today; 99, identifier:day; 100, attribute; 100, 101; 100, 102; 101, identifier:today; 102, identifier:month; 103, if_statement; 103, 104; 103, 109; 104, comparison_operator:<; 104, 105; 104, 108; 105, subscript; 105, 106; 105, 107; 106, identifier:parts; 107, integer:1; 108, integer:1; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 115; 112, subscript; 112, 113; 112, 114; 113, identifier:parts; 114, integer:1; 115, integer:12; 116, if_statement; 116, 117; 116, 123; 117, comparison_operator:==; 117, 118; 117, 122; 118, call; 118, 119; 118, 120; 119, identifier:len; 120, argument_list; 120, 121; 121, identifier:parts; 122, integer:2; 123, block; 123, 124; 124, if_statement; 124, 125; 124, 149; 124, 161; 125, boolean_operator:or; 125, 126; 125, 133; 125, 134; 126, comparison_operator:>; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:parts; 129, integer:1; 130, attribute; 130, 131; 130, 132; 131, identifier:today; 132, identifier:month; 133, line_continuation:\; 134, boolean_operator:and; 134, 135; 134, 142; 135, comparison_operator:==; 135, 136; 135, 139; 136, subscript; 136, 137; 136, 138; 137, identifier:parts; 138, integer:1; 139, attribute; 139, 140; 139, 141; 140, identifier:today; 141, identifier:month; 142, comparison_operator:>; 142, 143; 142, 146; 143, subscript; 143, 144; 143, 145; 144, identifier:parts; 145, integer:0; 146, attribute; 146, 147; 146, 148; 147, identifier:today; 148, identifier:day; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:parts; 154, identifier:append; 155, argument_list; 155, 156; 156, binary_operator:-; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:today; 159, identifier:year; 160, integer:1; 161, else_clause; 161, 162; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:parts; 167, identifier:append; 168, argument_list; 168, 169; 169, attribute; 169, 170; 169, 171; 170, identifier:today; 171, identifier:year; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:parts; 176, identifier:reverse; 177, argument_list; 178, try_statement; 178, 179; 178, 202; 179, block; 179, 180; 179, 190; 179, 200; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:date; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:datetime; 186, identifier:date; 187, argument_list; 187, 188; 188, list_splat; 188, 189; 189, identifier:parts; 190, if_statement; 190, 191; 190, 194; 191, comparison_operator:>; 191, 192; 191, 193; 192, identifier:date; 193, identifier:today; 194, block; 194, 195; 195, raise_statement; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:InvalidInputError; 198, argument_list; 198, 199; 199, string:"cannot choose a date in the future"; 200, return_statement; 200, 201; 201, identifier:date; 202, except_clause; 202, 203; 202, 204; 203, identifier:ValueError; 204, block; 204, 205; 204, 207; 205, print_statement; 205, 206; 206, identifier:parts; 207, raise_statement; 207, 208; 208, call; 208, 209; 208, 210; 209, identifier:InvalidInputError; 210, argument_list; 210, 211; 211, string:"invalid date; use format: DD [MM [YYYY]]" | def filter_pastdate(string, default=None):
if not string and default is not None:
return default
today = datetime.date.today()
try:
parts = map(int, re.split('\D+', string))
except ValueError:
raise InvalidInputError("invalid date; use format: DD [MM [YYYY]]")
if len(parts) < 1 or len(parts) > 3:
raise InvalidInputError("invalid date; use format: DD [MM [YYYY]]")
if len(parts) == 1:
parts.append(today.month - 1 if parts[0] > today.day else today.month)
if parts[1] < 1:
parts[1] = 12
if len(parts) == 2:
if parts[1] > today.month \
or parts[1] == today.month and parts[0] > today.day:
parts.append(today.year - 1)
else:
parts.append(today.year)
parts.reverse()
try:
date = datetime.date(*parts)
if date > today:
raise InvalidInputError("cannot choose a date in the future")
return date
except ValueError:
print parts
raise InvalidInputError("invalid date; use format: DD [MM [YYYY]]") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:get_rooms; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:lid; 6, default_parameter; 6, 7; 6, 8; 7, identifier:start; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:end; 11, None; 12, block; 12, 13; 12, 17; 12, 78; 12, 97; 12, 109; 12, 119; 12, 129; 12, 145; 12, 154; 12, 162; 12, 176; 12, 194; 12, 209; 12, 446; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:range_str; 16, string:"availability"; 17, if_statement; 17, 18; 17, 19; 17, 72; 18, identifier:start; 19, block; 19, 20; 19, 52; 19, 58; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:start_datetime; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:datetime; 27, identifier:datetime; 28, identifier:combine; 29, argument_list; 29, 30; 29, 43; 30, call; 30, 31; 30, 42; 31, attribute; 31, 32; 31, 41; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:datetime; 36, identifier:datetime; 37, identifier:strptime; 38, argument_list; 38, 39; 38, 40; 39, identifier:start; 40, string:"%Y-%m-%d"; 41, identifier:date; 42, argument_list; 43, call; 43, 44; 43, 51; 44, attribute; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:datetime; 48, identifier:datetime; 49, identifier:min; 50, identifier:time; 51, argument_list; 52, expression_statement; 52, 53; 53, augmented_assignment:+=; 53, 54; 53, 55; 54, identifier:range_str; 55, binary_operator:+; 55, 56; 55, 57; 56, string:"="; 57, identifier:start; 58, if_statement; 58, 59; 58, 65; 59, boolean_operator:and; 59, 60; 59, 61; 60, identifier:end; 61, not_operator; 61, 62; 62, comparison_operator:==; 62, 63; 62, 64; 63, identifier:start; 64, identifier:end; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, augmented_assignment:+=; 67, 68; 67, 69; 68, identifier:range_str; 69, binary_operator:+; 69, 70; 69, 71; 70, string:","; 71, identifier:end; 72, else_clause; 72, 73; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:start_datetime; 77, None; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:resp; 81, call; 81, 82; 81, 96; 82, attribute; 82, 83; 82, 95; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:_request; 87, argument_list; 87, 88; 87, 89; 88, string:"GET"; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, string:"/1.1/space/categories/{}"; 92, identifier:format; 93, argument_list; 93, 94; 94, identifier:lid; 95, identifier:json; 96, argument_list; 97, if_statement; 97, 98; 97, 101; 98, comparison_operator:in; 98, 99; 98, 100; 99, string:"error"; 100, identifier:resp; 101, block; 101, 102; 102, raise_statement; 102, 103; 103, call; 103, 104; 103, 105; 104, identifier:APIError; 105, argument_list; 105, 106; 106, subscript; 106, 107; 106, 108; 107, identifier:resp; 108, string:"error"; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:output; 112, dictionary; 112, 113; 112, 116; 113, pair; 113, 114; 113, 115; 114, string:"id"; 115, identifier:lid; 116, pair; 116, 117; 116, 118; 117, string:"categories"; 118, list:[]; 119, if_statement; 119, 120; 119, 126; 120, comparison_operator:<; 120, 121; 120, 125; 121, call; 121, 122; 121, 123; 122, identifier:len; 123, argument_list; 123, 124; 124, identifier:resp; 125, integer:1; 126, block; 126, 127; 127, return_statement; 127, 128; 128, identifier:output; 129, if_statement; 129, 130; 129, 135; 130, comparison_operator:in; 130, 131; 130, 132; 131, string:"error"; 132, subscript; 132, 133; 132, 134; 133, identifier:resp; 134, integer:0; 135, block; 135, 136; 136, raise_statement; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:APIError; 139, argument_list; 139, 140; 140, subscript; 140, 141; 140, 144; 141, subscript; 141, 142; 141, 143; 142, identifier:resp; 143, integer:0; 144, string:"error"; 145, if_statement; 145, 146; 145, 151; 146, comparison_operator:not; 146, 147; 146, 148; 147, string:"categories"; 148, subscript; 148, 149; 148, 150; 149, identifier:resp; 150, integer:0; 151, block; 151, 152; 152, return_statement; 152, 153; 153, identifier:output; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:categories; 157, subscript; 157, 158; 157, 161; 158, subscript; 158, 159; 158, 160; 159, identifier:resp; 160, integer:0; 161, string:"categories"; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:id_to_category; 165, dictionary_comprehension; 165, 166; 165, 173; 166, pair; 166, 167; 166, 170; 167, subscript; 167, 168; 167, 169; 168, identifier:i; 169, string:"cid"; 170, subscript; 170, 171; 170, 172; 171, identifier:i; 172, string:"name"; 173, for_in_clause; 173, 174; 173, 175; 174, identifier:i; 175, identifier:categories; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:categories; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, string:","; 182, identifier:join; 183, argument_list; 183, 184; 184, list_comprehension; 184, 185; 184, 191; 185, call; 185, 186; 185, 187; 186, identifier:str; 187, argument_list; 187, 188; 188, subscript; 188, 189; 188, 190; 189, identifier:x; 190, string:"cid"; 191, for_in_clause; 191, 192; 191, 193; 192, identifier:x; 193, identifier:categories; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:resp; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:_request; 201, argument_list; 201, 202; 201, 203; 202, string:"GET"; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, string:"/1.1/space/category/{}"; 206, identifier:format; 207, argument_list; 207, 208; 208, identifier:categories; 209, for_statement; 209, 210; 209, 211; 209, 216; 210, identifier:category; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:resp; 214, identifier:json; 215, argument_list; 216, block; 216, 217; 216, 236; 216, 247; 216, 253; 216, 269; 216, 285; 216, 432; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:cat_out; 220, dictionary; 220, 221; 220, 226; 220, 233; 221, pair; 221, 222; 221, 223; 222, string:"cid"; 223, subscript; 223, 224; 223, 225; 224, identifier:category; 225, string:"cid"; 226, pair; 226, 227; 226, 228; 227, string:"name"; 228, subscript; 228, 229; 228, 230; 229, identifier:id_to_category; 230, subscript; 230, 231; 230, 232; 231, identifier:category; 232, string:"cid"; 233, pair; 233, 234; 233, 235; 234, string:"rooms"; 235, list:[]; 236, if_statement; 236, 237; 236, 245; 237, call; 237, 238; 237, 243; 238, attribute; 238, 239; 238, 242; 239, subscript; 239, 240; 239, 241; 240, identifier:cat_out; 241, string:"name"; 242, identifier:endswith; 243, argument_list; 243, 244; 244, string:"Equipment"; 245, block; 245, 246; 246, continue_statement; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:items; 250, subscript; 250, 251; 250, 252; 251, identifier:category; 252, string:"items"; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:items; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, string:","; 259, identifier:join; 260, argument_list; 260, 261; 261, list_comprehension; 261, 262; 261, 266; 262, call; 262, 263; 262, 264; 263, identifier:str; 264, argument_list; 264, 265; 265, identifier:x; 266, for_in_clause; 266, 267; 266, 268; 267, identifier:x; 268, identifier:items; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:resp; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:self; 275, identifier:_request; 276, argument_list; 276, 277; 276, 278; 277, string:"GET"; 278, call; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, string:"/1.1/space/item/{}?{}"; 281, identifier:format; 282, argument_list; 282, 283; 282, 284; 283, identifier:items; 284, identifier:range_str; 285, for_statement; 285, 286; 285, 287; 285, 292; 286, identifier:room; 287, call; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:resp; 290, identifier:json; 291, argument_list; 292, block; 292, 293; 292, 301; 292, 331; 292, 364; 292, 373; 292, 423; 293, if_statement; 293, 294; 293, 299; 294, comparison_operator:in; 294, 295; 294, 298; 295, subscript; 295, 296; 295, 297; 296, identifier:room; 297, string:"id"; 298, identifier:ROOM_BLACKLIST; 299, block; 299, 300; 300, continue_statement; 301, if_statement; 301, 302; 301, 309; 302, boolean_operator:and; 302, 303; 302, 306; 303, comparison_operator:in; 303, 304; 303, 305; 304, string:"image"; 305, identifier:room; 306, subscript; 306, 307; 306, 308; 307, identifier:room; 308, string:"image"; 309, block; 309, 310; 310, if_statement; 310, 311; 310, 320; 311, not_operator; 311, 312; 312, call; 312, 313; 312, 318; 313, attribute; 313, 314; 313, 317; 314, subscript; 314, 315; 314, 316; 315, identifier:room; 316, string:"image"; 317, identifier:startswith; 318, argument_list; 318, 319; 319, string:"http"; 320, block; 320, 321; 321, expression_statement; 321, 322; 322, assignment; 322, 323; 322, 326; 323, subscript; 323, 324; 323, 325; 324, identifier:room; 325, string:"image"; 326, binary_operator:+; 326, 327; 326, 328; 327, string:"https:"; 328, subscript; 328, 329; 328, 330; 329, identifier:room; 330, string:"image"; 331, if_statement; 331, 332; 331, 335; 332, comparison_operator:in; 332, 333; 332, 334; 333, string:"description"; 334, identifier:room; 335, block; 335, 336; 335, 348; 336, expression_statement; 336, 337; 337, assignment; 337, 338; 337, 339; 338, identifier:description; 339, call; 339, 340; 339, 345; 340, attribute; 340, 341; 340, 344; 341, subscript; 341, 342; 341, 343; 342, identifier:room; 343, string:"description"; 344, identifier:replace; 345, argument_list; 345, 346; 345, 347; 346, string:u'\xa0'; 347, string:u' '; 348, expression_statement; 348, 349; 349, assignment; 349, 350; 349, 353; 350, subscript; 350, 351; 350, 352; 351, identifier:room; 352, string:"description"; 353, call; 353, 354; 353, 363; 354, attribute; 354, 355; 354, 362; 355, attribute; 355, 356; 355, 361; 356, call; 356, 357; 356, 358; 357, identifier:BeautifulSoup; 358, argument_list; 358, 359; 358, 360; 359, identifier:description; 360, string:"html.parser"; 361, identifier:text; 362, identifier:strip; 363, argument_list; 364, if_statement; 364, 365; 364, 368; 365, comparison_operator:in; 365, 366; 365, 367; 366, string:"formid"; 367, identifier:room; 368, block; 368, 369; 369, delete_statement; 369, 370; 370, subscript; 370, 371; 370, 372; 371, identifier:room; 372, string:"formid"; 373, if_statement; 373, 374; 373, 375; 374, identifier:start_datetime; 375, block; 375, 376; 375, 380; 375, 417; 376, expression_statement; 376, 377; 377, assignment; 377, 378; 377, 379; 378, identifier:out_times; 379, list:[]; 380, for_statement; 380, 381; 380, 382; 380, 385; 381, identifier:time; 382, subscript; 382, 383; 382, 384; 383, identifier:room; 384, string:"availability"; 385, block; 385, 386; 385, 405; 386, expression_statement; 386, 387; 387, assignment; 387, 388; 387, 389; 388, identifier:parsed_start; 389, call; 389, 390; 389, 395; 390, attribute; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, identifier:datetime; 393, identifier:datetime; 394, identifier:strptime; 395, argument_list; 395, 396; 395, 404; 396, subscript; 396, 397; 396, 400; 397, subscript; 397, 398; 397, 399; 398, identifier:time; 399, string:"from"; 400, slice; 400, 401; 400, 402; 401, colon; 402, unary_operator:-; 402, 403; 403, integer:6; 404, string:"%Y-%m-%dT%H:%M:%S"; 405, if_statement; 405, 406; 405, 409; 406, comparison_operator:>=; 406, 407; 406, 408; 407, identifier:parsed_start; 408, identifier:start_datetime; 409, block; 409, 410; 410, expression_statement; 410, 411; 411, call; 411, 412; 411, 415; 412, attribute; 412, 413; 412, 414; 413, identifier:out_times; 414, identifier:append; 415, argument_list; 415, 416; 416, identifier:time; 417, expression_statement; 417, 418; 418, assignment; 418, 419; 418, 422; 419, subscript; 419, 420; 419, 421; 420, identifier:room; 421, string:"availability"; 422, identifier:out_times; 423, expression_statement; 423, 424; 424, call; 424, 425; 424, 430; 425, attribute; 425, 426; 425, 429; 426, subscript; 426, 427; 426, 428; 427, identifier:cat_out; 428, string:"rooms"; 429, identifier:append; 430, argument_list; 430, 431; 431, identifier:room; 432, if_statement; 432, 433; 432, 436; 433, subscript; 433, 434; 433, 435; 434, identifier:cat_out; 435, string:"rooms"; 436, block; 436, 437; 437, expression_statement; 437, 438; 438, call; 438, 439; 438, 444; 439, attribute; 439, 440; 439, 443; 440, subscript; 440, 441; 440, 442; 441, identifier:output; 442, string:"categories"; 443, identifier:append; 444, argument_list; 444, 445; 445, identifier:cat_out; 446, return_statement; 446, 447; 447, identifier:output | def get_rooms(self, lid, start=None, end=None):
range_str = "availability"
if start:
start_datetime = datetime.datetime.combine(datetime.datetime.strptime(start, "%Y-%m-%d").date(), datetime.datetime.min.time())
range_str += "=" + start
if end and not start == end:
range_str += "," + end
else:
start_datetime = None
resp = self._request("GET", "/1.1/space/categories/{}".format(lid)).json()
if "error" in resp:
raise APIError(resp["error"])
output = {"id": lid, "categories": []}
if len(resp) < 1:
return output
if "error" in resp[0]:
raise APIError(resp[0]["error"])
if "categories" not in resp[0]:
return output
categories = resp[0]["categories"]
id_to_category = {i["cid"]: i["name"] for i in categories}
categories = ",".join([str(x["cid"]) for x in categories])
resp = self._request("GET", "/1.1/space/category/{}".format(categories))
for category in resp.json():
cat_out = {"cid": category["cid"], "name": id_to_category[category["cid"]], "rooms": []}
if cat_out["name"].endswith("Equipment"):
continue
items = category["items"]
items = ",".join([str(x) for x in items])
resp = self._request("GET", "/1.1/space/item/{}?{}".format(items, range_str))
for room in resp.json():
if room["id"] in ROOM_BLACKLIST:
continue
if "image" in room and room["image"]:
if not room["image"].startswith("http"):
room["image"] = "https:" + room["image"]
if "description" in room:
description = room["description"].replace(u'\xa0', u' ')
room["description"] = BeautifulSoup(description, "html.parser").text.strip()
if "formid" in room:
del room["formid"]
if start_datetime:
out_times = []
for time in room["availability"]:
parsed_start = datetime.datetime.strptime(time["from"][:-6], "%Y-%m-%dT%H:%M:%S")
if parsed_start >= start_datetime:
out_times.append(time)
room["availability"] = out_times
cat_out["rooms"].append(room)
if cat_out["rooms"]:
output["categories"].append(cat_out)
return output |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 28; 2, function_name:reconstruct_ancestral_states; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 4, identifier:tree; 5, identifier:character; 6, identifier:states; 7, default_parameter; 7, 8; 7, 9; 8, identifier:prediction_method; 9, identifier:MPPA; 10, default_parameter; 10, 11; 10, 12; 11, identifier:model; 12, identifier:F81; 13, default_parameter; 13, 14; 13, 15; 14, identifier:params; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:avg_br_len; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:num_nodes; 21, None; 22, default_parameter; 22, 23; 22, 24; 23, identifier:num_tips; 24, None; 25, default_parameter; 25, 26; 25, 27; 26, identifier:force_joint; 27, True; 28, block; 28, 29; 28, 61; 28, 77; 28, 95; 28, 106; 28, 205; 28, 221; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 39; 31, attribute; 31, 32; 31, 38; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:logging; 35, identifier:getLogger; 36, argument_list; 36, 37; 37, string:'pastml'; 38, identifier:debug; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, string:'ACR settings for {}:\n\tMethod:\t{}{}.'; 43, identifier:format; 44, argument_list; 44, 45; 44, 46; 44, 47; 45, identifier:character; 46, identifier:prediction_method; 47, conditional_expression:if; 47, 48; 47, 54; 47, 60; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, string:'\n\tModel:\t{}'; 51, identifier:format; 52, argument_list; 52, 53; 53, identifier:model; 54, boolean_operator:and; 54, 55; 54, 56; 55, identifier:model; 56, call; 56, 57; 56, 58; 57, identifier:is_ml; 58, argument_list; 58, 59; 59, identifier:prediction_method; 60, string:''; 61, if_statement; 61, 62; 61, 65; 62, comparison_operator:==; 62, 63; 62, 64; 63, identifier:COPY; 64, identifier:prediction_method; 65, block; 65, 66; 66, return_statement; 66, 67; 67, dictionary; 67, 68; 67, 71; 67, 74; 68, pair; 68, 69; 68, 70; 69, identifier:CHARACTER; 70, identifier:character; 71, pair; 71, 72; 71, 73; 72, identifier:STATES; 73, identifier:states; 74, pair; 74, 75; 74, 76; 75, identifier:METHOD; 76, identifier:prediction_method; 77, if_statement; 77, 78; 77, 80; 78, not_operator; 78, 79; 79, identifier:num_nodes; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:num_nodes; 84, call; 84, 85; 84, 86; 85, identifier:sum; 86, generator_expression; 86, 87; 86, 88; 87, integer:1; 88, for_in_clause; 88, 89; 88, 90; 89, identifier:_; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:tree; 93, identifier:traverse; 94, argument_list; 95, if_statement; 95, 96; 95, 98; 96, not_operator; 96, 97; 97, identifier:num_tips; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:num_tips; 102, call; 102, 103; 102, 104; 103, identifier:len; 104, argument_list; 104, 105; 105, identifier:tree; 106, if_statement; 106, 107; 106, 111; 107, call; 107, 108; 107, 109; 108, identifier:is_ml; 109, argument_list; 109, 110; 110, identifier:prediction_method; 111, block; 111, 112; 111, 139; 111, 149; 111, 165; 112, if_statement; 112, 113; 112, 116; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:avg_br_len; 115, None; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:avg_br_len; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:np; 123, identifier:mean; 124, generator_expression; 124, 125; 124, 128; 124, 135; 125, attribute; 125, 126; 125, 127; 126, identifier:n; 127, identifier:dist; 128, for_in_clause; 128, 129; 128, 130; 129, identifier:n; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:tree; 133, identifier:traverse; 134, argument_list; 135, if_clause; 135, 136; 136, attribute; 136, 137; 136, 138; 137, identifier:n; 138, identifier:dist; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 145; 141, pattern_list; 141, 142; 141, 143; 141, 144; 142, identifier:freqs; 143, identifier:sf; 144, identifier:kappa; 145, expression_list; 145, 146; 145, 147; 145, 148; 146, None; 147, None; 148, None; 149, if_statement; 149, 150; 149, 153; 150, comparison_operator:is; 150, 151; 150, 152; 151, identifier:params; 152, None; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 160; 156, pattern_list; 156, 157; 156, 158; 156, 159; 157, identifier:freqs; 158, identifier:sf; 159, identifier:kappa; 160, call; 160, 161; 160, 162; 161, identifier:_parse_pastml_parameters; 162, argument_list; 162, 163; 162, 164; 163, identifier:params; 164, identifier:states; 165, return_statement; 165, 166; 166, call; 166, 167; 166, 168; 167, identifier:ml_acr; 168, argument_list; 168, 169; 168, 172; 168, 175; 168, 178; 168, 181; 168, 184; 168, 187; 168, 190; 168, 193; 168, 196; 168, 199; 168, 202; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:tree; 171, identifier:tree; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:character; 174, identifier:character; 175, keyword_argument; 175, 176; 175, 177; 176, identifier:prediction_method; 177, identifier:prediction_method; 178, keyword_argument; 178, 179; 178, 180; 179, identifier:model; 180, identifier:model; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:states; 183, identifier:states; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:avg_br_len; 186, identifier:avg_br_len; 187, keyword_argument; 187, 188; 187, 189; 188, identifier:num_nodes; 189, identifier:num_nodes; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:num_tips; 192, identifier:num_tips; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:freqs; 195, identifier:freqs; 196, keyword_argument; 196, 197; 196, 198; 197, identifier:sf; 198, identifier:sf; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:kappa; 201, identifier:kappa; 202, keyword_argument; 202, 203; 202, 204; 203, identifier:force_joint; 204, identifier:force_joint; 205, if_statement; 205, 206; 205, 210; 206, call; 206, 207; 206, 208; 207, identifier:is_parsimonious; 208, argument_list; 208, 209; 209, identifier:prediction_method; 210, block; 210, 211; 211, return_statement; 211, 212; 212, call; 212, 213; 212, 214; 213, identifier:parsimonious_acr; 214, argument_list; 214, 215; 214, 216; 214, 217; 214, 218; 214, 219; 214, 220; 215, identifier:tree; 216, identifier:character; 217, identifier:prediction_method; 218, identifier:states; 219, identifier:num_nodes; 220, identifier:num_tips; 221, raise_statement; 221, 222; 222, call; 222, 223; 222, 224; 223, identifier:ValueError; 224, argument_list; 224, 225; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, string:'Method {} is unknown, should be one of ML ({}), one of MP ({}) or {}'; 228, identifier:format; 229, argument_list; 229, 230; 229, 231; 229, 237; 229, 243; 230, identifier:prediction_method; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, string:', '; 234, identifier:join; 235, argument_list; 235, 236; 236, identifier:ML_METHODS; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, string:', '; 240, identifier:join; 241, argument_list; 241, 242; 242, identifier:MP_METHODS; 243, identifier:COPY | def reconstruct_ancestral_states(tree, character, states, prediction_method=MPPA, model=F81,
params=None, avg_br_len=None, num_nodes=None, num_tips=None,
force_joint=True):
logging.getLogger('pastml').debug('ACR settings for {}:\n\tMethod:\t{}{}.'
.format(character, prediction_method,
'\n\tModel:\t{}'.format(model)
if model and is_ml(prediction_method) else ''))
if COPY == prediction_method:
return {CHARACTER: character, STATES: states, METHOD: prediction_method}
if not num_nodes:
num_nodes = sum(1 for _ in tree.traverse())
if not num_tips:
num_tips = len(tree)
if is_ml(prediction_method):
if avg_br_len is None:
avg_br_len = np.mean(n.dist for n in tree.traverse() if n.dist)
freqs, sf, kappa = None, None, None
if params is not None:
freqs, sf, kappa = _parse_pastml_parameters(params, states)
return ml_acr(tree=tree, character=character, prediction_method=prediction_method, model=model, states=states,
avg_br_len=avg_br_len, num_nodes=num_nodes, num_tips=num_tips, freqs=freqs, sf=sf, kappa=kappa,
force_joint=force_joint)
if is_parsimonious(prediction_method):
return parsimonious_acr(tree, character, prediction_method, states, num_nodes, num_tips)
raise ValueError('Method {} is unknown, should be one of ML ({}), one of MP ({}) or {}'
.format(prediction_method, ', '.join(ML_METHODS), ', '.join(MP_METHODS), COPY)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:acr; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:tree; 5, identifier:df; 6, default_parameter; 6, 7; 6, 8; 7, identifier:prediction_method; 8, identifier:MPPA; 9, default_parameter; 9, 10; 9, 11; 10, identifier:model; 11, identifier:F81; 12, default_parameter; 12, 13; 12, 14; 13, identifier:column2parameters; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:force_joint; 17, True; 18, block; 18, 19; 18, 59; 18, 67; 18, 72; 18, 82; 18, 92; 18, 104; 18, 111; 18, 134; 18, 146; 18, 158; 18, 286; 18, 341; 18, 345; 18, 372; 19, for_statement; 19, 20; 19, 21; 19, 24; 20, identifier:c; 21, attribute; 21, 22; 21, 23; 22, identifier:df; 23, identifier:columns; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, subscript; 27, 28; 27, 29; 28, identifier:df; 29, identifier:c; 30, call; 30, 31; 30, 36; 31, attribute; 31, 32; 31, 35; 32, subscript; 32, 33; 32, 34; 33, identifier:df; 34, identifier:c; 35, identifier:apply; 36, argument_list; 36, 37; 37, lambda; 37, 38; 37, 40; 38, lambda_parameters; 38, 39; 39, identifier:_; 40, conditional_expression:if; 40, 41; 40, 42; 40, 48; 41, string:''; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:pd; 45, identifier:isna; 46, argument_list; 46, 47; 47, identifier:_; 48, call; 48, 49; 48, 58; 49, attribute; 49, 50; 49, 57; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:_; 53, identifier:encode; 54, argument_list; 54, 55; 54, 56; 55, string:'ASCII'; 56, string:'replace'; 57, identifier:decode; 58, argument_list; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:columns; 62, call; 62, 63; 62, 64; 63, identifier:preannotate_tree; 64, argument_list; 64, 65; 64, 66; 65, identifier:df; 66, identifier:tree; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:name_tree; 70, argument_list; 70, 71; 71, identifier:tree; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:collapse_zero_branches; 75, argument_list; 75, 76; 75, 77; 76, identifier:tree; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:features_to_be_merged; 79, attribute; 79, 80; 79, 81; 80, identifier:df; 81, identifier:columns; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 88; 84, pattern_list; 84, 85; 84, 86; 84, 87; 85, identifier:avg_br_len; 86, identifier:num_nodes; 87, identifier:num_tips; 88, call; 88, 89; 88, 90; 89, identifier:get_tree_stats; 90, argument_list; 90, 91; 91, identifier:tree; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 102; 94, attribute; 94, 95; 94, 101; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:logging; 98, identifier:getLogger; 99, argument_list; 99, 100; 100, string:'pastml'; 101, identifier:debug; 102, argument_list; 102, 103; 103, string:'\n=============ACR==============================='; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:column2parameters; 107, conditional_expression:if; 107, 108; 107, 109; 107, 110; 108, identifier:column2parameters; 109, identifier:column2parameters; 110, dictionary; 111, function_definition; 111, 112; 111, 113; 111, 115; 112, function_name:_work; 113, parameters; 113, 114; 114, identifier:args; 115, block; 115, 116; 116, return_statement; 116, 117; 117, call; 117, 118; 117, 119; 118, identifier:reconstruct_ancestral_states; 119, argument_list; 119, 120; 119, 122; 119, 125; 119, 128; 119, 131; 120, list_splat; 120, 121; 121, identifier:args; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:avg_br_len; 124, identifier:avg_br_len; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:num_nodes; 127, identifier:num_nodes; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:num_tips; 130, identifier:num_tips; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:force_joint; 133, identifier:force_joint; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:prediction_methods; 137, call; 137, 138; 137, 139; 138, identifier:value2list; 139, argument_list; 139, 140; 139, 144; 139, 145; 140, call; 140, 141; 140, 142; 141, identifier:len; 142, argument_list; 142, 143; 143, identifier:columns; 144, identifier:prediction_method; 145, identifier:MPPA; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:models; 149, call; 149, 150; 149, 151; 150, identifier:value2list; 151, argument_list; 151, 152; 151, 156; 151, 157; 152, call; 152, 153; 152, 154; 153, identifier:len; 154, argument_list; 154, 155; 155, identifier:columns; 156, identifier:model; 157, identifier:F81; 158, function_definition; 158, 159; 158, 160; 158, 164; 159, function_name:get_states; 160, parameters; 160, 161; 160, 162; 160, 163; 161, identifier:method; 162, identifier:model; 163, identifier:column; 164, block; 164, 165; 164, 190; 164, 210; 164, 219; 164, 256; 164, 263; 164, 284; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:df_states; 168, list_comprehension; 168, 169; 168, 170; 168, 179; 169, identifier:_; 170, for_in_clause; 170, 171; 170, 172; 171, identifier:_; 172, call; 172, 173; 172, 178; 173, attribute; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:df; 176, identifier:column; 177, identifier:unique; 178, argument_list; 179, if_clause; 179, 180; 180, boolean_operator:and; 180, 181; 180, 187; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:pd; 184, identifier:notnull; 185, argument_list; 185, 186; 186, identifier:_; 187, comparison_operator:!=; 187, 188; 187, 189; 188, identifier:_; 189, string:''; 190, if_statement; 190, 191; 190, 202; 191, boolean_operator:or; 191, 192; 191, 197; 192, not_operator; 192, 193; 193, call; 193, 194; 193, 195; 194, identifier:is_ml; 195, argument_list; 195, 196; 196, identifier:method; 197, comparison_operator:not; 197, 198; 197, 199; 198, identifier:model; 199, set; 199, 200; 199, 201; 200, identifier:HKY; 201, identifier:JTT; 202, block; 202, 203; 203, return_statement; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:np; 207, identifier:sort; 208, argument_list; 208, 209; 209, identifier:df_states; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 213; 212, identifier:states; 213, conditional_expression:if; 213, 214; 213, 215; 213, 218; 214, identifier:HKY_STATES; 215, comparison_operator:==; 215, 216; 215, 217; 216, identifier:HKY; 217, identifier:model; 218, identifier:JTT_STATES; 219, if_statement; 219, 220; 219, 230; 220, not_operator; 220, 221; 221, binary_operator:&; 221, 222; 221, 226; 222, call; 222, 223; 222, 224; 223, identifier:set; 224, argument_list; 224, 225; 225, identifier:df_states; 226, call; 226, 227; 226, 228; 227, identifier:set; 228, argument_list; 228, 229; 229, identifier:states; 230, block; 230, 231; 231, raise_statement; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:ValueError; 234, argument_list; 234, 235; 235, call; 235, 236; 235, 241; 236, attribute; 236, 237; 236, 240; 237, concatenated_string; 237, 238; 237, 239; 238, string:'The allowed states for model {} are {}, '; 239, string:'but your annotation file specifies {} as states in column {}.'; 240, identifier:format; 241, argument_list; 241, 242; 241, 243; 241, 249; 241, 255; 242, identifier:model; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, string:', '; 246, identifier:join; 247, argument_list; 247, 248; 248, identifier:states; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, string:', '; 252, identifier:join; 253, argument_list; 253, 254; 254, identifier:df_states; 255, identifier:column; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 258, identifier:state_set; 259, call; 259, 260; 259, 261; 260, identifier:set; 261, argument_list; 261, 262; 262, identifier:states; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 268; 265, subscript; 265, 266; 265, 267; 266, identifier:df; 267, identifier:column; 268, call; 268, 269; 268, 274; 269, attribute; 269, 270; 269, 273; 270, subscript; 270, 271; 270, 272; 271, identifier:df; 272, identifier:column; 273, identifier:apply; 274, argument_list; 274, 275; 275, lambda; 275, 276; 275, 278; 276, lambda_parameters; 276, 277; 277, identifier:_; 278, conditional_expression:if; 278, 279; 278, 280; 278, 283; 279, identifier:_; 280, comparison_operator:in; 280, 281; 280, 282; 281, identifier:_; 282, identifier:state_set; 283, string:''; 284, return_statement; 284, 285; 285, identifier:states; 286, with_statement; 286, 287; 286, 295; 287, with_clause; 287, 288; 288, with_item; 288, 289; 289, as_pattern; 289, 290; 289, 293; 290, call; 290, 291; 290, 292; 291, identifier:ThreadPool; 292, argument_list; 293, as_pattern_target; 293, 294; 294, identifier:pool; 295, block; 295, 296; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 299; 297, 300; 298, identifier:acr_results; 299, line_continuation:\; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:pool; 303, identifier:map; 304, argument_list; 304, 305; 304, 308; 305, keyword_argument; 305, 306; 305, 307; 306, identifier:func; 307, identifier:_work; 308, keyword_argument; 308, 309; 308, 310; 309, identifier:iterable; 310, generator_expression; 310, 311; 310, 330; 311, tuple; 311, 312; 311, 313; 311, 314; 311, 320; 311, 321; 311, 322; 312, identifier:tree; 313, identifier:column; 314, call; 314, 315; 314, 316; 315, identifier:get_states; 316, argument_list; 316, 317; 316, 318; 316, 319; 317, identifier:method; 318, identifier:model; 319, identifier:column; 320, identifier:method; 321, identifier:model; 322, conditional_expression:if; 322, 323; 322, 326; 322, 329; 323, subscript; 323, 324; 323, 325; 324, identifier:column2parameters; 325, identifier:column; 326, comparison_operator:in; 326, 327; 326, 328; 327, identifier:column; 328, identifier:column2parameters; 329, None; 330, for_in_clause; 330, 331; 330, 335; 331, tuple_pattern; 331, 332; 331, 333; 331, 334; 332, identifier:column; 333, identifier:method; 334, identifier:model; 335, call; 335, 336; 335, 337; 336, identifier:zip; 337, argument_list; 337, 338; 337, 339; 337, 340; 338, identifier:columns; 339, identifier:prediction_methods; 340, identifier:models; 341, expression_statement; 341, 342; 342, assignment; 342, 343; 342, 344; 343, identifier:result; 344, list:[]; 345, for_statement; 345, 346; 345, 347; 345, 348; 346, identifier:acr_res; 347, identifier:acr_results; 348, block; 348, 349; 349, if_statement; 349, 350; 349, 355; 349, 363; 350, call; 350, 351; 350, 352; 351, identifier:isinstance; 352, argument_list; 352, 353; 352, 354; 353, identifier:acr_res; 354, identifier:list; 355, block; 355, 356; 356, expression_statement; 356, 357; 357, call; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, identifier:result; 360, identifier:extend; 361, argument_list; 361, 362; 362, identifier:acr_res; 363, else_clause; 363, 364; 364, block; 364, 365; 365, expression_statement; 365, 366; 366, call; 366, 367; 366, 370; 367, attribute; 367, 368; 367, 369; 368, identifier:result; 369, identifier:append; 370, argument_list; 370, 371; 371, identifier:acr_res; 372, return_statement; 372, 373; 373, identifier:result | def acr(tree, df, prediction_method=MPPA, model=F81, column2parameters=None, force_joint=True):
for c in df.columns:
df[c] = df[c].apply(lambda _: '' if pd.isna(_) else _.encode('ASCII', 'replace').decode())
columns = preannotate_tree(df, tree)
name_tree(tree)
collapse_zero_branches(tree, features_to_be_merged=df.columns)
avg_br_len, num_nodes, num_tips = get_tree_stats(tree)
logging.getLogger('pastml').debug('\n=============ACR===============================')
column2parameters = column2parameters if column2parameters else {}
def _work(args):
return reconstruct_ancestral_states(*args, avg_br_len=avg_br_len, num_nodes=num_nodes, num_tips=num_tips,
force_joint=force_joint)
prediction_methods = value2list(len(columns), prediction_method, MPPA)
models = value2list(len(columns), model, F81)
def get_states(method, model, column):
df_states = [_ for _ in df[column].unique() if pd.notnull(_) and _ != '']
if not is_ml(method) or model not in {HKY, JTT}:
return np.sort(df_states)
states = HKY_STATES if HKY == model else JTT_STATES
if not set(df_states) & set(states):
raise ValueError('The allowed states for model {} are {}, '
'but your annotation file specifies {} as states in column {}.'
.format(model, ', '.join(states), ', '.join(df_states), column))
state_set = set(states)
df[column] = df[column].apply(lambda _: _ if _ in state_set else '')
return states
with ThreadPool() as pool:
acr_results = \
pool.map(func=_work, iterable=((tree, column, get_states(method, model, column), method, model,
column2parameters[column] if column in column2parameters else None)
for (column, method, model) in zip(columns, prediction_methods, models)))
result = []
for acr_res in acr_results:
if isinstance(acr_res, list):
result.extend(acr_res)
else:
result.append(acr_res)
return result |
0, module; 0, 1; 0, 169; 0, 176; 0, 207; 0, 219; 1, function_definition; 1, 2; 1, 3; 1, 7; 1, 159; 2, function_name:export_bert; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:data; 5, identifier:electrodes; 6, identifier:filename; 7, ERROR; 7, 8; 7, 41; 7, 49; 7, 61; 7, 64; 7, 65; 8, if_statement; 8, 9; 8, 13; 9, call; 9, 10; 9, 11; 10, identifier:has_multiple_timesteps; 11, argument_list; 11, 12; 12, identifier:data; 13, block; 13, 14; 14, for_statement; 14, 15; 14, 18; 14, 25; 15, pattern_list; 15, 16; 15, 17; 16, identifier:i; 17, identifier:timestep; 18, call; 18, 19; 18, 20; 19, identifier:enumerate; 20, argument_list; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:split_timesteps; 23, argument_list; 23, 24; 24, identifier:data; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:export_bert; 29, argument_list; 29, 30; 29, 31; 29, 32; 30, identifier:timestep; 31, identifier:electrodes; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:filename; 35, identifier:replace; 36, argument_list; 36, 37; 36, 38; 37, string:"."; 38, binary_operator:%; 38, 39; 38, 40; 39, string:"_%.3d."; 40, identifier:i; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:f; 44, call; 44, 45; 44, 46; 45, identifier:open; 46, argument_list; 46, 47; 46, 48; 47, identifier:filename; 48, string:'w'; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:f; 53, identifier:write; 54, argument_list; 54, 55; 55, binary_operator:%; 55, 56; 55, 57; 56, string:"%d\n"; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, identifier:electrodes; 61, attribute; 61, 62; 61, 63; 62, identifier:f; 63, identifier:write; 64, ERROR; 65, keyword_argument; 65, 66; 65, 67; 65, 152; 66, identifier:electrodes; 67, ERROR; 67, 68; 67, 84; 67, 93; 67, 96; 67, 117; 67, 134; 67, 151; 68, attribute; 68, 69; 68, 81; 68, 83; 69, call; 69, 70; 69, 80; 70, attribute; 70, 71; 70, 76; 70, 79; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:electrodes; 74, identifier:copy; 75, argument_list; 76, ERROR; 76, 77; 76, 78; 77, identifier:data; 78, identifier:data; 79, identifier:copy; 80, argument_list; 81, ERROR; 81, 82; 82, identifier:electrodes; 83, identifier:columns; 84, call; 84, 85; 84, 92; 85, attribute; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:electrodes; 89, identifier:columns; 90, identifier:str; 91, identifier:lower; 92, argument_list; 93, attribute; 93, 94; 93, 95; 94, identifier:data; 95, identifier:columns; 96, subscript; 96, 97; 96, 106; 96, 108; 96, 109; 96, 110; 96, 111; 96, 112; 96, 113; 96, 114; 96, 115; 96, 116; 97, call; 97, 98; 97, 105; 98, attribute; 98, 99; 98, 104; 99, attribute; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:data; 102, identifier:columns; 103, identifier:str; 104, identifier:lower; 105, argument_list; 106, ERROR; 106, 107; 107, identifier:cols_to_export; 108, string:"a"; 109, string:"b"; 110, string:"m"; 111, string:"n"; 112, string:"u"; 113, string:"i"; 114, string:"r"; 115, string:"rho_a"; 116, string:"error"; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:data; 120, identifier:drop; 121, argument_list; 121, 122; 121, 130; 121, 131; 122, call; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:data; 126, identifier:columns; 127, identifier:difference; 128, argument_list; 128, 129; 129, identifier:cols_to_export; 130, integer:1; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:inplace; 133, True; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:data; 137, identifier:rename; 138, argument_list; 138, 139; 138, 148; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:columns; 141, dictionary; 141, 142; 141, 145; 142, pair; 142, 143; 142, 144; 143, string:"rho_a"; 144, string:"rhoa"; 145, pair; 145, 146; 145, 147; 146, string:"error"; 147, string:"err"; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:inplace; 150, True; 151, identifier:for; 152, comparison_operator:in; 152, 153; 152, 154; 153, identifier:key; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:electrodes; 157, identifier:keys; 158, argument_list; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:f; 164, identifier:write; 165, argument_list; 165, 166; 166, binary_operator:%; 166, 167; 166, 168; 167, string:"%s "; 168, identifier:key; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:f; 173, identifier:write; 174, argument_list; 174, 175; 175, string:"\n"; 176, for_statement; 176, 177; 176, 178; 176, 186; 177, identifier:row; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:electrodes; 181, identifier:itertuples; 182, argument_list; 182, 183; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:index; 185, False; 186, block; 186, 187; 186, 200; 187, for_statement; 187, 188; 187, 189; 187, 190; 188, identifier:val; 189, identifier:row; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:f; 195, identifier:write; 196, argument_list; 196, 197; 197, binary_operator:%; 197, 198; 197, 199; 198, string:"%5.3f "; 199, identifier:val; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:f; 204, identifier:write; 205, argument_list; 205, 206; 206, string:"\n"; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:f; 211, identifier:write; 212, argument_list; 212, 213; 213, binary_operator:%; 213, 214; 213, 215; 214, string:"%d\n"; 215, call; 215, 216; 215, 217; 216, identifier:len; 217, argument_list; 217, 218; 218, identifier:data; 219, ERROR; 219, 220; 219, 223; 219, 224; 219, 293; 219, 299; 219, 300; 219, 326; 220, attribute; 220, 221; 220, 222; 221, identifier:f; 222, identifier:write; 223, ERROR; 224, keyword_argument; 224, 225; 224, 226; 224, 292; 225, identifier:columns; 226, ERROR; 226, 227; 226, 239; 226, 245; 226, 246; 226, 266; 226, 281; 226, 282; 227, comparison_operator:in; 227, 228; 227, 235; 227, 238; 228, call; 228, 229; 228, 234; 229, attribute; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:data; 232, identifier:columns; 233, identifier:tolist; 234, argument_list; 235, ERROR; 235, 236; 235, 237; 236, identifier:for; 237, identifier:c; 238, string:"abmn"; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:columns; 242, identifier:remove; 243, argument_list; 243, 244; 244, identifier:c; 245, identifier:columns; 246, comparison_operator:in; 246, 247; 246, 258; 246, 261; 247, binary_operator:+; 247, 248; 247, 252; 248, call; 248, 249; 248, 250; 249, identifier:list; 250, argument_list; 250, 251; 251, string:"abmn"; 252, subscript; 252, 253; 252, 254; 252, 257; 253, identifier:columns; 254, ERROR; 254, 255; 254, 256; 255, identifier:data; 256, identifier:data; 257, identifier:columns; 258, ERROR; 258, 259; 258, 260; 259, identifier:for; 260, identifier:key; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:data; 264, identifier:keys; 265, argument_list; 266, call; 266, 267; 266, 279; 267, attribute; 267, 268; 267, 276; 267, 278; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:f; 271, identifier:write; 272, argument_list; 272, 273; 273, binary_operator:%; 273, 274; 273, 275; 274, string:"%s "; 275, identifier:key; 276, ERROR; 276, 277; 277, identifier:f; 278, identifier:write; 279, argument_list; 279, 280; 280, string:"\n"; 281, identifier:for; 282, comparison_operator:in; 282, 283; 282, 284; 283, identifier:row; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:data; 287, identifier:itertuples; 288, argument_list; 288, 289; 289, keyword_argument; 289, 290; 289, 291; 290, identifier:index; 291, False; 292, identifier:i; 293, comparison_operator:in; 293, 294; 293, 295; 294, identifier:val; 295, call; 295, 296; 295, 297; 296, identifier:enumerate; 297, argument_list; 297, 298; 298, identifier:row; 299, ERROR; 300, ERROR; 300, 301; 300, 304; 300, 312; 300, 320; 301, comparison_operator:<; 301, 302; 301, 303; 302, identifier:i; 303, integer:4; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:f; 307, identifier:write; 308, argument_list; 308, 309; 309, binary_operator:%; 309, 310; 309, 311; 310, string:"%d "; 311, identifier:val; 312, call; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:f; 315, identifier:write; 316, argument_list; 316, 317; 317, binary_operator:%; 317, 318; 317, 319; 318, string:"%E "; 319, identifier:val; 320, call; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:f; 323, identifier:write; 324, argument_list; 324, 325; 325, string:"\n"; 326, call; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, identifier:f; 329, identifier:close; 330, argument_list | def export_bert(data, electrodes, filename):
if has_multiple_timesteps(data):
for i, timestep in enumerate(split_timesteps(data)):
export_bert(timestep, electrodes,
filename.replace(".", "_%.3d." % i))
f = open(filename, 'w')
f.write("%d\n" % len(electrodes))
f.write("
electrodes = electrodes.copy()
data = data.copy()
electrodes.columns = electrodes.columns.str.lower()
data.columns = data.columns.str.lower()
cols_to_export = ["a", "b", "m", "n", "u", "i", "r", "rho_a", "error"]
data.drop(data.columns.difference(cols_to_export), 1, inplace=True)
data.rename(columns={"rho_a": "rhoa", "error": "err"}, inplace=True)
for key in electrodes.keys():
f.write("%s " % key)
f.write("\n")
for row in electrodes.itertuples(index=False):
for val in row:
f.write("%5.3f " % val)
f.write("\n")
f.write("%d\n" % len(data))
f.write("
columns = data.columns.tolist()
for c in "abmn":
columns.remove(c)
columns = list("abmn") + columns
data = data[columns]
for key in data.keys():
f.write("%s " % key)
f.write("\n")
for row in data.itertuples(index=False):
for i, val in enumerate(row):
if i < 4:
f.write("%d " % val)
else:
f.write("%E " % val)
f.write("\n")
f.close() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_sort_dd_skips; 3, parameters; 3, 4; 3, 5; 4, identifier:configs; 5, identifier:dd_indices_all; 6, block; 6, 7; 6, 26; 6, 44; 6, 53; 6, 70; 6, 74; 6, 101; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:config_current_skips; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:np; 13, identifier:abs; 14, argument_list; 14, 15; 15, binary_operator:-; 15, 16; 15, 21; 16, subscript; 16, 17; 16, 18; 16, 20; 17, identifier:configs; 18, slice; 18, 19; 19, colon; 20, integer:1; 21, subscript; 21, 22; 21, 23; 21, 25; 22, identifier:configs; 23, slice; 23, 24; 24, colon; 25, integer:0; 26, if_statement; 26, 27; 26, 38; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:np; 30, identifier:all; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:np; 35, identifier:isnan; 36, argument_list; 36, 37; 37, identifier:config_current_skips; 38, block; 38, 39; 39, return_statement; 39, 40; 40, dictionary; 40, 41; 41, pair; 41, 42; 41, 43; 42, integer:0; 43, list:[]; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:available_skips_raw; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:np; 50, identifier:unique; 51, argument_list; 51, 52; 52, identifier:config_current_skips; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:available_skips; 56, call; 56, 57; 56, 68; 57, attribute; 57, 58; 57, 67; 58, subscript; 58, 59; 58, 60; 59, identifier:available_skips_raw; 60, unary_operator:~; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:np; 64, identifier:isnan; 65, argument_list; 65, 66; 66, identifier:available_skips_raw; 67, identifier:astype; 68, argument_list; 68, 69; 69, identifier:int; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:dd_configs_sorted; 73, dictionary; 74, for_statement; 74, 75; 74, 76; 74, 77; 75, identifier:skip; 76, identifier:available_skips; 77, block; 77, 78; 77, 91; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:indices; 81, subscript; 81, 82; 81, 90; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:np; 85, identifier:where; 86, argument_list; 86, 87; 87, comparison_operator:==; 87, 88; 87, 89; 88, identifier:config_current_skips; 89, identifier:skip; 90, integer:0; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 98; 93, subscript; 93, 94; 93, 95; 94, identifier:dd_configs_sorted; 95, binary_operator:-; 95, 96; 95, 97; 96, identifier:skip; 97, integer:1; 98, subscript; 98, 99; 98, 100; 99, identifier:dd_indices_all; 100, identifier:indices; 101, return_statement; 101, 102; 102, identifier:dd_configs_sorted | def _sort_dd_skips(configs, dd_indices_all):
config_current_skips = np.abs(configs[:, 1] - configs[:, 0])
if np.all(np.isnan(config_current_skips)):
return {0: []}
available_skips_raw = np.unique(config_current_skips)
available_skips = available_skips_raw[
~np.isnan(available_skips_raw)
].astype(int)
dd_configs_sorted = {}
for skip in available_skips:
indices = np.where(config_current_skips == skip)[0]
dd_configs_sorted[skip - 1] = dd_indices_all[indices]
return dd_configs_sorted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:get_label; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:parameter; 5, identifier:ptype; 6, default_parameter; 6, 7; 6, 8; 7, identifier:flavor; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:mpl; 11, None; 12, block; 12, 13; 12, 68; 12, 78; 12, 90; 12, 104; 13, if_statement; 13, 14; 13, 17; 13, 35; 14, comparison_operator:is; 14, 15; 14, 16; 15, identifier:flavor; 16, None; 17, block; 17, 18; 18, if_statement; 18, 19; 18, 24; 19, comparison_operator:not; 19, 20; 19, 21; 20, identifier:flavor; 21, tuple; 21, 22; 21, 23; 22, string:'latex'; 23, string:'mathml'; 24, block; 24, 25; 25, raise_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:Exception; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, string:'flavor not recognized: {}'; 32, identifier:format; 33, argument_list; 33, 34; 34, identifier:flavor; 35, else_clause; 35, 36; 36, block; 36, 37; 36, 47; 36, 55; 37, if_statement; 37, 38; 37, 41; 38, comparison_operator:is; 38, 39; 38, 40; 39, identifier:mpl; 40, None; 41, block; 41, 42; 42, raise_statement; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:Exception; 45, argument_list; 45, 46; 46, string:'either the flavor or mpl must be provided'; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:rendering; 50, subscript; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:mpl; 53, identifier:rcParams; 54, string:'text.usetex'; 55, if_statement; 55, 56; 55, 57; 55, 62; 56, identifier:rendering; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:flavor; 61, string:'latex'; 62, else_clause; 62, 63; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:flavor; 67, string:'mathml'; 68, if_statement; 68, 69; 68, 72; 69, comparison_operator:not; 69, 70; 69, 71; 70, identifier:parameter; 71, identifier:labels; 72, block; 72, 73; 73, raise_statement; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:Exception; 76, argument_list; 76, 77; 77, string:'parameter not known'; 78, if_statement; 78, 79; 78, 84; 79, comparison_operator:not; 79, 80; 79, 81; 80, identifier:ptype; 81, subscript; 81, 82; 81, 83; 82, identifier:labels; 83, identifier:parameter; 84, block; 84, 85; 85, raise_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:Exception; 88, argument_list; 88, 89; 89, string:'ptype not known'; 90, if_statement; 90, 91; 90, 98; 91, comparison_operator:not; 91, 92; 91, 93; 92, identifier:flavor; 93, subscript; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:labels; 96, identifier:parameter; 97, identifier:ptype; 98, block; 98, 99; 99, raise_statement; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:Exception; 102, argument_list; 102, 103; 103, string:'flavor not known'; 104, return_statement; 104, 105; 105, subscript; 105, 106; 105, 111; 106, subscript; 106, 107; 106, 110; 107, subscript; 107, 108; 107, 109; 108, identifier:labels; 109, identifier:parameter; 110, identifier:ptype; 111, identifier:flavor | def get_label(parameter, ptype, flavor=None, mpl=None):
if flavor is not None:
if flavor not in ('latex', 'mathml'):
raise Exception('flavor not recognized: {}'.format(flavor))
else:
if mpl is None:
raise Exception('either the flavor or mpl must be provided')
rendering = mpl.rcParams['text.usetex']
if rendering:
flavor = 'latex'
else:
flavor = 'mathml'
if parameter not in labels:
raise Exception('parameter not known')
if ptype not in labels[parameter]:
raise Exception('ptype not known')
if flavor not in labels[parameter][ptype]:
raise Exception('flavor not known')
return labels[parameter][ptype][flavor] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:convert; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:input_format; 5, identifier:output_format; 6, identifier:data; 7, default_parameter; 7, 8; 7, 9; 8, identifier:one_spectrum; 9, False; 10, block; 10, 11; 10, 18; 10, 33; 10, 48; 10, 101; 10, 112; 10, 122; 10, 146; 10, 165; 11, if_statement; 11, 12; 11, 15; 12, comparison_operator:==; 12, 13; 12, 14; 13, identifier:input_format; 14, identifier:output_format; 15, block; 15, 16; 16, return_statement; 16, 17; 17, identifier:data; 18, if_statement; 18, 19; 18, 22; 19, comparison_operator:not; 19, 20; 19, 21; 20, identifier:input_format; 21, identifier:from_converters; 22, block; 22, 23; 23, raise_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:KeyError; 26, argument_list; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, string:'Input format {0} not known!'; 30, identifier:format; 31, argument_list; 31, 32; 32, identifier:input_format; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:not; 34, 35; 34, 36; 35, identifier:output_format; 36, identifier:to_converters; 37, block; 37, 38; 38, raise_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:KeyError; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, string:'Output format {0} not known!'; 45, identifier:format; 46, argument_list; 46, 47; 47, identifier:output_format; 48, if_statement; 48, 49; 48, 67; 48, 91; 49, boolean_operator:and; 49, 50; 49, 66; 50, boolean_operator:and; 50, 51; 50, 59; 51, comparison_operator:==; 51, 52; 51, 58; 52, call; 52, 53; 52, 54; 53, identifier:len; 54, argument_list; 54, 55; 55, attribute; 55, 56; 55, 57; 56, identifier:data; 57, identifier:shape; 58, integer:2; 59, comparison_operator:==; 59, 60; 59, 65; 60, subscript; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:data; 63, identifier:shape; 64, integer:0; 65, integer:2; 66, identifier:one_spectrum; 67, block; 67, 68; 67, 87; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:work_data; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:np; 74, identifier:hstack; 75, argument_list; 75, 76; 76, tuple; 76, 77; 76, 82; 77, subscript; 77, 78; 77, 79; 77, 80; 78, identifier:data; 79, integer:0; 80, slice; 80, 81; 81, colon; 82, subscript; 82, 83; 82, 84; 82, 85; 83, identifier:data; 84, integer:1; 85, slice; 85, 86; 86, colon; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:one_spec_2d; 90, True; 91, else_clause; 91, 92; 92, block; 92, 93; 92, 97; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:work_data; 96, identifier:data; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:one_spec_2d; 100, False; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 106; 103, pattern_list; 103, 104; 103, 105; 104, identifier:cre; 105, identifier:cim; 106, call; 106, 107; 106, 110; 107, subscript; 107, 108; 107, 109; 108, identifier:from_converters; 109, identifier:input_format; 110, argument_list; 110, 111; 111, identifier:work_data; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:converted_data; 115, call; 115, 116; 115, 119; 116, subscript; 116, 117; 116, 118; 117, identifier:to_converters; 118, identifier:output_format; 119, argument_list; 119, 120; 119, 121; 120, identifier:cre; 121, identifier:cim; 122, if_statement; 122, 123; 122, 124; 123, identifier:one_spec_2d; 124, block; 124, 125; 124, 135; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 130; 127, pattern_list; 127, 128; 127, 129; 128, identifier:part1; 129, identifier:part2; 130, call; 130, 131; 130, 132; 131, identifier:split_data; 132, argument_list; 132, 133; 132, 134; 133, identifier:converted_data; 134, True; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:converted_data; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:np; 141, identifier:vstack; 142, argument_list; 142, 143; 143, tuple; 143, 144; 143, 145; 144, identifier:part1; 145, identifier:part2; 146, if_statement; 146, 147; 146, 155; 147, comparison_operator:==; 147, 148; 147, 154; 148, call; 148, 149; 148, 150; 149, identifier:len; 150, argument_list; 150, 151; 151, attribute; 151, 152; 151, 153; 152, identifier:data; 153, identifier:shape; 154, integer:1; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:converted_data; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:np; 162, identifier:squeeze; 163, argument_list; 163, 164; 164, identifier:converted_data; 165, return_statement; 165, 166; 166, identifier:converted_data | def convert(input_format, output_format, data, one_spectrum=False):
if input_format == output_format:
return data
if input_format not in from_converters:
raise KeyError('Input format {0} not known!'.format(input_format))
if output_format not in to_converters:
raise KeyError('Output format {0} not known!'.format(output_format))
if len(data.shape) == 2 and data.shape[0] == 2 and one_spectrum:
work_data = np.hstack((data[0, :], data[1, :]))
one_spec_2d = True
else:
work_data = data
one_spec_2d = False
cre, cim = from_converters[input_format](work_data)
converted_data = to_converters[output_format](cre, cim)
if one_spec_2d:
part1, part2 = split_data(converted_data, True)
converted_data = np.vstack((part1, part2))
if len(data.shape) == 1:
converted_data = np.squeeze(converted_data)
return converted_data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:plot_ps_extra; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:dataobj; 5, identifier:key; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 30; 8, 59; 8, 105; 8, 114; 8, 127; 8, 136; 8, 150; 8, 156; 8, 164; 8, 187; 8, 196; 8, 200; 8, 287; 8, 322; 8, 328; 8, 334; 9, if_statement; 9, 10; 9, 17; 9, 22; 10, call; 10, 11; 10, 12; 11, identifier:isinstance; 12, argument_list; 12, 13; 12, 14; 13, identifier:dataobj; 14, attribute; 14, 15; 14, 16; 15, identifier:pd; 16, identifier:DataFrame; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:df_raw; 21, identifier:dataobj; 22, else_clause; 22, 23; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:df_raw; 27, attribute; 27, 28; 27, 29; 28, identifier:dataobj; 29, identifier:data; 30, if_statement; 30, 31; 30, 38; 30, 53; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:kwargs; 34, identifier:get; 35, argument_list; 35, 36; 35, 37; 36, string:'subquery'; 37, False; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:df; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:df_raw; 45, identifier:query; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:kwargs; 50, identifier:get; 51, argument_list; 51, 52; 52, string:'subquery'; 53, else_clause; 53, 54; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:df; 58, identifier:df_raw; 59, function_definition; 59, 60; 59, 61; 59, 64; 60, function_name:fancyfy; 61, parameters; 61, 62; 61, 63; 62, identifier:axes; 63, identifier:N; 64, block; 64, 65; 64, 86; 65, for_statement; 65, 66; 65, 67; 65, 78; 66, identifier:ax; 67, attribute; 67, 68; 67, 77; 68, subscript; 68, 69; 68, 70; 68, 75; 69, identifier:axes; 70, slice; 70, 71; 70, 72; 70, 73; 71, integer:0; 72, colon; 73, unary_operator:-; 73, 74; 74, integer:1; 75, slice; 75, 76; 76, colon; 77, identifier:flat; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:ax; 83, identifier:set_xlabel; 84, argument_list; 84, 85; 85, string:''; 86, for_statement; 86, 87; 86, 88; 86, 97; 87, identifier:ax; 88, attribute; 88, 89; 88, 96; 89, subscript; 89, 90; 89, 91; 89, 93; 90, identifier:axes; 91, slice; 91, 92; 92, colon; 93, slice; 93, 94; 93, 95; 94, integer:1; 95, colon; 96, identifier:flat; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:ax; 102, identifier:set_ylabel; 103, argument_list; 103, 104; 104, string:''; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:g; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:df; 111, identifier:groupby; 112, argument_list; 112, 113; 113, string:'timestep'; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:N; 117, call; 117, 118; 117, 119; 118, identifier:len; 119, argument_list; 119, 120; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:g; 124, identifier:groups; 125, identifier:keys; 126, argument_list; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:nrx; 130, call; 130, 131; 130, 132; 131, identifier:min; 132, argument_list; 132, 133; 133, tuple; 133, 134; 133, 135; 134, identifier:N; 135, integer:5; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:nry; 139, call; 139, 140; 139, 141; 140, identifier:int; 141, argument_list; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:np; 145, identifier:ceil; 146, argument_list; 146, 147; 147, binary_operator:/; 147, 148; 147, 149; 148, identifier:N; 149, identifier:nrx; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:sizex; 153, binary_operator:*; 153, 154; 153, 155; 154, identifier:nrx; 155, integer:3; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:sizey; 159, binary_operator:-; 159, 160; 159, 163; 160, binary_operator:*; 160, 161; 160, 162; 161, identifier:nry; 162, integer:4; 163, integer:1; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 169; 166, pattern_list; 166, 167; 166, 168; 167, identifier:fig; 168, identifier:axes; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:plt; 172, identifier:subplots; 173, argument_list; 173, 174; 173, 175; 173, 176; 173, 179; 173, 182; 174, identifier:nry; 175, identifier:nrx; 176, keyword_argument; 176, 177; 176, 178; 177, identifier:sharex; 178, True; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:sharey; 181, True; 182, keyword_argument; 182, 183; 182, 184; 183, identifier:figsize; 184, tuple; 184, 185; 184, 186; 185, identifier:sizex; 186, identifier:sizey; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:axes; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:np; 193, identifier:atleast_2d; 194, argument_list; 194, 195; 195, identifier:axes; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:cbs; 199, list:[]; 200, for_statement; 200, 201; 200, 206; 200, 213; 201, pattern_list; 201, 202; 201, 203; 202, identifier:ax; 203, tuple_pattern; 203, 204; 203, 205; 204, identifier:name; 205, identifier:group; 206, call; 206, 207; 206, 208; 207, identifier:zip; 208, argument_list; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:axes; 211, identifier:flat; 212, identifier:g; 213, block; 213, 214; 213, 249; 213, 256; 213, 271; 213, 280; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 220; 216, pattern_list; 216, 217; 216, 218; 216, 219; 217, identifier:fig1; 218, identifier:axes1; 219, identifier:cb1; 220, call; 220, 221; 220, 222; 221, identifier:plot_pseudosection_type2; 222, argument_list; 222, 223; 222, 224; 222, 225; 222, 228; 222, 231; 222, 240; 223, identifier:group; 224, identifier:key; 225, keyword_argument; 225, 226; 225, 227; 226, identifier:ax; 227, identifier:ax; 228, keyword_argument; 228, 229; 228, 230; 229, identifier:log10; 230, False; 231, keyword_argument; 231, 232; 231, 233; 232, identifier:cbmin; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:kwargs; 236, identifier:get; 237, argument_list; 237, 238; 237, 239; 238, string:'cbmin'; 239, None; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:cbmax; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:kwargs; 245, identifier:get; 246, argument_list; 246, 247; 246, 248; 247, string:'cbmax'; 248, None; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:cbs; 253, identifier:append; 254, argument_list; 254, 255; 255, identifier:cb1; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:ax; 260, identifier:set_title; 261, argument_list; 261, 262; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, string:'timestep: {0}'; 265, identifier:format; 266, argument_list; 266, 267; 267, call; 267, 268; 267, 269; 268, identifier:int; 269, argument_list; 269, 270; 270, identifier:name; 271, expression_statement; 271, 272; 272, call; 272, 273; 272, 278; 273, attribute; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:ax; 276, identifier:xaxis; 277, identifier:set_ticks_position; 278, argument_list; 278, 279; 279, string:'bottom'; 280, expression_statement; 280, 281; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:ax; 284, identifier:set_aspect; 285, argument_list; 285, 286; 286, string:'equal'; 287, for_statement; 287, 288; 287, 289; 287, 312; 288, identifier:cb; 289, attribute; 289, 290; 289, 311; 290, subscript; 290, 291; 290, 304; 290, 306; 291, call; 291, 292; 291, 300; 292, attribute; 292, 293; 292, 299; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:np; 296, identifier:array; 297, argument_list; 297, 298; 298, identifier:cbs; 299, identifier:reshape; 300, argument_list; 300, 301; 301, attribute; 301, 302; 301, 303; 302, identifier:axes; 303, identifier:shape; 304, slice; 304, 305; 305, colon; 306, slice; 306, 307; 306, 308; 306, 309; 307, integer:0; 308, colon; 309, unary_operator:-; 309, 310; 310, integer:1; 311, identifier:flat; 312, block; 312, 313; 313, expression_statement; 313, 314; 314, call; 314, 315; 314, 320; 315, attribute; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:cb; 318, identifier:ax; 319, identifier:set_visible; 320, argument_list; 320, 321; 321, False; 322, expression_statement; 322, 323; 323, call; 323, 324; 323, 325; 324, identifier:fancyfy; 325, argument_list; 325, 326; 325, 327; 326, identifier:axes; 327, identifier:N; 328, expression_statement; 328, 329; 329, call; 329, 330; 329, 333; 330, attribute; 330, 331; 330, 332; 331, identifier:fig; 332, identifier:tight_layout; 333, argument_list; 334, return_statement; 334, 335; 335, identifier:fig | def plot_ps_extra(dataobj, key, **kwargs):
if isinstance(dataobj, pd.DataFrame):
df_raw = dataobj
else:
df_raw = dataobj.data
if kwargs.get('subquery', False):
df = df_raw.query(kwargs.get('subquery'))
else:
df = df_raw
def fancyfy(axes, N):
for ax in axes[0:-1, :].flat:
ax.set_xlabel('')
for ax in axes[:, 1:].flat:
ax.set_ylabel('')
g = df.groupby('timestep')
N = len(g.groups.keys())
nrx = min((N, 5))
nry = int(np.ceil(N / nrx))
sizex = nrx * 3
sizey = nry * 4 - 1
fig, axes = plt.subplots(
nry, nrx,
sharex=True,
sharey=True,
figsize=(sizex, sizey),
)
axes = np.atleast_2d(axes)
cbs = []
for ax, (name, group) in zip(axes.flat, g):
fig1, axes1, cb1 = plot_pseudosection_type2(
group,
key,
ax=ax,
log10=False,
cbmin=kwargs.get('cbmin', None),
cbmax=kwargs.get('cbmax', None),
)
cbs.append(cb1)
ax.set_title('timestep: {0}'.format(int(name)))
ax.xaxis.set_ticks_position('bottom')
ax.set_aspect('equal')
for cb in np.array(cbs).reshape(axes.shape)[:, 0:-1].flat:
cb.ax.set_visible(False)
fancyfy(axes, N)
fig.tight_layout()
return fig |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:plot_pseudodepths; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:configs; 5, identifier:nr_electrodes; 6, default_parameter; 6, 7; 6, 8; 7, identifier:spacing; 8, integer:1; 9, default_parameter; 9, 10; 9, 11; 10, identifier:grid; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:ctypes; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:dd_merge; 17, False; 18, dictionary_splat_pattern; 18, 19; 19, identifier:kwargs; 20, block; 20, 21; 20, 34; 20, 47; 20, 54; 20, 69; 20, 73; 20, 77; 20, 372; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:pseudo_d_functions; 24, dictionary; 24, 25; 24, 28; 24, 31; 25, pair; 25, 26; 25, 27; 26, string:'dd'; 27, identifier:_pseudodepths_dd_simple; 28, pair; 28, 29; 28, 30; 29, string:'schlumberger'; 30, identifier:_pseudodepths_schlumberger; 31, pair; 31, 32; 31, 33; 32, string:'wenner'; 33, identifier:_pseudodepths_wenner; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:titles; 37, dictionary; 37, 38; 37, 41; 37, 44; 38, pair; 38, 39; 38, 40; 39, string:'dd'; 40, string:'dipole-dipole configurations'; 41, pair; 41, 42; 41, 43; 42, string:'schlumberger'; 43, string:'Schlumberger configurations'; 44, pair; 44, 45; 44, 46; 45, string:'wenner'; 46, string:'Wenner configurations'; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:only_types; 50, boolean_operator:or; 50, 51; 50, 52; 51, identifier:ctypes; 52, list:['dd', ]; 52, 53; 53, string:'dd'; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:results; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:fT; 60, identifier:filter; 61, argument_list; 61, 62; 61, 63; 62, identifier:configs; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:settings; 65, dictionary; 65, 66; 66, pair; 66, 67; 66, 68; 67, string:'only_types'; 68, identifier:only_types; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:figs; 72, list:[]; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:axes; 76, list:[]; 77, for_statement; 77, 78; 77, 79; 77, 87; 78, identifier:key; 79, call; 79, 80; 79, 81; 80, identifier:sorted; 81, argument_list; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:results; 85, identifier:keys; 86, argument_list; 87, block; 87, 88; 87, 94; 87, 100; 87, 106; 87, 181; 87, 185; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:print; 91, argument_list; 91, 92; 91, 93; 92, string:'plotting: '; 93, identifier:key; 94, if_statement; 94, 95; 94, 98; 95, comparison_operator:==; 95, 96; 95, 97; 96, identifier:key; 97, string:'not_sorted'; 98, block; 98, 99; 99, continue_statement; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:index_dict; 103, subscript; 103, 104; 103, 105; 104, identifier:results; 105, identifier:key; 106, if_statement; 106, 107; 106, 113; 106, 154; 107, boolean_operator:and; 107, 108; 107, 111; 108, comparison_operator:==; 108, 109; 108, 110; 109, identifier:key; 110, string:'dd'; 111, not_operator; 111, 112; 112, identifier:dd_merge; 113, block; 113, 114; 113, 118; 113, 122; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:plot_list; 117, list:[]; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:labels_add; 121, list:[]; 122, for_statement; 122, 123; 122, 124; 122, 132; 123, identifier:skip; 124, call; 124, 125; 124, 126; 125, identifier:sorted; 126, argument_list; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:index_dict; 130, identifier:keys; 131, argument_list; 132, block; 132, 133; 132, 142; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:plot_list; 137, identifier:append; 138, argument_list; 138, 139; 139, subscript; 139, 140; 139, 141; 140, identifier:index_dict; 141, identifier:skip; 142, expression_statement; 142, 143; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:labels_add; 146, identifier:append; 147, argument_list; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, string:' - skip {0}'; 151, identifier:format; 152, argument_list; 152, 153; 153, identifier:skip; 154, else_clause; 154, 155; 155, block; 155, 156; 155, 170; 155, 176; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:plot_list; 159, list:[np.hstack(index_dict.values()), ]; 159, 160; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:np; 163, identifier:hstack; 164, argument_list; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:index_dict; 168, identifier:values; 169, argument_list; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:print; 173, argument_list; 173, 174; 173, 175; 174, string:'schlumberger'; 175, identifier:plot_list; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:labels_add; 179, list:['', ]; 179, 180; 180, string:''; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:grid; 184, None; 185, for_statement; 185, 186; 185, 189; 185, 194; 186, pattern_list; 186, 187; 186, 188; 187, identifier:indices; 188, identifier:label_add; 189, call; 189, 190; 189, 191; 190, identifier:zip; 191, argument_list; 191, 192; 191, 193; 192, identifier:plot_list; 193, identifier:labels_add; 194, block; 194, 195; 194, 204; 194, 210; 194, 223; 194, 242; 194, 256; 194, 320; 194, 331; 194, 338; 194, 345; 194, 352; 194, 358; 194, 365; 195, if_statement; 195, 196; 195, 202; 196, comparison_operator:==; 196, 197; 196, 201; 197, call; 197, 198; 197, 199; 198, identifier:len; 199, argument_list; 199, 200; 200, identifier:indices; 201, integer:0; 202, block; 202, 203; 203, continue_statement; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:ddc; 207, subscript; 207, 208; 207, 209; 208, identifier:configs; 209, identifier:indices; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 215; 212, pattern_list; 212, 213; 212, 214; 213, identifier:px; 214, identifier:pz; 215, call; 215, 216; 215, 219; 216, subscript; 216, 217; 216, 218; 217, identifier:pseudo_d_functions; 218, identifier:key; 219, argument_list; 219, 220; 219, 221; 219, 222; 220, identifier:ddc; 221, identifier:spacing; 222, identifier:grid; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 228; 225, pattern_list; 225, 226; 225, 227; 226, identifier:fig; 227, identifier:ax; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:plt; 231, identifier:subplots; 232, argument_list; 232, 233; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:figsize; 235, tuple; 235, 236; 235, 239; 236, binary_operator:/; 236, 237; 236, 238; 237, integer:15; 238, float:2.54; 239, binary_operator:/; 239, 240; 239, 241; 240, integer:5; 241, float:2.54; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:ax; 246, identifier:scatter; 247, argument_list; 247, 248; 247, 249; 247, 250; 247, 253; 248, identifier:px; 249, identifier:pz; 250, keyword_argument; 250, 251; 250, 252; 251, identifier:color; 252, string:'k'; 253, keyword_argument; 253, 254; 253, 255; 254, identifier:alpha; 255, float:0.5; 256, if_statement; 256, 257; 256, 260; 256, 291; 257, comparison_operator:is; 257, 258; 257, 259; 258, identifier:grid; 259, None; 260, block; 260, 261; 260, 269; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:electrodes; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:grid; 267, identifier:get_electrode_positions; 268, argument_list; 269, expression_statement; 269, 270; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:ax; 273, identifier:scatter; 274, argument_list; 274, 275; 274, 280; 274, 285; 274, 288; 275, subscript; 275, 276; 275, 277; 275, 279; 276, identifier:electrodes; 277, slice; 277, 278; 278, colon; 279, integer:0; 280, subscript; 280, 281; 280, 282; 280, 284; 281, identifier:electrodes; 282, slice; 282, 283; 283, colon; 284, integer:1; 285, keyword_argument; 285, 286; 285, 287; 286, identifier:color; 287, string:'b'; 288, keyword_argument; 288, 289; 288, 290; 289, identifier:label; 290, string:'electrodes'; 291, else_clause; 291, 292; 292, block; 292, 293; 293, expression_statement; 293, 294; 294, call; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:ax; 297, identifier:scatter; 298, argument_list; 298, 299; 298, 308; 298, 314; 298, 317; 299, binary_operator:*; 299, 300; 299, 307; 300, call; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:np; 303, identifier:arange; 304, argument_list; 304, 305; 304, 306; 305, integer:0; 306, identifier:nr_electrodes; 307, identifier:spacing; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:np; 311, identifier:zeros; 312, argument_list; 312, 313; 313, identifier:nr_electrodes; 314, keyword_argument; 314, 315; 314, 316; 315, identifier:color; 316, string:'b'; 317, keyword_argument; 317, 318; 317, 319; 318, identifier:label; 319, string:'electrodes'; 320, expression_statement; 320, 321; 321, call; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, identifier:ax; 324, identifier:set_title; 325, argument_list; 325, 326; 326, binary_operator:+; 326, 327; 326, 330; 327, subscript; 327, 328; 327, 329; 328, identifier:titles; 329, identifier:key; 330, identifier:label_add; 331, expression_statement; 331, 332; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:ax; 335, identifier:set_aspect; 336, argument_list; 336, 337; 337, string:'equal'; 338, expression_statement; 338, 339; 339, call; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, identifier:ax; 342, identifier:set_xlabel; 343, argument_list; 343, 344; 344, string:'x [m]'; 345, expression_statement; 345, 346; 346, call; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, identifier:ax; 349, identifier:set_ylabel; 350, argument_list; 350, 351; 351, string:'x [z]'; 352, expression_statement; 352, 353; 353, call; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:fig; 356, identifier:tight_layout; 357, argument_list; 358, expression_statement; 358, 359; 359, call; 359, 360; 359, 363; 360, attribute; 360, 361; 360, 362; 361, identifier:figs; 362, identifier:append; 363, argument_list; 363, 364; 364, identifier:fig; 365, expression_statement; 365, 366; 366, call; 366, 367; 366, 370; 367, attribute; 367, 368; 367, 369; 368, identifier:axes; 369, identifier:append; 370, argument_list; 370, 371; 371, identifier:ax; 372, if_statement; 372, 373; 372, 379; 372, 388; 373, comparison_operator:==; 373, 374; 373, 378; 374, call; 374, 375; 374, 376; 375, identifier:len; 376, argument_list; 376, 377; 377, identifier:figs; 378, integer:1; 379, block; 379, 380; 380, return_statement; 380, 381; 381, expression_list; 381, 382; 381, 385; 382, subscript; 382, 383; 382, 384; 383, identifier:figs; 384, integer:0; 385, subscript; 385, 386; 385, 387; 386, identifier:axes; 387, integer:0; 388, else_clause; 388, 389; 389, block; 389, 390; 390, return_statement; 390, 391; 391, expression_list; 391, 392; 391, 393; 392, identifier:figs; 393, identifier:axes | def plot_pseudodepths(configs, nr_electrodes, spacing=1, grid=None,
ctypes=None, dd_merge=False, **kwargs):
pseudo_d_functions = {
'dd': _pseudodepths_dd_simple,
'schlumberger': _pseudodepths_schlumberger,
'wenner': _pseudodepths_wenner,
}
titles = {
'dd': 'dipole-dipole configurations',
'schlumberger': 'Schlumberger configurations',
'wenner': 'Wenner configurations',
}
only_types = ctypes or ['dd', ]
results = fT.filter(configs, settings={'only_types': only_types, })
figs = []
axes = []
for key in sorted(results.keys()):
print('plotting: ', key)
if key == 'not_sorted':
continue
index_dict = results[key]
if key == 'dd' and not dd_merge:
plot_list = []
labels_add = []
for skip in sorted(index_dict.keys()):
plot_list.append(index_dict[skip])
labels_add.append(' - skip {0}'.format(skip))
else:
plot_list = [np.hstack(index_dict.values()), ]
print('schlumberger', plot_list)
labels_add = ['', ]
grid = None
for indices, label_add in zip(plot_list, labels_add):
if len(indices) == 0:
continue
ddc = configs[indices]
px, pz = pseudo_d_functions[key](ddc, spacing, grid)
fig, ax = plt.subplots(figsize=(15 / 2.54, 5 / 2.54))
ax.scatter(px, pz, color='k', alpha=0.5)
if grid is not None:
electrodes = grid.get_electrode_positions()
ax.scatter(
electrodes[:, 0],
electrodes[:, 1],
color='b',
label='electrodes', )
else:
ax.scatter(
np.arange(0, nr_electrodes) * spacing,
np.zeros(nr_electrodes),
color='b',
label='electrodes', )
ax.set_title(titles[key] + label_add)
ax.set_aspect('equal')
ax.set_xlabel('x [m]')
ax.set_ylabel('x [z]')
fig.tight_layout()
figs.append(fig)
axes.append(ax)
if len(figs) == 1:
return figs[0], axes[0]
else:
return figs, axes |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:complete; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:uio; 6, default_parameter; 6, 7; 6, 8; 7, identifier:dropped; 8, False; 9, block; 9, 10; 9, 19; 10, if_statement; 10, 11; 10, 17; 11, boolean_operator:and; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:dropped; 15, not_operator; 15, 16; 16, identifier:dropped; 17, block; 17, 18; 18, return_statement; 19, for_statement; 19, 20; 19, 21; 19, 24; 20, identifier:end; 21, list:['src', 'dst']; 21, 22; 21, 23; 22, string:'src'; 23, string:'dst'; 24, block; 24, 25; 24, 33; 24, 44; 24, 51; 24, 62; 24, 149; 24, 174; 25, if_statement; 25, 26; 25, 31; 26, call; 26, 27; 26, 28; 27, identifier:getattr; 28, argument_list; 28, 29; 28, 30; 29, identifier:self; 30, identifier:end; 31, block; 31, 32; 32, continue_statement; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:uio; 37, identifier:show; 38, argument_list; 38, 39; 39, binary_operator:+; 39, 40; 39, 43; 40, binary_operator:+; 40, 41; 40, 42; 41, string:'\nEnter '; 42, identifier:end; 43, string:' for transaction:'; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:uio; 48, identifier:show; 49, argument_list; 49, 50; 50, string:''; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:uio; 55, identifier:show; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:summary; 61, argument_list; 62, try_statement; 62, 63; 62, 137; 63, block; 63, 64; 63, 68; 63, 74; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:endpoints; 67, list:[]; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:remaining; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:amount; 74, while_statement; 74, 75; 74, 76; 75, identifier:remaining; 76, block; 76, 77; 76, 87; 76, 105; 76, 116; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:account; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:uio; 83, identifier:text; 84, argument_list; 84, 85; 84, 86; 85, string:' Enter account'; 86, None; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:amount; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:uio; 93, identifier:decimal; 94, argument_list; 94, 95; 94, 96; 94, 99; 94, 102; 95, string:' Enter amount'; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:default; 98, identifier:remaining; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:lower; 101, integer:0; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:upper; 104, identifier:remaining; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:endpoints; 109, identifier:append; 110, argument_list; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:Endpoint; 113, argument_list; 113, 114; 113, 115; 114, identifier:account; 115, identifier:amount; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:remaining; 119, binary_operator:-; 119, 120; 119, 123; 119, 124; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:amount; 123, line_continuation:\; 124, call; 124, 125; 124, 126; 125, identifier:sum; 126, argument_list; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:map; 129, argument_list; 129, 130; 129, 136; 130, lambda; 130, 131; 130, 133; 131, lambda_parameters; 131, 132; 132, identifier:x; 133, attribute; 133, 134; 133, 135; 134, identifier:x; 135, identifier:amount; 136, identifier:endpoints; 137, except_clause; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:ui; 140, identifier:RejectWarning; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:sys; 146, identifier:exit; 147, argument_list; 147, 148; 148, string:"bye!"; 149, if_statement; 149, 150; 149, 153; 150, comparison_operator:==; 150, 151; 150, 152; 151, identifier:end; 152, string:'src'; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:endpoints; 157, call; 157, 158; 157, 159; 158, identifier:map; 159, argument_list; 159, 160; 159, 173; 160, lambda; 160, 161; 160, 163; 161, lambda_parameters; 161, 162; 162, identifier:x; 163, call; 163, 164; 163, 165; 164, identifier:Endpoint; 165, argument_list; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:x; 168, identifier:account; 169, unary_operator:-; 169, 170; 170, attribute; 170, 171; 170, 172; 171, identifier:x; 172, identifier:amount; 173, identifier:endpoints; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 177; 176, identifier:setattr; 177, argument_list; 177, 178; 177, 179; 177, 180; 178, identifier:self; 179, identifier:end; 180, identifier:endpoints | def complete(self, uio, dropped=False):
if self.dropped and not dropped:
return
for end in ['src', 'dst']:
if getattr(self, end):
continue
uio.show('\nEnter ' + end + ' for transaction:')
uio.show('')
uio.show(self.summary())
try:
endpoints = []
remaining = self.amount
while remaining:
account = uio.text(' Enter account', None)
amount = uio.decimal(
' Enter amount',
default=remaining,
lower=0,
upper=remaining
)
endpoints.append(Endpoint(account, amount))
remaining = self.amount \
- sum(map(lambda x: x.amount, endpoints))
except ui.RejectWarning:
sys.exit("bye!")
if end == 'src':
endpoints = map(
lambda x: Endpoint(x.account, -x.amount),
endpoints
)
setattr(self, end, endpoints) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 27; 2, function_name:gen_dipole_dipole; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 4, identifier:self; 5, identifier:skipc; 6, default_parameter; 6, 7; 6, 8; 7, identifier:skipv; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:stepc; 11, integer:1; 12, default_parameter; 12, 13; 12, 14; 13, identifier:stepv; 14, integer:1; 15, default_parameter; 15, 16; 15, 17; 16, identifier:nr_voltage_dipoles; 17, integer:10; 18, default_parameter; 18, 19; 18, 20; 19, identifier:before_current; 20, False; 21, default_parameter; 21, 22; 21, 23; 22, identifier:start_skip; 23, integer:0; 24, default_parameter; 24, 25; 24, 26; 25, identifier:N; 26, None; 27, block; 27, 28; 27, 55; 27, 64; 27, 68; 27, 220; 27, 229; 27, 259; 28, if_statement; 28, 29; 28, 38; 28, 44; 29, boolean_operator:and; 29, 30; 29, 33; 30, comparison_operator:is; 30, 31; 30, 32; 31, identifier:N; 32, None; 33, comparison_operator:is; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:nr_electrodes; 37, None; 38, block; 38, 39; 39, raise_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:Exception; 42, argument_list; 42, 43; 43, string:'You must provide the number of electrodes'; 44, elif_clause; 44, 45; 44, 48; 45, comparison_operator:is; 45, 46; 45, 47; 46, identifier:N; 47, None; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:N; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:nr_electrodes; 55, if_statement; 55, 56; 55, 59; 56, comparison_operator:is; 56, 57; 56, 58; 57, identifier:skipv; 58, None; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:skipv; 63, identifier:skipc; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:configs; 67, list:[]; 68, for_statement; 68, 69; 68, 70; 68, 82; 69, identifier:a; 70, call; 70, 71; 70, 72; 71, identifier:range; 72, argument_list; 72, 73; 72, 74; 72, 81; 73, integer:0; 74, binary_operator:-; 74, 75; 74, 80; 75, binary_operator:-; 75, 76; 75, 79; 76, binary_operator:-; 76, 77; 76, 78; 77, identifier:N; 78, identifier:skipv; 79, identifier:skipc; 80, integer:3; 81, identifier:stepc; 82, block; 82, 83; 82, 91; 82, 95; 82, 159; 82, 163; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:b; 86, binary_operator:+; 86, 87; 86, 90; 87, binary_operator:+; 87, 88; 87, 89; 88, identifier:a; 89, identifier:skipc; 90, integer:1; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:nr; 94, integer:0; 95, if_statement; 95, 96; 95, 97; 96, identifier:before_current; 97, block; 97, 98; 98, for_statement; 98, 99; 98, 100; 98, 112; 99, identifier:n; 100, call; 100, 101; 100, 102; 101, identifier:range; 102, argument_list; 102, 103; 102, 108; 102, 110; 103, binary_operator:-; 103, 104; 103, 107; 104, binary_operator:-; 104, 105; 104, 106; 105, identifier:a; 106, identifier:start_skip; 107, integer:1; 108, unary_operator:-; 108, 109; 109, integer:1; 110, unary_operator:-; 110, 111; 111, identifier:stepv; 112, block; 112, 113; 112, 117; 112, 123; 112, 131; 112, 137; 112, 152; 113, expression_statement; 113, 114; 114, augmented_assignment:+=; 114, 115; 114, 116; 115, identifier:nr; 116, integer:1; 117, if_statement; 117, 118; 117, 121; 118, comparison_operator:>; 118, 119; 118, 120; 119, identifier:nr; 120, identifier:nr_voltage_dipoles; 121, block; 121, 122; 122, continue_statement; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:m; 126, binary_operator:-; 126, 127; 126, 130; 127, binary_operator:-; 127, 128; 127, 129; 128, identifier:n; 129, identifier:skipv; 130, integer:1; 131, if_statement; 131, 132; 131, 135; 132, comparison_operator:<; 132, 133; 132, 134; 133, identifier:m; 134, integer:0; 135, block; 135, 136; 136, continue_statement; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:quadpole; 140, binary_operator:+; 140, 141; 140, 151; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:np; 144, identifier:array; 145, argument_list; 145, 146; 146, tuple; 146, 147; 146, 148; 146, 149; 146, 150; 147, identifier:a; 148, identifier:b; 149, identifier:m; 150, identifier:n; 151, integer:1; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:configs; 156, identifier:append; 157, argument_list; 157, 158; 158, identifier:quadpole; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:nr; 162, integer:0; 163, for_statement; 163, 164; 163, 165; 163, 179; 164, identifier:m; 165, call; 165, 166; 165, 167; 166, identifier:range; 167, argument_list; 167, 168; 167, 173; 167, 178; 168, binary_operator:+; 168, 169; 168, 172; 169, binary_operator:+; 169, 170; 169, 171; 170, identifier:b; 171, identifier:start_skip; 172, integer:1; 173, binary_operator:-; 173, 174; 173, 177; 174, binary_operator:-; 174, 175; 174, 176; 175, identifier:N; 176, identifier:skipv; 177, integer:1; 178, identifier:stepv; 179, block; 179, 180; 179, 184; 179, 190; 179, 198; 179, 213; 180, expression_statement; 180, 181; 181, augmented_assignment:+=; 181, 182; 181, 183; 182, identifier:nr; 183, integer:1; 184, if_statement; 184, 185; 184, 188; 185, comparison_operator:>; 185, 186; 185, 187; 186, identifier:nr; 187, identifier:nr_voltage_dipoles; 188, block; 188, 189; 189, continue_statement; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:n; 193, binary_operator:+; 193, 194; 193, 197; 194, binary_operator:+; 194, 195; 194, 196; 195, identifier:m; 196, identifier:skipv; 197, integer:1; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:quadpole; 201, binary_operator:+; 201, 202; 201, 212; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:np; 205, identifier:array; 206, argument_list; 206, 207; 207, tuple; 207, 208; 207, 209; 207, 210; 207, 211; 208, identifier:a; 209, identifier:b; 210, identifier:m; 211, identifier:n; 212, integer:1; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:configs; 217, identifier:append; 218, argument_list; 218, 219; 219, identifier:quadpole; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:configs; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:np; 226, identifier:array; 227, argument_list; 227, 228; 228, identifier:configs; 229, if_statement; 229, 230; 229, 235; 229, 242; 230, comparison_operator:is; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:self; 233, identifier:configs; 234, None; 235, block; 235, 236; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:self; 240, identifier:configs; 241, identifier:configs; 242, else_clause; 242, 243; 243, block; 243, 244; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:self; 248, identifier:configs; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:np; 252, identifier:vstack; 253, argument_list; 253, 254; 254, tuple; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:self; 257, identifier:configs; 258, identifier:configs; 259, return_statement; 259, 260; 260, identifier:configs | def gen_dipole_dipole(self,
skipc,
skipv=None,
stepc=1,
stepv=1,
nr_voltage_dipoles=10,
before_current=False,
start_skip=0,
N=None):
if N is None and self.nr_electrodes is None:
raise Exception('You must provide the number of electrodes')
elif N is None:
N = self.nr_electrodes
if skipv is None:
skipv = skipc
configs = []
for a in range(0, N - skipv - skipc - 3, stepc):
b = a + skipc + 1
nr = 0
if before_current:
for n in range(a - start_skip - 1, -1, -stepv):
nr += 1
if nr > nr_voltage_dipoles:
continue
m = n - skipv - 1
if m < 0:
continue
quadpole = np.array((a, b, m, n)) + 1
configs.append(quadpole)
nr = 0
for m in range(b + start_skip + 1, N - skipv - 1, stepv):
nr += 1
if nr > nr_voltage_dipoles:
continue
n = m + skipv + 1
quadpole = np.array((a, b, m, n)) + 1
configs.append(quadpole)
configs = np.array(configs)
if self.configs is None:
self.configs = configs
else:
self.configs = np.vstack((self.configs, configs))
return configs |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:split_into_normal_and_reciprocal; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:pad; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:return_indices; 10, False; 11, block; 11, 12; 11, 57; 11, 65; 11, 73; 11, 86; 11, 90; 11, 94; 11, 98; 11, 102; 11, 106; 11, 110; 11, 315; 11, 333; 11, 340; 11, 346; 11, 382; 11, 391; 11, 400; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:configs; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:np; 18, identifier:hstack; 19, argument_list; 19, 20; 20, tuple; 20, 21; 20, 39; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:sort; 25, argument_list; 25, 26; 25, 36; 26, subscript; 26, 27; 26, 30; 26, 32; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:configs; 30, slice; 30, 31; 31, colon; 32, slice; 32, 33; 32, 34; 32, 35; 33, integer:0; 34, colon; 35, integer:2; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:axis; 38, integer:1; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:np; 42, identifier:sort; 43, argument_list; 43, 44; 43, 54; 44, subscript; 44, 45; 44, 48; 44, 50; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:configs; 48, slice; 48, 49; 49, colon; 50, slice; 50, 51; 50, 52; 50, 53; 51, integer:2; 52, colon; 53, integer:4; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:axis; 56, integer:1; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:ab_min; 60, subscript; 60, 61; 60, 62; 60, 64; 61, identifier:configs; 62, slice; 62, 63; 63, colon; 64, integer:0; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:mn_min; 68, subscript; 68, 69; 68, 70; 68, 72; 69, identifier:configs; 70, slice; 70, 71; 71, colon; 72, integer:2; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:indices_normal; 76, subscript; 76, 77; 76, 85; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:np; 80, identifier:where; 81, argument_list; 81, 82; 82, comparison_operator:<; 82, 83; 82, 84; 83, identifier:ab_min; 84, identifier:mn_min; 85, integer:0; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:indices_used; 89, list:[]; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:normal; 93, list:[]; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:normal_indices; 97, list:[]; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:reciprocal_indices; 101, list:[]; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:reciprocal; 105, list:[]; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:duplicates; 109, list:[]; 110, for_statement; 110, 111; 110, 112; 110, 113; 111, identifier:index; 112, identifier:indices_normal; 113, block; 113, 114; 113, 121; 113, 134; 113, 141; 113, 198; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:indices_used; 118, identifier:append; 119, argument_list; 119, 120; 120, identifier:index; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:normal; 125, identifier:append; 126, argument_list; 126, 127; 127, subscript; 127, 128; 127, 131; 127, 132; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:configs; 131, identifier:index; 132, slice; 132, 133; 133, colon; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:normal_indices; 138, identifier:append; 139, argument_list; 139, 140; 140, identifier:index; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:index_rec; 144, subscript; 144, 145; 144, 197; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:np; 148, identifier:where; 149, argument_list; 149, 150; 150, binary_operator:&; 150, 151; 150, 186; 151, binary_operator:&; 151, 152; 151, 175; 152, binary_operator:&; 152, 153; 152, 164; 153, parenthesized_expression; 153, 154; 154, comparison_operator:==; 154, 155; 154, 160; 155, subscript; 155, 156; 155, 157; 155, 159; 156, identifier:configs; 157, slice; 157, 158; 158, colon; 159, integer:0; 160, subscript; 160, 161; 160, 162; 160, 163; 161, identifier:configs; 162, identifier:index; 163, integer:2; 164, parenthesized_expression; 164, 165; 165, comparison_operator:==; 165, 166; 165, 171; 166, subscript; 166, 167; 166, 168; 166, 170; 167, identifier:configs; 168, slice; 168, 169; 169, colon; 170, integer:1; 171, subscript; 171, 172; 171, 173; 171, 174; 172, identifier:configs; 173, identifier:index; 174, integer:3; 175, parenthesized_expression; 175, 176; 176, comparison_operator:==; 176, 177; 176, 182; 177, subscript; 177, 178; 177, 179; 177, 181; 178, identifier:configs; 179, slice; 179, 180; 180, colon; 181, integer:2; 182, subscript; 182, 183; 182, 184; 182, 185; 183, identifier:configs; 184, identifier:index; 185, integer:0; 186, parenthesized_expression; 186, 187; 187, comparison_operator:==; 187, 188; 187, 193; 188, subscript; 188, 189; 188, 190; 188, 192; 189, identifier:configs; 190, slice; 190, 191; 191, colon; 192, integer:3; 193, subscript; 193, 194; 193, 195; 193, 196; 194, identifier:configs; 195, identifier:index; 196, integer:1; 197, integer:0; 198, if_statement; 198, 199; 198, 207; 198, 224; 198, 265; 199, boolean_operator:and; 199, 200; 199, 206; 200, comparison_operator:==; 200, 201; 200, 205; 201, call; 201, 202; 201, 203; 202, identifier:len; 203, argument_list; 203, 204; 204, identifier:index_rec; 205, integer:0; 206, identifier:pad; 207, block; 207, 208; 208, expression_statement; 208, 209; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:reciprocal; 212, identifier:append; 213, argument_list; 213, 214; 214, binary_operator:*; 214, 215; 214, 221; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:np; 218, identifier:ones; 219, argument_list; 219, 220; 220, integer:4; 221, attribute; 221, 222; 221, 223; 222, identifier:np; 223, identifier:nan; 224, elif_clause; 224, 225; 224, 231; 225, comparison_operator:==; 225, 226; 225, 230; 226, call; 226, 227; 226, 228; 227, identifier:len; 228, argument_list; 228, 229; 229, identifier:index_rec; 230, integer:1; 231, block; 231, 232; 231, 247; 231, 256; 232, expression_statement; 232, 233; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:reciprocal; 236, identifier:append; 237, argument_list; 237, 238; 238, subscript; 238, 239; 238, 242; 238, 245; 239, attribute; 239, 240; 239, 241; 240, identifier:self; 241, identifier:configs; 242, subscript; 242, 243; 242, 244; 243, identifier:index_rec; 244, integer:0; 245, slice; 245, 246; 246, colon; 247, expression_statement; 247, 248; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:indices_used; 251, identifier:append; 252, argument_list; 252, 253; 253, subscript; 253, 254; 253, 255; 254, identifier:index_rec; 255, integer:0; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:reciprocal_indices; 260, identifier:append; 261, argument_list; 261, 262; 262, subscript; 262, 263; 262, 264; 263, identifier:index_rec; 264, integer:0; 265, elif_clause; 265, 266; 265, 272; 266, call; 266, 267; 266, 268; 267, identifier:len; 268, argument_list; 268, 269; 269, comparison_operator:>; 269, 270; 269, 271; 270, identifier:index_rec; 271, integer:1; 272, block; 272, 273; 272, 288; 272, 297; 272, 308; 273, expression_statement; 273, 274; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:reciprocal; 277, identifier:append; 278, argument_list; 278, 279; 279, subscript; 279, 280; 279, 283; 279, 286; 280, attribute; 280, 281; 280, 282; 281, identifier:self; 282, identifier:configs; 283, subscript; 283, 284; 283, 285; 284, identifier:index_rec; 285, integer:0; 286, slice; 286, 287; 287, colon; 288, expression_statement; 288, 289; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:reciprocal_indices; 292, identifier:append; 293, argument_list; 293, 294; 294, subscript; 294, 295; 294, 296; 295, identifier:index_rec; 296, integer:0; 297, expression_statement; 297, 298; 298, augmented_assignment:+=; 298, 299; 298, 300; 299, identifier:duplicates; 300, call; 300, 301; 300, 302; 301, identifier:list; 302, argument_list; 302, 303; 303, subscript; 303, 304; 303, 305; 304, identifier:index_rec; 305, slice; 305, 306; 305, 307; 306, integer:1; 307, colon; 308, expression_statement; 308, 309; 309, augmented_assignment:+=; 309, 310; 309, 311; 310, identifier:indices_used; 311, call; 311, 312; 311, 313; 312, identifier:list; 313, argument_list; 313, 314; 314, identifier:index_rec; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 318; 317, identifier:set_all_indices; 318, call; 318, 319; 318, 320; 319, identifier:set; 320, argument_list; 320, 321; 321, call; 321, 322; 321, 323; 322, identifier:list; 323, argument_list; 323, 324; 324, call; 324, 325; 324, 326; 325, identifier:range; 326, argument_list; 326, 327; 326, 328; 327, integer:0; 328, subscript; 328, 329; 328, 332; 329, attribute; 329, 330; 329, 331; 330, identifier:configs; 331, identifier:shape; 332, integer:0; 333, expression_statement; 333, 334; 334, assignment; 334, 335; 334, 336; 335, identifier:set_used_indices; 336, call; 336, 337; 336, 338; 337, identifier:set; 338, argument_list; 338, 339; 339, identifier:indices_used; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 343; 342, identifier:reciprocal_only_indices; 343, binary_operator:-; 343, 344; 343, 345; 344, identifier:set_all_indices; 345, identifier:set_used_indices; 346, for_statement; 346, 347; 346, 348; 346, 349; 347, identifier:index; 348, identifier:reciprocal_only_indices; 349, block; 349, 350; 349, 369; 350, if_statement; 350, 351; 350, 352; 351, identifier:pad; 352, block; 352, 353; 353, expression_statement; 353, 354; 354, call; 354, 355; 354, 358; 355, attribute; 355, 356; 355, 357; 356, identifier:normal; 357, identifier:append; 358, argument_list; 358, 359; 359, binary_operator:*; 359, 360; 359, 366; 360, call; 360, 361; 360, 364; 361, attribute; 361, 362; 361, 363; 362, identifier:np; 363, identifier:ones; 364, argument_list; 364, 365; 365, integer:4; 366, attribute; 366, 367; 366, 368; 367, identifier:np; 368, identifier:nan; 369, expression_statement; 369, 370; 370, call; 370, 371; 370, 374; 371, attribute; 371, 372; 371, 373; 372, identifier:reciprocal; 373, identifier:append; 374, argument_list; 374, 375; 375, subscript; 375, 376; 375, 379; 375, 380; 376, attribute; 376, 377; 376, 378; 377, identifier:self; 378, identifier:configs; 379, identifier:index; 380, slice; 380, 381; 381, colon; 382, expression_statement; 382, 383; 383, assignment; 383, 384; 383, 385; 384, identifier:normals; 385, call; 385, 386; 385, 389; 386, attribute; 386, 387; 386, 388; 387, identifier:np; 388, identifier:array; 389, argument_list; 389, 390; 390, identifier:normal; 391, expression_statement; 391, 392; 392, assignment; 392, 393; 392, 394; 393, identifier:reciprocals; 394, call; 394, 395; 394, 398; 395, attribute; 395, 396; 395, 397; 396, identifier:np; 397, identifier:array; 398, argument_list; 398, 399; 399, identifier:reciprocal; 400, if_statement; 400, 401; 400, 402; 400, 409; 401, identifier:return_indices; 402, block; 402, 403; 403, return_statement; 403, 404; 404, expression_list; 404, 405; 404, 406; 404, 407; 404, 408; 405, identifier:normals; 406, identifier:reciprocals; 407, identifier:normal_indices; 408, identifier:reciprocal_indices; 409, else_clause; 409, 410; 410, block; 410, 411; 411, return_statement; 411, 412; 412, expression_list; 412, 413; 412, 414; 413, identifier:normals; 414, identifier:reciprocals | def split_into_normal_and_reciprocal(self, pad=False,
return_indices=False):
configs = np.hstack((np.sort(self.configs[:, 0:2], axis=1),
np.sort(self.configs[:, 2:4], axis=1)))
ab_min = configs[:, 0]
mn_min = configs[:, 2]
indices_normal = np.where(ab_min < mn_min)[0]
indices_used = []
normal = []
normal_indices = []
reciprocal_indices = []
reciprocal = []
duplicates = []
for index in indices_normal:
indices_used.append(index)
normal.append(self.configs[index, :])
normal_indices.append(index)
index_rec = np.where(
(configs[:, 0] == configs[index, 2]) &
(configs[:, 1] == configs[index, 3]) &
(configs[:, 2] == configs[index, 0]) &
(configs[:, 3] == configs[index, 1]))[0]
if len(index_rec) == 0 and pad:
reciprocal.append(np.ones(4) * np.nan)
elif len(index_rec) == 1:
reciprocal.append(self.configs[index_rec[0], :])
indices_used.append(index_rec[0])
reciprocal_indices.append(index_rec[0])
elif len(index_rec > 1):
reciprocal.append(self.configs[index_rec[0], :])
reciprocal_indices.append(index_rec[0])
duplicates += list(index_rec[1:])
indices_used += list(index_rec)
set_all_indices = set(list(range(0, configs.shape[0])))
set_used_indices = set(indices_used)
reciprocal_only_indices = set_all_indices - set_used_indices
for index in reciprocal_only_indices:
if pad:
normal.append(np.ones(4) * np.nan)
reciprocal.append(self.configs[index, :])
normals = np.array(normal)
reciprocals = np.array(reciprocal)
if return_indices:
return normals, reciprocals, normal_indices, reciprocal_indices
else:
return normals, reciprocals |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:gen_reciprocals; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:append; 7, False; 8, block; 8, 9; 8, 27; 8, 53; 8, 79; 8, 108; 8, 114; 8, 132; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:reciprocals; 12, subscript; 12, 13; 12, 20; 12, 22; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:configs; 18, identifier:copy; 19, argument_list; 20, slice; 20, 21; 21, colon; 22, slice; 22, 23; 22, 24; 22, 25; 23, colon; 24, colon; 25, unary_operator:-; 25, 26; 26, integer:1; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 37; 29, subscript; 29, 30; 29, 31; 29, 33; 30, identifier:reciprocals; 31, slice; 31, 32; 32, colon; 33, slice; 33, 34; 33, 35; 33, 36; 34, integer:0; 35, colon; 36, integer:2; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:np; 40, identifier:sort; 41, argument_list; 41, 42; 41, 50; 42, subscript; 42, 43; 42, 44; 42, 46; 43, identifier:reciprocals; 44, slice; 44, 45; 45, colon; 46, slice; 46, 47; 46, 48; 46, 49; 47, integer:0; 48, colon; 49, integer:2; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:axis; 52, integer:1; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 63; 55, subscript; 55, 56; 55, 57; 55, 59; 56, identifier:reciprocals; 57, slice; 57, 58; 58, colon; 59, slice; 59, 60; 59, 61; 59, 62; 60, integer:2; 61, colon; 62, integer:4; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:np; 66, identifier:sort; 67, argument_list; 67, 68; 67, 76; 68, subscript; 68, 69; 68, 70; 68, 72; 69, identifier:reciprocals; 70, slice; 70, 71; 71, colon; 72, slice; 72, 73; 72, 74; 72, 75; 73, integer:2; 74, colon; 75, integer:4; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:axis; 78, integer:1; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:ind; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:np; 85, identifier:lexsort; 86, argument_list; 86, 87; 87, tuple; 87, 88; 87, 93; 87, 98; 87, 103; 88, subscript; 88, 89; 88, 90; 88, 92; 89, identifier:reciprocals; 90, slice; 90, 91; 91, colon; 92, integer:3; 93, subscript; 93, 94; 93, 95; 93, 97; 94, identifier:reciprocals; 95, slice; 95, 96; 96, colon; 97, integer:2; 98, subscript; 98, 99; 98, 100; 98, 102; 99, identifier:reciprocals; 100, slice; 100, 101; 101, colon; 102, integer:1; 103, subscript; 103, 104; 103, 105; 103, 107; 104, identifier:reciprocals; 105, slice; 105, 106; 106, colon; 107, integer:0; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:reciprocals; 111, subscript; 111, 112; 111, 113; 112, identifier:reciprocals; 113, identifier:ind; 114, if_statement; 114, 115; 114, 116; 115, identifier:append; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:configs; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:np; 125, identifier:vstack; 126, argument_list; 126, 127; 127, tuple; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:configs; 131, identifier:reciprocals; 132, return_statement; 132, 133; 133, identifier:reciprocals | def gen_reciprocals(self, append=False):
reciprocals = self.configs.copy()[:, ::-1]
reciprocals[:, 0:2] = np.sort(reciprocals[:, 0:2], axis=1)
reciprocals[:, 2:4] = np.sort(reciprocals[:, 2:4], axis=1)
ind = np.lexsort((reciprocals[:, 3], reciprocals[:, 2],
reciprocals[:, 1], reciprocals[:, 0]))
reciprocals = reciprocals[ind]
if append:
self.configs = np.vstack((self.configs, reciprocals))
return reciprocals |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:gen_configs_permutate; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:injections_raw; 6, default_parameter; 6, 7; 6, 8; 7, identifier:only_same_dipole_length; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:ignore_crossed_dipoles; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:silent; 14, False; 15, block; 15, 16; 15, 30; 15, 38; 15, 42; 15, 220; 15, 224; 15, 274; 15, 281; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:injections; 19, call; 19, 20; 19, 28; 20, attribute; 20, 21; 20, 27; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:atleast_2d; 25, argument_list; 25, 26; 26, identifier:injections_raw; 27, identifier:astype; 28, argument_list; 28, 29; 29, identifier:int; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:N; 33, subscript; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:injections; 36, identifier:shape; 37, integer:0; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:measurements; 41, list:[]; 42, for_statement; 42, 43; 42, 44; 42, 49; 43, identifier:injection; 44, call; 44, 45; 44, 46; 45, identifier:range; 46, argument_list; 46, 47; 46, 48; 47, integer:0; 48, identifier:N; 49, block; 49, 50; 49, 69; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:dipole_length; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:np; 56, identifier:abs; 57, argument_list; 57, 58; 58, binary_operator:-; 58, 59; 58, 64; 59, subscript; 59, 60; 59, 63; 60, subscript; 60, 61; 60, 62; 61, identifier:injections; 62, identifier:injection; 63, integer:1; 64, subscript; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:injections; 67, identifier:injection; 68, integer:0; 69, for_statement; 69, 70; 69, 71; 69, 85; 70, identifier:i; 71, binary_operator:-; 71, 72; 71, 80; 72, call; 72, 73; 72, 74; 73, identifier:set; 74, argument_list; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:range; 77, argument_list; 77, 78; 77, 79; 78, integer:0; 79, identifier:N; 80, call; 80, 81; 80, 82; 81, identifier:set; 82, argument_list; 82, 83; 83, list:[injection]; 83, 84; 84, identifier:injection; 85, block; 85, 86; 85, 109; 85, 118; 85, 141; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:test_dipole_length; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:np; 92, identifier:abs; 93, argument_list; 93, 94; 94, binary_operator:-; 94, 95; 94, 102; 95, subscript; 95, 96; 95, 101; 96, subscript; 96, 97; 96, 98; 96, 99; 97, identifier:injections; 98, identifier:i; 99, slice; 99, 100; 100, colon; 101, integer:1; 102, subscript; 102, 103; 102, 108; 103, subscript; 103, 104; 103, 105; 103, 106; 104, identifier:injections; 105, identifier:i; 106, slice; 106, 107; 107, colon; 108, integer:0; 109, if_statement; 109, 110; 109, 116; 110, parenthesized_expression; 110, 111; 111, boolean_operator:and; 111, 112; 111, 113; 112, identifier:only_same_dipole_length; 113, comparison_operator:!=; 113, 114; 113, 115; 114, identifier:test_dipole_length; 115, identifier:dipole_length; 116, block; 116, 117; 117, continue_statement; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:quadpole; 121, call; 121, 122; 121, 140; 122, attribute; 122, 123; 122, 139; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:np; 126, identifier:array; 127, argument_list; 127, 128; 128, list:[injections[injection, :], injections[i, :]]; 128, 129; 128, 134; 129, subscript; 129, 130; 129, 131; 129, 132; 130, identifier:injections; 131, identifier:injection; 132, slice; 132, 133; 133, colon; 134, subscript; 134, 135; 134, 136; 134, 137; 135, identifier:injections; 136, identifier:i; 137, slice; 137, 138; 138, colon; 139, identifier:flatten; 140, argument_list; 141, if_statement; 141, 142; 141, 145; 141, 211; 142, comparison_operator:is; 142, 143; 142, 144; 143, identifier:ignore_crossed_dipoles; 144, True; 145, block; 145, 146; 146, if_statement; 146, 147; 146, 163; 146, 174; 146, 202; 147, parenthesized_expression; 147, 148; 148, boolean_operator:and; 148, 149; 148, 156; 149, comparison_operator:>; 149, 150; 149, 153; 150, subscript; 150, 151; 150, 152; 151, identifier:quadpole; 152, integer:2; 153, subscript; 153, 154; 153, 155; 154, identifier:quadpole; 155, integer:0; 156, comparison_operator:<; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:quadpole; 159, integer:2; 160, subscript; 160, 161; 160, 162; 161, identifier:quadpole; 162, integer:1; 163, block; 163, 164; 164, if_statement; 164, 165; 164, 167; 165, not_operator; 165, 166; 166, identifier:silent; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:print; 171, argument_list; 171, 172; 171, 173; 172, string:'A - ignoring'; 173, identifier:quadpole; 174, elif_clause; 174, 175; 174, 191; 175, parenthesized_expression; 175, 176; 176, boolean_operator:and; 176, 177; 176, 184; 177, comparison_operator:>; 177, 178; 177, 181; 178, subscript; 178, 179; 178, 180; 179, identifier:quadpole; 180, integer:3; 181, subscript; 181, 182; 181, 183; 182, identifier:quadpole; 183, integer:0; 184, comparison_operator:<; 184, 185; 184, 188; 185, subscript; 185, 186; 185, 187; 186, identifier:quadpole; 187, integer:3; 188, subscript; 188, 189; 188, 190; 189, identifier:quadpole; 190, integer:1; 191, block; 191, 192; 192, if_statement; 192, 193; 192, 195; 193, not_operator; 193, 194; 194, identifier:silent; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, call; 197, 198; 197, 199; 198, identifier:print; 199, argument_list; 199, 200; 199, 201; 200, string:'B - ignoring'; 201, identifier:quadpole; 202, else_clause; 202, 203; 203, block; 203, 204; 204, expression_statement; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:measurements; 208, identifier:append; 209, argument_list; 209, 210; 210, identifier:quadpole; 211, else_clause; 211, 212; 212, block; 212, 213; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:measurements; 217, identifier:append; 218, argument_list; 218, 219; 219, identifier:quadpole; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:filtered; 223, list:[]; 224, for_statement; 224, 225; 224, 226; 224, 227; 225, identifier:quadpole; 226, identifier:measurements; 227, block; 227, 228; 228, if_statement; 228, 229; 228, 253; 228, 265; 229, parenthesized_expression; 229, 230; 230, not_operator; 230, 231; 231, call; 231, 232; 231, 243; 232, attribute; 232, 233; 232, 242; 233, call; 233, 234; 233, 235; 234, identifier:set; 235, argument_list; 235, 236; 236, subscript; 236, 237; 236, 238; 237, identifier:quadpole; 238, slice; 238, 239; 238, 240; 238, 241; 239, integer:0; 240, colon; 241, integer:2; 242, identifier:isdisjoint; 243, argument_list; 243, 244; 244, call; 244, 245; 244, 246; 245, identifier:set; 246, argument_list; 246, 247; 247, subscript; 247, 248; 247, 249; 248, identifier:quadpole; 249, slice; 249, 250; 249, 251; 249, 252; 250, integer:2; 251, colon; 252, integer:4; 253, block; 253, 254; 254, if_statement; 254, 255; 254, 257; 255, not_operator; 255, 256; 256, identifier:silent; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 261; 260, identifier:print; 261, argument_list; 261, 262; 261, 263; 261, 264; 262, string:'Ignoring quadrupole because of '; 263, string:'repeated electrode use:'; 264, identifier:quadpole; 265, else_clause; 265, 266; 266, block; 266, 267; 267, expression_statement; 267, 268; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:filtered; 271, identifier:append; 272, argument_list; 272, 273; 273, identifier:quadpole; 274, expression_statement; 274, 275; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:self; 278, identifier:add_to_configs; 279, argument_list; 279, 280; 280, identifier:filtered; 281, return_statement; 281, 282; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:np; 285, identifier:array; 286, argument_list; 286, 287; 287, identifier:filtered | def gen_configs_permutate(self,
injections_raw,
only_same_dipole_length=False,
ignore_crossed_dipoles=False,
silent=False):
injections = np.atleast_2d(injections_raw).astype(int)
N = injections.shape[0]
measurements = []
for injection in range(0, N):
dipole_length = np.abs(injections[injection][1] -
injections[injection][0])
for i in set(range(0, N)) - set([injection]):
test_dipole_length = np.abs(injections[i, :][1] -
injections[i, :][0])
if (only_same_dipole_length
and test_dipole_length != dipole_length):
continue
quadpole = np.array(
[injections[injection, :], injections[i, :]]).flatten()
if ignore_crossed_dipoles is True:
if (quadpole[2] > quadpole[0]
and quadpole[2] < quadpole[1]):
if not silent:
print('A - ignoring', quadpole)
elif (quadpole[3] > quadpole[0]
and quadpole[3] < quadpole[1]):
if not silent:
print('B - ignoring', quadpole)
else:
measurements.append(quadpole)
else:
measurements.append(quadpole)
filtered = []
for quadpole in measurements:
if (not set(quadpole[0:2]).isdisjoint(set(quadpole[2:4]))):
if not silent:
print('Ignoring quadrupole because of ',
'repeated electrode use:', quadpole)
else:
filtered.append(quadpole)
self.add_to_configs(filtered)
return np.array(filtered) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:to_pg_scheme; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:container; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:positions; 10, None; 11, block; 11, 12; 11, 26; 11, 42; 11, 56; 11, 78; 11, 86; 11, 89; 11, 97; 11, 119; 11, 132; 11, 159; 11, 176; 12, if_statement; 12, 13; 12, 20; 13, boolean_operator:and; 13, 14; 13, 17; 14, comparison_operator:is; 14, 15; 14, 16; 15, identifier:container; 16, None; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:positions; 19, None; 20, block; 20, 21; 21, raise_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:Exception; 24, argument_list; 24, 25; 25, string:'electrode positions are required for BERT export'; 26, if_statement; 26, 27; 26, 36; 27, boolean_operator:and; 27, 28; 27, 31; 28, comparison_operator:is; 28, 29; 28, 30; 29, identifier:container; 30, None; 31, comparison_operator:is; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:container; 34, identifier:electrodes; 35, None; 36, block; 36, 37; 37, raise_statement; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:Exception; 40, argument_list; 40, 41; 41, string:'container does not contain electrode positions'; 42, if_statement; 42, 43; 42, 50; 43, boolean_operator:and; 43, 44; 43, 47; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:container; 46, None; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:positions; 49, None; 50, block; 50, 51; 51, raise_statement; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:Exception; 54, argument_list; 54, 55; 55, string:'only one of container OR positions must be provided'; 56, if_statement; 56, 57; 56, 60; 56, 69; 57, comparison_operator:is; 57, 58; 57, 59; 58, identifier:container; 59, None; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:elec_positions; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:container; 67, identifier:electrodes; 68, identifier:values; 69, elif_clause; 69, 70; 69, 73; 70, comparison_operator:is; 70, 71; 70, 72; 71, identifier:positions; 72, None; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:elec_positions; 77, identifier:positions; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:opt_import; 81, argument_list; 81, 82; 81, 83; 82, string:"pybert"; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:requiredFor; 85, string:""; 86, import_statement; 86, 87; 87, dotted_name; 87, 88; 88, identifier:pybert; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:data; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:pybert; 95, identifier:DataContainerERT; 96, argument_list; 97, for_statement; 97, 98; 97, 104; 97, 108; 98, pattern_list; 98, 99; 98, 100; 99, identifier:nr; 100, tuple_pattern; 100, 101; 100, 102; 100, 103; 101, identifier:x; 102, identifier:y; 103, identifier:z; 104, call; 104, 105; 104, 106; 105, identifier:enumerate; 106, argument_list; 106, 107; 107, identifier:elec_positions; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:data; 113, identifier:createSensor; 114, argument_list; 114, 115; 115, tuple; 115, 116; 115, 117; 115, 118; 116, identifier:x; 117, identifier:y; 118, identifier:z; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:data; 123, identifier:resize; 124, argument_list; 124, 125; 125, subscript; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:configs; 130, identifier:shape; 131, integer:0; 132, for_statement; 132, 133; 132, 136; 132, 140; 133, pattern_list; 133, 134; 133, 135; 134, identifier:index; 135, identifier:token; 136, call; 136, 137; 136, 138; 137, identifier:enumerate; 138, argument_list; 138, 139; 139, string:"abmn"; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:data; 145, identifier:set; 146, argument_list; 146, 147; 146, 148; 147, identifier:token; 148, call; 148, 149; 148, 158; 149, attribute; 149, 150; 149, 157; 150, subscript; 150, 151; 150, 154; 150, 156; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:configs; 154, slice; 154, 155; 155, colon; 156, identifier:index; 157, identifier:tolist; 158, argument_list; 159, for_statement; 159, 160; 159, 161; 159, 162; 160, identifier:token; 161, string:"abmn"; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:data; 167, identifier:set; 168, argument_list; 168, 169; 168, 170; 169, identifier:token; 170, binary_operator:-; 170, 171; 170, 175; 171, call; 171, 172; 171, 173; 172, identifier:data; 173, argument_list; 173, 174; 174, identifier:token; 175, integer:1; 176, return_statement; 176, 177; 177, identifier:data | def to_pg_scheme(self, container=None, positions=None):
if container is None and positions is None:
raise Exception('electrode positions are required for BERT export')
if container is not None and container.electrodes is None:
raise Exception('container does not contain electrode positions')
if container is not None and positions is not None:
raise Exception(
'only one of container OR positions must be provided')
if container is not None:
elec_positions = container.electrodes.values
elif positions is not None:
elec_positions = positions
opt_import("pybert", requiredFor="")
import pybert
data = pybert.DataContainerERT()
for nr, (x, y, z) in enumerate(elec_positions):
data.createSensor((x, y, z))
data.resize(self.configs.shape[0])
for index, token in enumerate("abmn"):
data.set(token, self.configs[:, index].tolist())
for token in "abmn":
data.set(token, data(token) - 1)
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:try_sending; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:msg; 6, identifier:timeout_secs; 7, identifier:max_attempts; 8, block; 8, 9; 8, 20; 8, 31; 8, 35; 9, if_statement; 9, 10; 9, 13; 10, comparison_operator:is; 10, 11; 10, 12; 11, identifier:timeout_secs; 12, None; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:timeout_secs; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:timeout; 20, if_statement; 20, 21; 20, 24; 21, comparison_operator:is; 21, 22; 21, 23; 22, identifier:max_attempts; 23, None; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:max_attempts; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:retry_count; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:attempts; 34, integer:0; 35, while_statement; 35, 36; 35, 39; 36, comparison_operator:<; 36, 37; 36, 38; 37, identifier:attempts; 38, identifier:max_attempts; 39, block; 39, 40; 39, 50; 39, 58; 39, 70; 39, 74; 39, 90; 40, if_statement; 40, 41; 40, 48; 41, comparison_operator:not; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:msg; 44, identifier:seq_num; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:message; 48, block; 48, 49; 49, return_statement; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:event; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:aio; 56, identifier:Event; 57, argument_list; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 69; 60, subscript; 60, 61; 60, 68; 61, subscript; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:message; 65, attribute; 65, 66; 65, 67; 66, identifier:msg; 67, identifier:seq_num; 68, integer:1; 69, identifier:event; 70, expression_statement; 70, 71; 71, augmented_assignment:+=; 71, 72; 71, 73; 72, identifier:attempts; 73, integer:1; 74, if_statement; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:transport; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:transport; 85, identifier:sendto; 86, argument_list; 86, 87; 87, attribute; 87, 88; 87, 89; 88, identifier:msg; 89, identifier:packed_message; 90, try_statement; 90, 91; 90, 108; 91, block; 91, 92; 91, 107; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:myresult; 95, await; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:aio; 99, identifier:wait_for; 100, argument_list; 100, 101; 100, 106; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:event; 104, identifier:wait; 105, argument_list; 106, identifier:timeout_secs; 107, break_statement; 108, except_clause; 108, 109; 108, 113; 109, as_pattern; 109, 110; 109, 111; 110, identifier:Exception; 111, as_pattern_target; 111, 112; 112, identifier:inst; 113, block; 113, 114; 114, if_statement; 114, 115; 114, 118; 115, comparison_operator:>=; 115, 116; 115, 117; 116, identifier:attempts; 117, identifier:max_attempts; 118, block; 118, 119; 118, 158; 119, if_statement; 119, 120; 119, 127; 120, comparison_operator:in; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:msg; 123, identifier:seq_num; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:message; 127, block; 127, 128; 127, 140; 127, 149; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:callb; 131, subscript; 131, 132; 131, 139; 132, subscript; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:message; 136, attribute; 136, 137; 136, 138; 137, identifier:msg; 138, identifier:seq_num; 139, integer:2; 140, if_statement; 140, 141; 140, 142; 141, identifier:callb; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 146; 145, identifier:callb; 146, argument_list; 146, 147; 146, 148; 147, identifier:self; 148, None; 149, delete_statement; 149, 150; 150, parenthesized_expression; 150, 151; 151, subscript; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:message; 155, attribute; 155, 156; 155, 157; 156, identifier:msg; 157, identifier:seq_num; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:unregister; 163, argument_list | async def try_sending(self,msg,timeout_secs, max_attempts):
if timeout_secs is None:
timeout_secs = self.timeout
if max_attempts is None:
max_attempts = self.retry_count
attempts = 0
while attempts < max_attempts:
if msg.seq_num not in self.message: return
event = aio.Event()
self.message[msg.seq_num][1]= event
attempts += 1
if self.transport:
self.transport.sendto(msg.packed_message)
try:
myresult = await aio.wait_for(event.wait(),timeout_secs)
break
except Exception as inst:
if attempts >= max_attempts:
if msg.seq_num in self.message:
callb = self.message[msg.seq_num][2]
if callb:
callb(self, None)
del(self.message[msg.seq_num])
self.unregister() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:apply_correction_factors; 3, parameters; 3, 4; 3, 5; 4, identifier:df; 5, identifier:correction_file; 6, block; 6, 7; 6, 158; 6, 184; 6, 210; 6, 222; 6, 230; 6, 243; 6, 406; 7, if_statement; 7, 8; 7, 15; 7, 34; 8, call; 8, 9; 8, 10; 9, identifier:isinstance; 10, argument_list; 10, 11; 10, 12; 11, identifier:correction_file; 12, tuple; 12, 13; 12, 14; 13, identifier:list; 14, identifier:tuple; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:corr_data_raw; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:np; 22, identifier:vstack; 23, argument_list; 23, 24; 24, list_comprehension; 24, 25; 24, 31; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:np; 28, identifier:loadtxt; 29, argument_list; 29, 30; 30, identifier:x; 31, for_in_clause; 31, 32; 31, 33; 32, identifier:x; 33, identifier:correction_file; 34, else_clause; 34, 35; 35, block; 35, 36; 35, 45; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:corr_data_raw; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:np; 42, identifier:loadtxt; 43, argument_list; 43, 44; 44, identifier:correction_file; 45, if_statement; 45, 46; 45, 53; 45, 138; 45, 151; 46, comparison_operator:==; 46, 47; 46, 52; 47, subscript; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:corr_data_raw; 50, identifier:shape; 51, integer:1; 52, integer:3; 53, block; 53, 54; 53, 70; 53, 86; 53, 102; 53, 118; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:A; 57, call; 57, 58; 57, 68; 58, attribute; 58, 59; 58, 67; 59, parenthesized_expression; 59, 60; 60, binary_operator:/; 60, 61; 60, 66; 61, subscript; 61, 62; 61, 63; 61, 65; 62, identifier:corr_data_raw; 63, slice; 63, 64; 64, colon; 65, integer:0; 66, float:1e4; 67, identifier:astype; 68, argument_list; 68, 69; 69, identifier:int; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:B; 73, call; 73, 74; 73, 84; 74, attribute; 74, 75; 74, 83; 75, parenthesized_expression; 75, 76; 76, binary_operator:%; 76, 77; 76, 82; 77, subscript; 77, 78; 77, 79; 77, 81; 78, identifier:corr_data_raw; 79, slice; 79, 80; 80, colon; 81, integer:0; 82, float:1e4; 83, identifier:astype; 84, argument_list; 84, 85; 85, identifier:int; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:M; 89, call; 89, 90; 89, 100; 90, attribute; 90, 91; 90, 99; 91, parenthesized_expression; 91, 92; 92, binary_operator:/; 92, 93; 92, 98; 93, subscript; 93, 94; 93, 95; 93, 97; 94, identifier:corr_data_raw; 95, slice; 95, 96; 96, colon; 97, integer:1; 98, float:1e4; 99, identifier:astype; 100, argument_list; 100, 101; 101, identifier:int; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:N; 105, call; 105, 106; 105, 116; 106, attribute; 106, 107; 106, 115; 107, parenthesized_expression; 107, 108; 108, binary_operator:%; 108, 109; 108, 114; 109, subscript; 109, 110; 109, 111; 109, 113; 110, identifier:corr_data_raw; 111, slice; 111, 112; 112, colon; 113, integer:1; 114, float:1e4; 115, identifier:astype; 116, argument_list; 116, 117; 117, identifier:int; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:corr_data; 121, attribute; 121, 122; 121, 137; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:np; 125, identifier:vstack; 126, argument_list; 126, 127; 127, tuple; 127, 128; 127, 129; 127, 130; 127, 131; 127, 132; 128, identifier:A; 129, identifier:B; 130, identifier:M; 131, identifier:N; 132, subscript; 132, 133; 132, 134; 132, 136; 133, identifier:corr_data_raw; 134, slice; 134, 135; 135, colon; 136, integer:2; 137, identifier:T; 138, elif_clause; 138, 139; 138, 146; 139, comparison_operator:==; 139, 140; 139, 145; 140, subscript; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:corr_data_raw; 143, identifier:shape; 144, integer:1; 145, integer:5; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:corr_data; 150, identifier:corr_data_raw; 151, else_clause; 151, 152; 152, block; 152, 153; 153, raise_statement; 153, 154; 154, call; 154, 155; 154, 156; 155, identifier:Exception; 156, argument_list; 156, 157; 157, string:'error'; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 168; 160, subscript; 160, 161; 160, 162; 160, 164; 161, identifier:corr_data; 162, slice; 162, 163; 163, colon; 164, slice; 164, 165; 164, 166; 164, 167; 165, integer:0; 166, colon; 167, integer:2; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:np; 171, identifier:sort; 172, argument_list; 172, 173; 172, 181; 173, subscript; 173, 174; 173, 175; 173, 177; 174, identifier:corr_data; 175, slice; 175, 176; 176, colon; 177, slice; 177, 178; 177, 179; 177, 180; 178, integer:0; 179, colon; 180, integer:2; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:axis; 183, integer:1; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 194; 186, subscript; 186, 187; 186, 188; 186, 190; 187, identifier:corr_data; 188, slice; 188, 189; 189, colon; 190, slice; 190, 191; 190, 192; 190, 193; 191, integer:2; 192, colon; 193, integer:4; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:np; 197, identifier:sort; 198, argument_list; 198, 199; 198, 207; 199, subscript; 199, 200; 199, 201; 199, 203; 200, identifier:corr_data; 201, slice; 201, 202; 202, colon; 203, slice; 203, 204; 203, 205; 203, 206; 204, integer:2; 205, colon; 206, integer:4; 207, keyword_argument; 207, 208; 207, 209; 208, identifier:axis; 209, integer:1; 210, if_statement; 210, 211; 210, 216; 211, comparison_operator:not; 211, 212; 211, 213; 212, string:'frequency'; 213, attribute; 213, 214; 213, 215; 214, identifier:df; 215, identifier:columns; 216, block; 216, 217; 217, raise_statement; 217, 218; 218, call; 218, 219; 218, 220; 219, identifier:Exception; 220, argument_list; 220, 221; 221, string:'No frequency data found. Are you sure this is a seit data set?'; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:df; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:df; 228, identifier:reset_index; 229, argument_list; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:gf; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:df; 236, identifier:groupby; 237, argument_list; 237, 238; 238, list:['a', 'b', 'm', 'n']; 238, 239; 238, 240; 238, 241; 238, 242; 239, string:'a'; 240, string:'b'; 241, string:'m'; 242, string:'n'; 243, for_statement; 243, 244; 243, 247; 243, 254; 244, pattern_list; 244, 245; 244, 246; 245, identifier:key; 246, identifier:item; 247, call; 247, 248; 247, 253; 248, attribute; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:gf; 251, identifier:indices; 252, identifier:items; 253, argument_list; 254, block; 254, 255; 254, 286; 254, 339; 254, 366; 254, 373; 254, 397; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:item_norm; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:np; 261, identifier:hstack; 262, argument_list; 262, 263; 263, tuple; 263, 264; 263, 275; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:np; 267, identifier:sort; 268, argument_list; 268, 269; 269, subscript; 269, 270; 269, 271; 270, identifier:key; 271, slice; 271, 272; 271, 273; 271, 274; 272, integer:0; 273, colon; 274, integer:2; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:np; 278, identifier:sort; 279, argument_list; 279, 280; 280, subscript; 280, 281; 280, 282; 281, identifier:key; 282, slice; 282, 283; 282, 284; 282, 285; 283, integer:2; 284, colon; 285, integer:4; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:index; 289, subscript; 289, 290; 289, 338; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:np; 293, identifier:where; 294, argument_list; 294, 295; 295, binary_operator:&; 295, 296; 295, 328; 296, binary_operator:&; 296, 297; 296, 318; 297, binary_operator:&; 297, 298; 297, 308; 298, parenthesized_expression; 298, 299; 299, comparison_operator:==; 299, 300; 299, 305; 300, subscript; 300, 301; 300, 302; 300, 304; 301, identifier:corr_data; 302, slice; 302, 303; 303, colon; 304, integer:0; 305, subscript; 305, 306; 305, 307; 306, identifier:item_norm; 307, integer:0; 308, parenthesized_expression; 308, 309; 309, comparison_operator:==; 309, 310; 309, 315; 310, subscript; 310, 311; 310, 312; 310, 314; 311, identifier:corr_data; 312, slice; 312, 313; 313, colon; 314, integer:1; 315, subscript; 315, 316; 315, 317; 316, identifier:item_norm; 317, integer:1; 318, parenthesized_expression; 318, 319; 319, comparison_operator:==; 319, 320; 319, 325; 320, subscript; 320, 321; 320, 322; 320, 324; 321, identifier:corr_data; 322, slice; 322, 323; 323, colon; 324, integer:2; 325, subscript; 325, 326; 325, 327; 326, identifier:item_norm; 327, integer:2; 328, parenthesized_expression; 328, 329; 329, comparison_operator:==; 329, 330; 329, 335; 330, subscript; 330, 331; 330, 332; 330, 334; 331, identifier:corr_data; 332, slice; 332, 333; 333, colon; 334, integer:3; 335, subscript; 335, 336; 335, 337; 336, identifier:item_norm; 337, integer:3; 338, integer:0; 339, if_statement; 339, 340; 339, 346; 340, comparison_operator:==; 340, 341; 340, 345; 341, call; 341, 342; 341, 343; 342, identifier:len; 343, argument_list; 343, 344; 344, identifier:index; 345, integer:0; 346, block; 346, 347; 346, 352; 346, 355; 346, 361; 347, expression_statement; 347, 348; 348, call; 348, 349; 348, 350; 349, identifier:print; 350, argument_list; 350, 351; 351, identifier:key; 352, import_statement; 352, 353; 353, dotted_name; 353, 354; 354, identifier:IPython; 355, expression_statement; 355, 356; 356, call; 356, 357; 356, 360; 357, attribute; 357, 358; 357, 359; 358, identifier:IPython; 359, identifier:embed; 360, argument_list; 361, raise_statement; 361, 362; 362, call; 362, 363; 362, 364; 363, identifier:Exception; 364, argument_list; 364, 365; 365, string:'No correction factor found for this configuration'; 366, expression_statement; 366, 367; 367, assignment; 367, 368; 367, 369; 368, identifier:factor; 369, subscript; 369, 370; 369, 371; 369, 372; 370, identifier:corr_data; 371, identifier:index; 372, integer:4; 373, for_statement; 373, 374; 373, 375; 373, 380; 374, identifier:col; 375, tuple; 375, 376; 375, 377; 375, 378; 375, 379; 376, string:'r'; 377, string:'Zt'; 378, string:'Vmn'; 379, string:'rho_a'; 380, block; 380, 381; 381, if_statement; 381, 382; 381, 387; 382, comparison_operator:in; 382, 383; 382, 384; 383, identifier:col; 384, attribute; 384, 385; 384, 386; 385, identifier:df; 386, identifier:columns; 387, block; 387, 388; 388, expression_statement; 388, 389; 389, augmented_assignment:*=; 389, 390; 389, 396; 390, subscript; 390, 391; 390, 394; 390, 395; 391, attribute; 391, 392; 391, 393; 392, identifier:df; 393, identifier:ix; 394, identifier:item; 395, identifier:col; 396, identifier:factor; 397, expression_statement; 397, 398; 398, assignment; 398, 399; 398, 405; 399, subscript; 399, 400; 399, 403; 399, 404; 400, attribute; 400, 401; 400, 402; 401, identifier:df; 402, identifier:ix; 403, identifier:item; 404, string:'corr_fac'; 405, identifier:factor; 406, return_statement; 406, 407; 407, expression_list; 407, 408; 407, 409; 408, identifier:df; 409, identifier:corr_data | def apply_correction_factors(df, correction_file):
if isinstance(correction_file, (list, tuple)):
corr_data_raw = np.vstack(
[np.loadtxt(x) for x in correction_file]
)
else:
corr_data_raw = np.loadtxt(correction_file)
if corr_data_raw.shape[1] == 3:
A = (corr_data_raw[:, 0] / 1e4).astype(int)
B = (corr_data_raw[:, 0] % 1e4).astype(int)
M = (corr_data_raw[:, 1] / 1e4).astype(int)
N = (corr_data_raw[:, 1] % 1e4).astype(int)
corr_data = np.vstack((A, B, M, N, corr_data_raw[:, 2])).T
elif corr_data_raw.shape[1] == 5:
corr_data = corr_data_raw
else:
raise Exception('error')
corr_data[:, 0:2] = np.sort(corr_data[:, 0:2], axis=1)
corr_data[:, 2:4] = np.sort(corr_data[:, 2:4], axis=1)
if 'frequency' not in df.columns:
raise Exception(
'No frequency data found. Are you sure this is a seit data set?'
)
df = df.reset_index()
gf = df.groupby(['a', 'b', 'm', 'n'])
for key, item in gf.indices.items():
item_norm = np.hstack((np.sort(key[0:2]), np.sort(key[2:4])))
index = np.where(
(corr_data[:, 0] == item_norm[0]) &
(corr_data[:, 1] == item_norm[1]) &
(corr_data[:, 2] == item_norm[2]) &
(corr_data[:, 3] == item_norm[3])
)[0]
if len(index) == 0:
print(key)
import IPython
IPython.embed()
raise Exception(
'No correction factor found for this configuration'
)
factor = corr_data[index, 4]
for col in ('r', 'Zt', 'Vmn', 'rho_a'):
if col in df.columns:
df.ix[item, col] *= factor
df.ix[item, 'corr_fac'] = factor
return df, corr_data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:alter_zero_tip_allowed_states; 3, parameters; 3, 4; 3, 5; 4, identifier:tree; 5, identifier:feature; 6, block; 6, 7; 6, 14; 6, 22; 6, 62; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:zero_parent2tips; 10, call; 10, 11; 10, 12; 11, identifier:defaultdict; 12, argument_list; 12, 13; 13, identifier:list; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:allowed_state_feature; 17, call; 17, 18; 17, 19; 18, identifier:get_personalized_feature_name; 19, argument_list; 19, 20; 19, 21; 20, identifier:feature; 21, identifier:ALLOWED_STATES; 22, for_statement; 22, 23; 22, 24; 22, 25; 23, identifier:tip; 24, identifier:tree; 25, block; 25, 26; 26, if_statement; 26, 27; 26, 32; 27, comparison_operator:==; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:tip; 30, identifier:dist; 31, integer:0; 32, block; 32, 33; 32, 42; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:state; 36, call; 36, 37; 36, 38; 37, identifier:getattr; 38, argument_list; 38, 39; 38, 40; 38, 41; 39, identifier:tip; 40, identifier:feature; 41, None; 42, if_statement; 42, 43; 42, 50; 43, boolean_operator:and; 43, 44; 43, 47; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:state; 46, None; 47, comparison_operator:!=; 47, 48; 47, 49; 48, identifier:state; 49, string:''; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 60; 53, attribute; 53, 54; 53, 59; 54, subscript; 54, 55; 54, 56; 55, identifier:zero_parent2tips; 56, attribute; 56, 57; 56, 58; 57, identifier:tip; 58, identifier:up; 59, identifier:append; 60, argument_list; 60, 61; 61, identifier:tip; 62, for_statement; 62, 63; 62, 66; 62, 71; 63, pattern_list; 63, 64; 63, 65; 64, identifier:parent; 65, identifier:zero_tips; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:zero_parent2tips; 69, identifier:items; 70, argument_list; 71, block; 71, 72; 71, 76; 71, 107; 71, 120; 71, 124; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:counts; 75, None; 76, for_statement; 76, 77; 76, 78; 76, 79; 77, identifier:tip; 78, identifier:zero_tips; 79, block; 79, 80; 80, if_statement; 80, 81; 80, 84; 80, 97; 81, comparison_operator:is; 81, 82; 81, 83; 82, identifier:counts; 83, None; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:counts; 88, call; 88, 89; 88, 96; 89, attribute; 89, 90; 89, 95; 90, call; 90, 91; 90, 92; 91, identifier:getattr; 92, argument_list; 92, 93; 92, 94; 93, identifier:tip; 94, identifier:allowed_state_feature; 95, identifier:copy; 96, argument_list; 97, else_clause; 97, 98; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, augmented_assignment:+=; 100, 101; 100, 102; 101, identifier:counts; 102, call; 102, 103; 102, 104; 103, identifier:getattr; 104, argument_list; 104, 105; 104, 106; 105, identifier:tip; 106, identifier:allowed_state_feature; 107, if_statement; 107, 108; 107, 118; 108, comparison_operator:==; 108, 109; 108, 114; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:counts; 112, identifier:max; 113, argument_list; 114, call; 114, 115; 114, 116; 115, identifier:len; 116, argument_list; 116, 117; 117, identifier:zero_tips; 118, block; 118, 119; 119, continue_statement; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:allowed_states; 123, None; 124, for_statement; 124, 125; 124, 126; 124, 127; 125, identifier:tip; 126, identifier:zero_tips; 127, block; 127, 128; 127, 166; 128, if_statement; 128, 129; 128, 132; 128, 145; 129, comparison_operator:is; 129, 130; 129, 131; 130, identifier:allowed_states; 131, None; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:allowed_states; 136, call; 136, 137; 136, 144; 137, attribute; 137, 138; 137, 143; 138, call; 138, 139; 138, 140; 139, identifier:getattr; 140, argument_list; 140, 141; 140, 142; 141, identifier:tip; 142, identifier:allowed_state_feature; 143, identifier:copy; 144, argument_list; 145, else_clause; 145, 146; 146, block; 146, 147; 146, 155; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:tip_allowed_states; 150, call; 150, 151; 150, 152; 151, identifier:getattr; 152, argument_list; 152, 153; 152, 154; 153, identifier:tip; 154, identifier:allowed_state_feature; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 165; 157, subscript; 157, 158; 157, 159; 158, identifier:allowed_states; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:np; 162, identifier:nonzero; 163, argument_list; 163, 164; 164, identifier:tip_allowed_states; 165, integer:1; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:tip; 170, identifier:add_feature; 171, argument_list; 171, 172; 171, 173; 172, identifier:allowed_state_feature; 173, identifier:allowed_states | def alter_zero_tip_allowed_states(tree, feature):
zero_parent2tips = defaultdict(list)
allowed_state_feature = get_personalized_feature_name(feature, ALLOWED_STATES)
for tip in tree:
if tip.dist == 0:
state = getattr(tip, feature, None)
if state is not None and state != '':
zero_parent2tips[tip.up].append(tip)
for parent, zero_tips in zero_parent2tips.items():
counts = None
for tip in zero_tips:
if counts is None:
counts = getattr(tip, allowed_state_feature).copy()
else:
counts += getattr(tip, allowed_state_feature)
if counts.max() == len(zero_tips):
continue
allowed_states = None
for tip in zero_tips:
if allowed_states is None:
allowed_states = getattr(tip, allowed_state_feature).copy()
else:
tip_allowed_states = getattr(tip, allowed_state_feature)
allowed_states[np.nonzero(tip_allowed_states)] = 1
tip.add_feature(allowed_state_feature, allowed_states) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:choose_ancestral_states_mppa; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:tree; 5, identifier:feature; 6, identifier:states; 7, default_parameter; 7, 8; 7, 9; 8, identifier:force_joint; 9, True; 10, block; 10, 11; 10, 19; 10, 27; 10, 35; 10, 42; 10, 52; 10, 56; 10, 60; 10, 64; 10, 326; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:lh_feature; 14, call; 14, 15; 14, 16; 15, identifier:get_personalized_feature_name; 16, argument_list; 16, 17; 16, 18; 17, identifier:feature; 18, identifier:LH; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:allowed_state_feature; 22, call; 22, 23; 22, 24; 23, identifier:get_personalized_feature_name; 24, argument_list; 24, 25; 24, 26; 25, identifier:feature; 26, identifier:ALLOWED_STATES; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:joint_state_feature; 30, call; 30, 31; 30, 32; 31, identifier:get_personalized_feature_name; 32, argument_list; 32, 33; 32, 34; 33, identifier:feature; 34, identifier:JOINT_STATE; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:n; 38, call; 38, 39; 38, 40; 39, identifier:len; 40, argument_list; 40, 41; 41, identifier:states; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, pattern_list; 44, 45; 44, 46; 45, identifier:_; 46, identifier:state2array; 47, call; 47, 48; 47, 49; 48, identifier:get_state2allowed_states; 49, argument_list; 49, 50; 49, 51; 50, identifier:states; 51, False; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:num_scenarios; 55, integer:1; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:unresolved_nodes; 59, integer:0; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:num_states; 63, integer:0; 64, for_statement; 64, 65; 64, 66; 64, 71; 65, identifier:node; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:tree; 69, identifier:traverse; 70, argument_list; 71, block; 71, 72; 71, 80; 71, 90; 71, 141; 71, 145; 71, 151; 71, 210; 71, 214; 71, 218; 71, 276; 71, 318; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:marginal_likelihoods; 75, call; 75, 76; 75, 77; 76, identifier:getattr; 77, argument_list; 77, 78; 77, 79; 78, identifier:node; 79, identifier:lh_feature; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:marginal_probs; 83, binary_operator:/; 83, 84; 83, 85; 84, identifier:marginal_likelihoods; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:marginal_likelihoods; 88, identifier:sum; 89, argument_list; 90, if_statement; 90, 91; 90, 92; 90, 130; 91, identifier:force_joint; 92, block; 92, 93; 92, 101; 92, 107; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:joint_index; 96, call; 96, 97; 96, 98; 97, identifier:getattr; 98, argument_list; 98, 99; 98, 100; 99, identifier:node; 100, identifier:joint_state_feature; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:joint_prob; 104, subscript; 104, 105; 104, 106; 105, identifier:marginal_probs; 106, identifier:joint_index; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:marginal_probs; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:np; 113, identifier:hstack; 114, argument_list; 114, 115; 115, tuple; 115, 116; 115, 128; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:np; 119, identifier:sort; 120, argument_list; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:np; 124, identifier:delete; 125, argument_list; 125, 126; 125, 127; 126, identifier:marginal_probs; 127, identifier:joint_index; 128, list:[joint_prob]; 128, 129; 129, identifier:joint_prob; 130, else_clause; 130, 131; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:marginal_probs; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:np; 138, identifier:sort; 139, argument_list; 139, 140; 140, identifier:marginal_probs; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:best_k; 144, identifier:n; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:best_correstion; 148, attribute; 148, 149; 148, 150; 149, identifier:np; 150, identifier:inf; 151, for_statement; 151, 152; 151, 153; 151, 160; 152, identifier:k; 153, call; 153, 154; 153, 155; 154, identifier:range; 155, argument_list; 155, 156; 155, 157; 156, integer:1; 157, binary_operator:+; 157, 158; 157, 159; 158, identifier:n; 159, integer:1; 160, block; 160, 161; 160, 188; 160, 197; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:correction; 164, binary_operator:-; 164, 165; 164, 187; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:np; 168, identifier:hstack; 169, argument_list; 169, 170; 170, tuple; 170, 171; 170, 179; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:np; 174, identifier:zeros; 175, argument_list; 175, 176; 176, binary_operator:-; 176, 177; 176, 178; 177, identifier:n; 178, identifier:k; 179, binary_operator:/; 179, 180; 179, 186; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:np; 183, identifier:ones; 184, argument_list; 184, 185; 185, identifier:k; 186, identifier:k; 187, identifier:marginal_probs; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:correction; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:correction; 194, identifier:dot; 195, argument_list; 195, 196; 196, identifier:correction; 197, if_statement; 197, 198; 197, 201; 198, comparison_operator:<; 198, 199; 198, 200; 199, identifier:correction; 200, identifier:best_correstion; 201, block; 201, 202; 201, 206; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:best_correstion; 205, identifier:correction; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:best_k; 209, identifier:k; 210, expression_statement; 210, 211; 211, augmented_assignment:*=; 211, 212; 211, 213; 212, identifier:num_scenarios; 213, identifier:best_k; 214, expression_statement; 214, 215; 215, augmented_assignment:+=; 215, 216; 215, 217; 216, identifier:num_states; 217, identifier:best_k; 218, if_statement; 218, 219; 218, 220; 218, 251; 219, identifier:force_joint; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:indices_selected; 224, subscript; 224, 225; 224, 248; 225, call; 225, 226; 225, 227; 226, identifier:sorted; 227, argument_list; 227, 228; 227, 232; 228, call; 228, 229; 228, 230; 229, identifier:range; 230, argument_list; 230, 231; 231, identifier:n; 232, keyword_argument; 232, 233; 232, 234; 233, identifier:key; 234, lambda; 234, 235; 234, 237; 235, lambda_parameters; 235, 236; 236, identifier:_; 237, tuple; 237, 238; 237, 244; 238, conditional_expression:if; 238, 239; 238, 240; 238, 243; 239, integer:0; 240, comparison_operator:==; 240, 241; 240, 242; 241, identifier:n; 242, identifier:joint_index; 243, integer:1; 244, unary_operator:-; 244, 245; 245, subscript; 245, 246; 245, 247; 246, identifier:marginal_likelihoods; 247, identifier:_; 248, slice; 248, 249; 248, 250; 249, colon; 250, identifier:best_k; 251, else_clause; 251, 252; 252, block; 252, 253; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:indices_selected; 256, subscript; 256, 257; 256, 273; 257, call; 257, 258; 257, 259; 258, identifier:sorted; 259, argument_list; 259, 260; 259, 264; 260, call; 260, 261; 260, 262; 261, identifier:range; 262, argument_list; 262, 263; 263, identifier:n; 264, keyword_argument; 264, 265; 264, 266; 265, identifier:key; 266, lambda; 266, 267; 266, 269; 267, lambda_parameters; 267, 268; 268, identifier:_; 269, unary_operator:-; 269, 270; 270, subscript; 270, 271; 270, 272; 271, identifier:marginal_likelihoods; 272, identifier:_; 273, slice; 273, 274; 273, 275; 274, colon; 275, identifier:best_k; 276, if_statement; 276, 277; 276, 280; 276, 289; 277, comparison_operator:==; 277, 278; 277, 279; 278, identifier:best_k; 279, integer:1; 280, block; 280, 281; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:allowed_states; 284, subscript; 284, 285; 284, 286; 285, identifier:state2array; 286, subscript; 286, 287; 286, 288; 287, identifier:indices_selected; 288, integer:0; 289, else_clause; 289, 290; 290, block; 290, 291; 290, 308; 290, 314; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:allowed_states; 294, call; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:np; 297, identifier:zeros; 298, argument_list; 298, 299; 298, 303; 299, call; 299, 300; 299, 301; 300, identifier:len; 301, argument_list; 301, 302; 302, identifier:states; 303, keyword_argument; 303, 304; 303, 305; 304, identifier:dtype; 305, attribute; 305, 306; 305, 307; 306, identifier:np; 307, identifier:int; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 313; 310, subscript; 310, 311; 310, 312; 311, identifier:allowed_states; 312, identifier:indices_selected; 313, integer:1; 314, expression_statement; 314, 315; 315, augmented_assignment:+=; 315, 316; 315, 317; 316, identifier:unresolved_nodes; 317, integer:1; 318, expression_statement; 318, 319; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:node; 322, identifier:add_feature; 323, argument_list; 323, 324; 323, 325; 324, identifier:allowed_state_feature; 325, identifier:allowed_states; 326, return_statement; 326, 327; 327, expression_list; 327, 328; 327, 329; 327, 330; 328, identifier:num_scenarios; 329, identifier:unresolved_nodes; 330, identifier:num_states | def choose_ancestral_states_mppa(tree, feature, states, force_joint=True):
lh_feature = get_personalized_feature_name(feature, LH)
allowed_state_feature = get_personalized_feature_name(feature, ALLOWED_STATES)
joint_state_feature = get_personalized_feature_name(feature, JOINT_STATE)
n = len(states)
_, state2array = get_state2allowed_states(states, False)
num_scenarios = 1
unresolved_nodes = 0
num_states = 0
for node in tree.traverse():
marginal_likelihoods = getattr(node, lh_feature)
marginal_probs = marginal_likelihoods / marginal_likelihoods.sum()
if force_joint:
joint_index = getattr(node, joint_state_feature)
joint_prob = marginal_probs[joint_index]
marginal_probs = np.hstack((np.sort(np.delete(marginal_probs, joint_index)), [joint_prob]))
else:
marginal_probs = np.sort(marginal_probs)
best_k = n
best_correstion = np.inf
for k in range(1, n + 1):
correction = np.hstack((np.zeros(n - k), np.ones(k) / k)) - marginal_probs
correction = correction.dot(correction)
if correction < best_correstion:
best_correstion = correction
best_k = k
num_scenarios *= best_k
num_states += best_k
if force_joint:
indices_selected = sorted(range(n),
key=lambda _: (0 if n == joint_index else 1, -marginal_likelihoods[_]))[:best_k]
else:
indices_selected = sorted(range(n), key=lambda _: -marginal_likelihoods[_])[:best_k]
if best_k == 1:
allowed_states = state2array[indices_selected[0]]
else:
allowed_states = np.zeros(len(states), dtype=np.int)
allowed_states[indices_selected] = 1
unresolved_nodes += 1
node.add_feature(allowed_state_feature, allowed_states)
return num_scenarios, unresolved_nodes, num_states |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:parse; 3, parameters; 3, 4; 4, identifier:text; 5, block; 5, 6; 5, 18; 5, 22; 5, 26; 5, 209; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:fixed_text; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:validate; 12, identifier:fix_string_case; 13, argument_list; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:utf; 16, argument_list; 16, 17; 17, identifier:text; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:output; 21, list:[]; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:cur_end; 25, integer:0; 26, for_statement; 26, 27; 26, 30; 26, 34; 27, pattern_list; 27, 28; 27, 29; 28, identifier:cur; 29, identifier:i; 30, call; 30, 31; 30, 32; 31, identifier:enumerate; 32, argument_list; 32, 33; 33, identifier:fixed_text; 34, block; 34, 35; 34, 57; 34, 64; 35, try_statement; 35, 36; 35, 44; 35, 51; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:i; 41, identifier:encode; 42, argument_list; 42, 43; 43, string:'utf-8'; 44, except_clause; 44, 45; 44, 46; 45, identifier:UnicodeDecodeError; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:uni_pass; 50, False; 51, else_clause; 51, 52; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:uni_pass; 56, True; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:match; 60, dictionary; 60, 61; 61, pair; 61, 62; 61, 63; 62, string:'matched'; 63, False; 64, if_statement; 64, 65; 64, 67; 64, 81; 65, not_operator; 65, 66; 66, identifier:uni_pass; 67, block; 67, 68; 67, 74; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:cur_end; 71, binary_operator:+; 71, 72; 71, 73; 72, identifier:cur; 73, integer:1; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:output; 78, identifier:append; 79, argument_list; 79, 80; 80, identifier:i; 81, elif_clause; 81, 82; 81, 87; 82, boolean_operator:and; 82, 83; 82, 86; 83, comparison_operator:>=; 83, 84; 83, 85; 84, identifier:cur; 85, identifier:cur_end; 86, identifier:uni_pass; 87, block; 87, 88; 87, 96; 87, 190; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:match; 91, call; 91, 92; 91, 93; 92, identifier:match_non_rule_patterns; 93, argument_list; 93, 94; 93, 95; 94, identifier:fixed_text; 95, identifier:cur; 96, if_statement; 96, 97; 96, 100; 96, 121; 97, subscript; 97, 98; 97, 99; 98, identifier:match; 99, string:"matched"; 100, block; 100, 101; 100, 110; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:output; 105, identifier:append; 106, argument_list; 106, 107; 107, subscript; 107, 108; 107, 109; 108, identifier:match; 109, string:"replaced"; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:cur_end; 113, binary_operator:+; 113, 114; 113, 115; 114, identifier:cur; 115, call; 115, 116; 115, 117; 116, identifier:len; 117, argument_list; 117, 118; 118, subscript; 118, 119; 118, 120; 119, identifier:match; 120, string:"found"; 121, else_clause; 121, 122; 122, block; 122, 123; 122, 131; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:match; 126, call; 126, 127; 126, 128; 127, identifier:match_rule_patterns; 128, argument_list; 128, 129; 128, 130; 129, identifier:fixed_text; 130, identifier:cur; 131, if_statement; 131, 132; 131, 135; 132, subscript; 132, 133; 132, 134; 133, identifier:match; 134, string:"matched"; 135, block; 135, 136; 135, 147; 135, 167; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:cur_end; 139, binary_operator:+; 139, 140; 139, 141; 140, identifier:cur; 141, call; 141, 142; 141, 143; 142, identifier:len; 143, argument_list; 143, 144; 144, subscript; 144, 145; 144, 146; 145, identifier:match; 146, string:"found"; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:replaced; 150, call; 150, 151; 150, 152; 151, identifier:process_rules; 152, argument_list; 152, 153; 152, 158; 152, 161; 152, 164; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:rules; 155, subscript; 155, 156; 155, 157; 156, identifier:match; 157, string:"rules"; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:fixed_text; 160, identifier:fixed_text; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:cur; 163, identifier:cur; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:cur_end; 166, identifier:cur_end; 167, if_statement; 167, 168; 167, 171; 167, 179; 168, comparison_operator:is; 168, 169; 168, 170; 169, identifier:replaced; 170, None; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:output; 176, identifier:append; 177, argument_list; 177, 178; 178, identifier:replaced; 179, else_clause; 179, 180; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:output; 185, identifier:append; 186, argument_list; 186, 187; 187, subscript; 187, 188; 187, 189; 188, identifier:match; 189, string:"replaced"; 190, if_statement; 190, 191; 190, 195; 191, not_operator; 191, 192; 192, subscript; 192, 193; 192, 194; 193, identifier:match; 194, string:"matched"; 195, block; 195, 196; 195, 202; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:cur_end; 199, binary_operator:+; 199, 200; 199, 201; 200, identifier:cur; 201, integer:1; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:output; 206, identifier:append; 207, argument_list; 207, 208; 208, identifier:i; 209, return_statement; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, string:''; 213, identifier:join; 214, argument_list; 214, 215; 215, identifier:output | def parse(text):
fixed_text = validate.fix_string_case(utf(text))
output = []
cur_end = 0
for cur, i in enumerate(fixed_text):
try:
i.encode('utf-8')
except UnicodeDecodeError:
uni_pass = False
else:
uni_pass = True
match = {'matched': False}
if not uni_pass:
cur_end = cur + 1
output.append(i)
elif cur >= cur_end and uni_pass:
match = match_non_rule_patterns(fixed_text, cur)
if match["matched"]:
output.append(match["replaced"])
cur_end = cur + len(match["found"])
else:
match = match_rule_patterns(fixed_text, cur)
if match["matched"]:
cur_end = cur + len(match["found"])
replaced = process_rules(rules = match["rules"],
fixed_text = fixed_text,
cur = cur, cur_end = cur_end)
if replaced is not None:
output.append(replaced)
else:
output.append(match["replaced"])
if not match["matched"]:
cur_end = cur + 1
output.append(i)
return ''.join(output) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:process_match; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:match; 5, identifier:fixed_text; 6, identifier:cur; 7, identifier:cur_end; 8, block; 8, 9; 8, 13; 8, 32; 8, 68; 8, 280; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:replace; 12, True; 13, if_statement; 13, 14; 13, 19; 13, 26; 14, comparison_operator:==; 14, 15; 14, 18; 15, subscript; 15, 16; 15, 17; 16, identifier:match; 17, string:'type'; 18, string:'prefix'; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:chk; 23, binary_operator:-; 23, 24; 23, 25; 24, identifier:cur; 25, integer:1; 26, else_clause; 26, 27; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:chk; 31, identifier:cur_end; 32, if_statement; 32, 33; 32, 41; 32, 56; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, subscript; 35, 36; 35, 37; 36, identifier:match; 37, string:'scope'; 38, identifier:startswith; 39, argument_list; 39, 40; 40, string:'!'; 41, block; 41, 42; 41, 52; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:scope; 45, subscript; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:match; 48, string:'scope'; 49, slice; 49, 50; 49, 51; 50, integer:1; 51, colon; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:negative; 55, True; 56, else_clause; 56, 57; 57, block; 57, 58; 57, 64; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:scope; 61, subscript; 61, 62; 61, 63; 62, identifier:match; 63, string:'scope'; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:negative; 67, False; 68, if_statement; 68, 69; 68, 72; 68, 117; 68, 167; 68, 217; 69, comparison_operator:==; 69, 70; 69, 71; 70, identifier:scope; 71, string:'punctuation'; 72, block; 72, 73; 73, if_statement; 73, 74; 73, 112; 74, parenthesized_expression; 74, 75; 75, not_operator; 75, 76; 76, binary_operator:^; 76, 77; 76, 111; 77, parenthesized_expression; 77, 78; 78, boolean_operator:or; 78, 79; 78, 103; 79, boolean_operator:or; 79, 80; 79, 90; 80, parenthesized_expression; 80, 81; 81, boolean_operator:and; 81, 82; 81, 85; 82, comparison_operator:<; 82, 83; 82, 84; 83, identifier:chk; 84, integer:0; 85, comparison_operator:==; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:match; 88, string:'type'; 89, string:'prefix'; 90, parenthesized_expression; 90, 91; 91, boolean_operator:and; 91, 92; 91, 98; 92, comparison_operator:>=; 92, 93; 92, 94; 93, identifier:chk; 94, call; 94, 95; 94, 96; 95, identifier:len; 96, argument_list; 96, 97; 97, identifier:fixed_text; 98, comparison_operator:==; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:match; 101, string:'type'; 102, string:'suffix'; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:validate; 106, identifier:is_punctuation; 107, argument_list; 107, 108; 108, subscript; 108, 109; 108, 110; 109, identifier:fixed_text; 110, identifier:chk; 111, identifier:negative; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:replace; 116, False; 117, elif_clause; 117, 118; 117, 121; 118, comparison_operator:==; 118, 119; 118, 120; 119, identifier:scope; 120, string:'vowel'; 121, block; 121, 122; 122, if_statement; 122, 123; 122, 162; 123, parenthesized_expression; 123, 124; 124, not_operator; 124, 125; 125, binary_operator:^; 125, 126; 125, 161; 126, parenthesized_expression; 126, 127; 127, boolean_operator:and; 127, 128; 127, 153; 128, parenthesized_expression; 128, 129; 129, boolean_operator:or; 129, 130; 129, 140; 130, parenthesized_expression; 130, 131; 131, boolean_operator:and; 131, 132; 131, 135; 132, comparison_operator:>=; 132, 133; 132, 134; 133, identifier:chk; 134, integer:0; 135, comparison_operator:==; 135, 136; 135, 139; 136, subscript; 136, 137; 136, 138; 137, identifier:match; 138, string:'type'; 139, string:'prefix'; 140, parenthesized_expression; 140, 141; 141, boolean_operator:and; 141, 142; 141, 148; 142, comparison_operator:<; 142, 143; 142, 144; 143, identifier:chk; 144, call; 144, 145; 144, 146; 145, identifier:len; 146, argument_list; 146, 147; 147, identifier:fixed_text; 148, comparison_operator:==; 148, 149; 148, 152; 149, subscript; 149, 150; 149, 151; 150, identifier:match; 151, string:'type'; 152, string:'suffix'; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:validate; 156, identifier:is_vowel; 157, argument_list; 157, 158; 158, subscript; 158, 159; 158, 160; 159, identifier:fixed_text; 160, identifier:chk; 161, identifier:negative; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:replace; 166, False; 167, elif_clause; 167, 168; 167, 171; 168, comparison_operator:==; 168, 169; 168, 170; 169, identifier:scope; 170, string:'consonant'; 171, block; 171, 172; 172, if_statement; 172, 173; 172, 212; 173, parenthesized_expression; 173, 174; 174, not_operator; 174, 175; 175, binary_operator:^; 175, 176; 175, 211; 176, parenthesized_expression; 176, 177; 177, boolean_operator:and; 177, 178; 177, 203; 178, parenthesized_expression; 178, 179; 179, boolean_operator:or; 179, 180; 179, 190; 180, parenthesized_expression; 180, 181; 181, boolean_operator:and; 181, 182; 181, 185; 182, comparison_operator:>=; 182, 183; 182, 184; 183, identifier:chk; 184, integer:0; 185, comparison_operator:==; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:match; 188, string:'type'; 189, string:'prefix'; 190, parenthesized_expression; 190, 191; 191, boolean_operator:and; 191, 192; 191, 198; 192, comparison_operator:<; 192, 193; 192, 194; 193, identifier:chk; 194, call; 194, 195; 194, 196; 195, identifier:len; 196, argument_list; 196, 197; 197, identifier:fixed_text; 198, comparison_operator:==; 198, 199; 198, 202; 199, subscript; 199, 200; 199, 201; 200, identifier:match; 201, string:'type'; 202, string:'suffix'; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:validate; 206, identifier:is_consonant; 207, argument_list; 207, 208; 208, subscript; 208, 209; 208, 210; 209, identifier:fixed_text; 210, identifier:chk; 211, identifier:negative; 212, block; 212, 213; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:replace; 216, False; 217, elif_clause; 217, 218; 217, 221; 218, comparison_operator:==; 218, 219; 218, 220; 219, identifier:scope; 220, string:'exact'; 221, block; 221, 222; 221, 261; 222, if_statement; 222, 223; 222, 228; 222, 244; 223, comparison_operator:==; 223, 224; 223, 227; 224, subscript; 224, 225; 224, 226; 225, identifier:match; 226, string:'type'; 227, string:'prefix'; 228, block; 228, 229; 228, 240; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:exact_start; 232, binary_operator:-; 232, 233; 232, 234; 233, identifier:cur; 234, call; 234, 235; 234, 236; 235, identifier:len; 236, argument_list; 236, 237; 237, subscript; 237, 238; 237, 239; 238, identifier:match; 239, string:'value'; 240, expression_statement; 240, 241; 241, assignment; 241, 242; 241, 243; 242, identifier:exact_end; 243, identifier:cur; 244, else_clause; 244, 245; 245, block; 245, 246; 245, 250; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:exact_start; 249, identifier:cur_end; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:exact_end; 253, binary_operator:+; 253, 254; 253, 255; 254, identifier:cur_end; 255, call; 255, 256; 255, 257; 256, identifier:len; 257, argument_list; 257, 258; 258, subscript; 258, 259; 258, 260; 259, identifier:match; 260, string:'value'; 261, if_statement; 261, 262; 261, 275; 262, not_operator; 262, 263; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:validate; 266, identifier:is_exact; 267, argument_list; 267, 268; 267, 271; 267, 272; 267, 273; 267, 274; 268, subscript; 268, 269; 268, 270; 269, identifier:match; 270, string:'value'; 271, identifier:fixed_text; 272, identifier:exact_start; 273, identifier:exact_end; 274, identifier:negative; 275, block; 275, 276; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:replace; 279, False; 280, return_statement; 280, 281; 281, identifier:replace | def process_match(match, fixed_text, cur, cur_end):
replace = True
if match['type'] == 'prefix':
chk = cur - 1
else:
chk = cur_end
if match['scope'].startswith('!'):
scope = match['scope'][1:]
negative = True
else:
scope = match['scope']
negative = False
if scope == 'punctuation':
if (not ((chk < 0 and match['type'] == 'prefix') or
(chk >= len(fixed_text) and match['type'] == 'suffix') or
validate.is_punctuation(fixed_text[chk]))
^ negative):
replace = False
elif scope == 'vowel':
if (not (((chk >= 0 and match['type'] == 'prefix') or
(chk < len(fixed_text) and match['type'] == 'suffix'))
and validate.is_vowel(fixed_text[chk]))
^ negative):
replace = False
elif scope == 'consonant':
if (not (((chk >= 0 and match['type'] == 'prefix') or
(chk < len(fixed_text) and match['type'] == 'suffix'))
and validate.is_consonant(fixed_text[chk]))
^ negative):
replace = False
elif scope == 'exact':
if match['type'] == 'prefix':
exact_start = cur - len(match['value'])
exact_end = cur
else:
exact_start = cur_end
exact_end = cur_end + len(match['value'])
if not validate.is_exact(match['value'], fixed_text, exact_start,
exact_end, negative):
replace = False
return replace |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:scatter_norrec; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:filename; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:individual; 10, False; 11, block; 11, 12; 11, 22; 11, 26; 11, 30; 11, 63; 11, 74; 11, 90; 11, 142; 11, 292; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:std_diff_labels; 15, dictionary; 15, 16; 15, 19; 16, pair; 16, 17; 16, 18; 17, string:'r'; 18, string:'rdiff'; 19, pair; 19, 20; 19, 21; 20, string:'rpha'; 21, string:'rphadiff'; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:diff_labels; 25, identifier:std_diff_labels; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:labels_to_use; 29, dictionary; 30, for_statement; 30, 31; 30, 34; 30, 39; 31, pattern_list; 31, 32; 31, 33; 32, identifier:key; 33, identifier:item; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:diff_labels; 37, identifier:items; 38, argument_list; 39, block; 39, 40; 40, if_statement; 40, 41; 40, 56; 41, boolean_operator:and; 41, 42; 41, 49; 42, comparison_operator:in; 42, 43; 42, 44; 43, identifier:key; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:data; 48, identifier:columns; 49, comparison_operator:in; 49, 50; 49, 51; 50, identifier:item; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:data; 55, identifier:columns; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 62; 59, subscript; 59, 60; 59, 61; 60, identifier:labels_to_use; 61, identifier:key; 62, identifier:item; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:g_freq; 66, call; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:data; 71, identifier:groupby; 72, argument_list; 72, 73; 73, string:'frequency'; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:frequencies; 77, call; 77, 78; 77, 79; 78, identifier:list; 79, argument_list; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:sorted; 82, argument_list; 82, 83; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:g_freq; 87, identifier:groups; 88, identifier:keys; 89, argument_list; 90, if_statement; 90, 91; 90, 92; 90, 101; 91, identifier:individual; 92, block; 92, 93; 92, 97; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:figures; 96, dictionary; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:axes_all; 100, dictionary; 101, else_clause; 101, 102; 102, block; 102, 103; 102, 114; 102, 121; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:Nx; 106, call; 106, 107; 106, 108; 107, identifier:len; 108, argument_list; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:labels_to_use; 112, identifier:keys; 113, argument_list; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:Ny; 117, call; 117, 118; 117, 119; 118, identifier:len; 119, argument_list; 119, 120; 120, identifier:frequencies; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 126; 123, pattern_list; 123, 124; 123, 125; 124, identifier:fig; 125, identifier:axes; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:plt; 129, identifier:subplots; 130, argument_list; 130, 131; 130, 132; 130, 133; 131, identifier:Ny; 132, identifier:Nx; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:figsize; 135, tuple; 135, 136; 135, 139; 136, binary_operator:*; 136, 137; 136, 138; 137, identifier:Nx; 138, float:2.5; 139, binary_operator:*; 139, 140; 139, 141; 140, identifier:Ny; 141, float:2.5; 142, for_statement; 142, 143; 142, 148; 142, 152; 143, pattern_list; 143, 144; 143, 145; 144, identifier:row; 145, tuple_pattern; 145, 146; 145, 147; 146, identifier:name; 147, identifier:item; 148, call; 148, 149; 148, 150; 149, identifier:enumerate; 150, argument_list; 150, 151; 151, identifier:g_freq; 152, block; 152, 153; 152, 187; 152, 271; 153, if_statement; 153, 154; 153, 155; 153, 177; 154, identifier:individual; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 161; 158, pattern_list; 158, 159; 158, 160; 159, identifier:fig; 160, identifier:axes_row; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:plt; 164, identifier:subplots; 165, argument_list; 165, 166; 165, 167; 165, 168; 166, integer:1; 167, integer:2; 168, keyword_argument; 168, 169; 168, 170; 169, identifier:figsize; 170, tuple; 170, 171; 170, 174; 171, binary_operator:/; 171, 172; 171, 173; 172, integer:16; 173, float:2.54; 174, binary_operator:/; 174, 175; 174, 176; 175, integer:6; 176, float:2.54; 177, else_clause; 177, 178; 178, block; 178, 179; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:axes_row; 182, subscript; 182, 183; 182, 184; 182, 185; 183, identifier:axes; 184, identifier:row; 185, slice; 185, 186; 186, colon; 187, for_statement; 187, 188; 187, 193; 187, 204; 188, pattern_list; 188, 189; 188, 190; 189, identifier:col_nr; 190, tuple_pattern; 190, 191; 190, 192; 191, identifier:key; 192, identifier:diff_column; 193, call; 193, 194; 193, 195; 194, identifier:enumerate; 195, argument_list; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:sorted; 198, argument_list; 198, 199; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:labels_to_use; 202, identifier:items; 203, argument_list; 204, block; 204, 205; 204, 224; 204, 230; 204, 242; 204, 249; 204, 256; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:indices; 208, subscript; 208, 209; 208, 223; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:np; 212, identifier:where; 213, argument_list; 213, 214; 214, unary_operator:~; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:np; 218, identifier:isnan; 219, argument_list; 219, 220; 220, subscript; 220, 221; 220, 222; 221, identifier:item; 222, identifier:diff_column; 223, integer:0; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:ax; 227, subscript; 227, 228; 227, 229; 228, identifier:axes_row; 229, identifier:col_nr; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:ax; 234, identifier:scatter; 235, argument_list; 235, 236; 235, 239; 236, subscript; 236, 237; 236, 238; 237, identifier:item; 238, identifier:key; 239, subscript; 239, 240; 239, 241; 240, identifier:item; 241, identifier:diff_column; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:ax; 246, identifier:set_xlabel; 247, argument_list; 247, 248; 248, identifier:key; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:ax; 253, identifier:set_ylabel; 254, argument_list; 254, 255; 255, identifier:diff_column; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:ax; 260, identifier:set_title; 261, argument_list; 261, 262; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, string:'N: {}'; 265, identifier:format; 266, argument_list; 266, 267; 267, call; 267, 268; 267, 269; 268, identifier:len; 269, argument_list; 269, 270; 270, identifier:indices; 271, if_statement; 271, 272; 271, 273; 272, identifier:individual; 273, block; 273, 274; 273, 280; 273, 286; 274, expression_statement; 274, 275; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:fig; 278, identifier:tight_layout; 279, argument_list; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 285; 282, subscript; 282, 283; 282, 284; 283, identifier:figures; 284, identifier:name; 285, identifier:fig; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 291; 288, subscript; 288, 289; 288, 290; 289, identifier:axes_all; 290, identifier:name; 291, identifier:axes_row; 292, if_statement; 292, 293; 292, 294; 292, 299; 293, identifier:individual; 294, block; 294, 295; 295, return_statement; 295, 296; 296, expression_list; 296, 297; 296, 298; 297, identifier:figures; 298, identifier:axes_all; 299, else_clause; 299, 300; 300, block; 300, 301; 300, 307; 301, expression_statement; 301, 302; 302, call; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:fig; 305, identifier:tight_layout; 306, argument_list; 307, return_statement; 307, 308; 308, expression_list; 308, 309; 308, 310; 309, identifier:fig; 310, identifier:axes | def scatter_norrec(self, filename=None, individual=False):
std_diff_labels = {
'r': 'rdiff',
'rpha': 'rphadiff',
}
diff_labels = std_diff_labels
labels_to_use = {}
for key, item in diff_labels.items():
if key in self.data.columns and item in self.data.columns:
labels_to_use[key] = item
g_freq = self.data.groupby('frequency')
frequencies = list(sorted(g_freq.groups.keys()))
if individual:
figures = {}
axes_all = {}
else:
Nx = len(labels_to_use.keys())
Ny = len(frequencies)
fig, axes = plt.subplots(
Ny, Nx,
figsize=(Nx * 2.5, Ny * 2.5)
)
for row, (name, item) in enumerate(g_freq):
if individual:
fig, axes_row = plt.subplots(
1, 2, figsize=(16 / 2.54, 6 / 2.54))
else:
axes_row = axes[row, :]
for col_nr, (key, diff_column) in enumerate(
sorted(labels_to_use.items())):
indices = np.where(~np.isnan(item[diff_column]))[0]
ax = axes_row[col_nr]
ax.scatter(
item[key],
item[diff_column],
)
ax.set_xlabel(key)
ax.set_ylabel(diff_column)
ax.set_title('N: {}'.format(len(indices)))
if individual:
fig.tight_layout()
figures[name] = fig
axes_all[name] = axes_row
if individual:
return figures, axes_all
else:
fig.tight_layout()
return fig, axes |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_spectrum; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:nr_id; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:abmn; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:plot_filename; 13, None; 14, block; 14, 15; 14, 23; 14, 73; 14, 94; 14, 115; 14, 119; 14, 123; 14, 157; 14, 191; 14, 242; 15, assert_statement; 15, 16; 16, boolean_operator:or; 16, 17; 16, 20; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:nr_id; 19, None; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:abmn; 22, None; 23, if_statement; 23, 24; 23, 27; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:abmn; 26, None; 27, block; 27, 28; 27, 50; 27, 63; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:subdata; 31, call; 31, 32; 31, 48; 32, attribute; 32, 33; 32, 47; 33, call; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:data; 38, identifier:query; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, string:'a == {} and b == {} and m == {} and n == {}'; 43, identifier:format; 44, argument_list; 44, 45; 45, list_splat; 45, 46; 46, identifier:abmn; 47, identifier:sort_values; 48, argument_list; 48, 49; 49, string:'frequency'; 50, if_statement; 50, 51; 50, 58; 51, comparison_operator:==; 51, 52; 51, 57; 52, subscript; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:subdata; 55, identifier:shape; 56, integer:0; 57, integer:0; 58, block; 58, 59; 59, return_statement; 59, 60; 60, expression_list; 60, 61; 60, 62; 61, None; 62, None; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:nr_id; 66, subscript; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:subdata; 70, string:'id'; 71, identifier:iloc; 72, integer:0; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:subdata_nor; 76, call; 76, 77; 76, 92; 77, attribute; 77, 78; 77, 91; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:data; 83, identifier:query; 84, argument_list; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, string:'id == {} and norrec=="nor"'; 88, identifier:format; 89, argument_list; 89, 90; 90, identifier:nr_id; 91, identifier:sort_values; 92, argument_list; 92, 93; 93, string:'frequency'; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:subdata_rec; 97, call; 97, 98; 97, 113; 98, attribute; 98, 99; 98, 112; 99, call; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:data; 104, identifier:query; 105, argument_list; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, string:'id == {} and norrec=="rec"'; 109, identifier:format; 110, argument_list; 110, 111; 111, identifier:nr_id; 112, identifier:sort_values; 113, argument_list; 113, 114; 114, string:'frequency'; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:spectrum_nor; 118, None; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:spectrum_rec; 122, None; 123, if_statement; 123, 124; 123, 131; 124, comparison_operator:>; 124, 125; 124, 130; 125, subscript; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:subdata_nor; 128, identifier:shape; 129, integer:0; 130, integer:0; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:spectrum_nor; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:eis_plot; 138, identifier:sip_response; 139, argument_list; 139, 140; 139, 147; 139, 152; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:frequencies; 142, attribute; 142, 143; 142, 146; 143, subscript; 143, 144; 143, 145; 144, identifier:subdata_nor; 145, string:'frequency'; 146, identifier:values; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:rmag; 149, subscript; 149, 150; 149, 151; 150, identifier:subdata_nor; 151, string:'r'; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:rpha; 154, subscript; 154, 155; 154, 156; 155, identifier:subdata_nor; 156, string:'rpha'; 157, if_statement; 157, 158; 157, 165; 158, comparison_operator:>; 158, 159; 158, 164; 159, subscript; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:subdata_rec; 162, identifier:shape; 163, integer:0; 164, integer:0; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:spectrum_rec; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:eis_plot; 172, identifier:sip_response; 173, argument_list; 173, 174; 173, 181; 173, 186; 174, keyword_argument; 174, 175; 174, 176; 175, identifier:frequencies; 176, attribute; 176, 177; 176, 180; 177, subscript; 177, 178; 177, 179; 178, identifier:subdata_rec; 179, string:'frequency'; 180, identifier:values; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:rmag; 183, subscript; 183, 184; 183, 185; 184, identifier:subdata_rec; 185, string:'r'; 186, keyword_argument; 186, 187; 186, 188; 187, identifier:rpha; 188, subscript; 188, 189; 188, 190; 189, identifier:subdata_rec; 190, string:'rpha'; 191, if_statement; 191, 192; 191, 195; 192, comparison_operator:is; 192, 193; 192, 194; 193, identifier:plot_filename; 194, None; 195, block; 195, 196; 196, if_statement; 196, 197; 196, 200; 197, comparison_operator:is; 197, 198; 197, 199; 198, identifier:spectrum_nor; 199, None; 200, block; 200, 201; 200, 237; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:fig; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:spectrum_nor; 207, identifier:plot; 208, argument_list; 208, 209; 208, 210; 208, 213; 208, 216; 209, identifier:plot_filename; 210, keyword_argument; 210, 211; 210, 212; 211, identifier:reciprocal; 212, identifier:spectrum_rec; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:return_fig; 215, True; 216, keyword_argument; 216, 217; 216, 218; 217, identifier:title; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, string:'a: {} b: {} m: {}: n: {}'; 221, identifier:format; 222, argument_list; 222, 223; 223, list_splat; 223, 224; 224, subscript; 224, 225; 224, 234; 224, 235; 225, attribute; 225, 226; 225, 233; 226, subscript; 226, 227; 226, 228; 227, identifier:subdata_nor; 228, list:['a', 'b', 'm', 'n']; 228, 229; 228, 230; 228, 231; 228, 232; 229, string:'a'; 230, string:'b'; 231, string:'m'; 232, string:'n'; 233, identifier:values; 234, integer:0; 235, slice; 235, 236; 236, colon; 237, return_statement; 237, 238; 238, expression_list; 238, 239; 238, 240; 238, 241; 239, identifier:spectrum_nor; 240, identifier:spectrum_rec; 241, identifier:fig; 242, return_statement; 242, 243; 243, expression_list; 243, 244; 243, 245; 244, identifier:spectrum_nor; 245, identifier:spectrum_rec | def get_spectrum(self, nr_id=None, abmn=None, plot_filename=None):
assert nr_id is None or abmn is None
if abmn is not None:
subdata = self.data.query(
'a == {} and b == {} and m == {} and n == {}'.format(*abmn)
).sort_values('frequency')
if subdata.shape[0] == 0:
return None, None
nr_id = subdata['id'].iloc[0]
subdata_nor = self.data.query(
'id == {} and norrec=="nor"'.format(nr_id)
).sort_values('frequency')
subdata_rec = self.data.query(
'id == {} and norrec=="rec"'.format(nr_id)
).sort_values('frequency')
spectrum_nor = None
spectrum_rec = None
if subdata_nor.shape[0] > 0:
spectrum_nor = eis_plot.sip_response(
frequencies=subdata_nor['frequency'].values,
rmag=subdata_nor['r'],
rpha=subdata_nor['rpha'],
)
if subdata_rec.shape[0] > 0:
spectrum_rec = eis_plot.sip_response(
frequencies=subdata_rec['frequency'].values,
rmag=subdata_rec['r'],
rpha=subdata_rec['rpha'],
)
if plot_filename is not None:
if spectrum_nor is not None:
fig = spectrum_nor.plot(
plot_filename,
reciprocal=spectrum_rec,
return_fig=True,
title='a: {} b: {} m: {}: n: {}'.format(
*subdata_nor[['a', 'b', 'm', 'n']].values[0, :]
)
)
return spectrum_nor, spectrum_rec, fig
return spectrum_nor, spectrum_rec |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:import_bin; 3, parameters; 3, 4; 3, 5; 4, identifier:filename; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 17; 7, 27; 7, 58; 7, 188; 7, 214; 7, 229; 7, 241; 7, 249; 7, 257; 7, 265; 7, 273; 7, 281; 7, 289; 7, 297; 7, 305; 7, 315; 7, 345; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 13; 10, pattern_list; 10, 11; 10, 12; 11, identifier:metadata; 12, identifier:data_raw; 13, call; 13, 14; 13, 15; 14, identifier:_import_bin; 15, argument_list; 15, 16; 16, identifier:filename; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:skip_rows; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:kwargs; 23, identifier:get; 24, argument_list; 24, 25; 24, 26; 25, string:'skip_rows'; 26, integer:0; 27, if_statement; 27, 28; 27, 31; 28, comparison_operator:>; 28, 29; 28, 30; 29, identifier:skip_rows; 30, integer:0; 31, block; 31, 32; 31, 50; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:data_raw; 36, identifier:drop; 37, argument_list; 37, 38; 37, 47; 38, subscript; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:data_raw; 41, identifier:index; 42, call; 42, 43; 42, 44; 43, identifier:range; 44, argument_list; 44, 45; 44, 46; 45, integer:0; 46, identifier:skip_rows; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:inplace; 49, True; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:data_raw; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:data_raw; 56, identifier:reset_index; 57, argument_list; 58, if_statement; 58, 59; 58, 66; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:kwargs; 62, identifier:get; 63, argument_list; 63, 64; 63, 65; 64, string:'check_meas_nums'; 65, True; 66, block; 66, 67; 66, 85; 66, 112; 66, 126; 66, 139; 67, if_statement; 67, 68; 67, 77; 68, comparison_operator:!=; 68, 69; 68, 76; 69, subscript; 69, 70; 69, 75; 70, attribute; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:data_raw; 73, string:'measurement_num'; 74, identifier:iloc; 75, integer:0; 76, integer:0; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:print; 81, argument_list; 81, 82; 82, binary_operator:+; 82, 83; 82, 84; 83, string:'WARNING: Measurement numbers do not start with 0 '; 84, string:'(did you download ALL data?)'; 85, if_statement; 85, 86; 85, 102; 86, not_operator; 86, 87; 87, comparison_operator:==; 87, 88; 87, 101; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:np; 91, identifier:all; 92, argument_list; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:np; 96, identifier:diff; 97, argument_list; 97, 98; 98, subscript; 98, 99; 98, 100; 99, identifier:data_raw; 100, string:'measurement_num'; 101, integer:1; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:print; 106, argument_list; 106, 107; 107, concatenated_string; 107, 108; 107, 109; 107, 110; 107, 111; 108, string:'WARNING '; 109, string:'Measurement numbers are not consecutive. '; 110, string:'Perhaps the first measurement belongs to another measurement?'; 111, string:' Use the skip_rows parameter to skip those measurements'; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:diff; 115, subscript; 115, 116; 115, 123; 116, call; 116, 117; 116, 122; 117, attribute; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:data_raw; 120, string:'measurement_num'; 121, identifier:diff; 122, argument_list; 123, slice; 123, 124; 123, 125; 124, integer:1; 125, colon; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:jump; 129, subscript; 129, 130; 129, 138; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:np; 133, identifier:where; 134, argument_list; 134, 135; 135, comparison_operator:!=; 135, 136; 135, 137; 136, identifier:diff; 137, integer:1; 138, integer:0; 139, if_statement; 139, 140; 139, 146; 140, comparison_operator:>; 140, 141; 140, 145; 141, call; 141, 142; 141, 143; 142, identifier:len; 143, argument_list; 143, 144; 144, identifier:jump; 145, integer:0; 146, block; 146, 147; 146, 152; 146, 157; 146, 166; 146, 171; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 150; 149, identifier:print; 150, argument_list; 150, 151; 151, string:'WARNING: One or more jumps in measurement numbers detected'; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 155; 154, identifier:print; 155, argument_list; 155, 156; 156, string:'The jump indices are:'; 157, for_statement; 157, 158; 157, 159; 157, 160; 158, identifier:jump_nr; 159, identifier:jump; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 164; 163, identifier:print; 164, argument_list; 164, 165; 165, identifier:jump_nr; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 169; 168, identifier:print; 169, argument_list; 169, 170; 170, string:'Removing data points subsequent to the first jump'; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:data_raw; 174, subscript; 174, 175; 174, 178; 174, 186; 175, attribute; 175, 176; 175, 177; 176, identifier:data_raw; 177, identifier:iloc; 178, slice; 178, 179; 178, 180; 178, 181; 179, integer:0; 180, colon; 181, binary_operator:+; 181, 182; 181, 185; 182, subscript; 182, 183; 182, 184; 183, identifier:jump; 184, integer:0; 185, integer:1; 186, slice; 186, 187; 187, colon; 188, if_statement; 188, 189; 188, 196; 189, comparison_operator:==; 189, 190; 189, 195; 190, subscript; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:data_raw; 193, identifier:shape; 194, integer:0; 195, integer:0; 196, block; 196, 197; 197, return_statement; 197, 198; 198, expression_list; 198, 199; 198, 212; 198, 213; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:pd; 202, identifier:DataFrame; 203, argument_list; 203, 204; 204, keyword_argument; 204, 205; 204, 206; 205, identifier:columns; 206, list:['a', 'b', 'm', 'n', 'r']; 206, 207; 206, 208; 206, 209; 206, 210; 206, 211; 207, string:'a'; 208, string:'b'; 209, string:'m'; 210, string:'n'; 211, string:'r'; 212, None; 213, None; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:data; 217, call; 217, 218; 217, 219; 218, identifier:_convert_coords_to_abmn_X; 219, argument_list; 219, 220; 219, 227; 220, subscript; 220, 221; 220, 222; 221, identifier:data_raw; 222, list:['x_a', 'x_b', 'x_m', 'x_n']; 222, 223; 222, 224; 222, 225; 222, 226; 223, string:'x_a'; 224, string:'x_b'; 225, string:'x_m'; 226, string:'x_n'; 227, dictionary_splat; 227, 228; 228, identifier:kwargs; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 234; 231, subscript; 231, 232; 231, 233; 232, identifier:data; 233, string:'r'; 234, binary_operator:/; 234, 235; 234, 238; 235, subscript; 235, 236; 235, 237; 236, identifier:data_raw; 237, string:'vp'; 238, subscript; 238, 239; 238, 240; 239, identifier:data_raw; 240, string:'Iab'; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 246; 243, subscript; 243, 244; 243, 245; 244, identifier:data; 245, string:'Vmn'; 246, subscript; 246, 247; 246, 248; 247, identifier:data_raw; 248, string:'vp'; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 254; 251, subscript; 251, 252; 251, 253; 252, identifier:data; 253, string:'vab'; 254, subscript; 254, 255; 254, 256; 255, identifier:data_raw; 256, string:'vab'; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 262; 259, subscript; 259, 260; 259, 261; 260, identifier:data; 261, string:'Iab'; 262, subscript; 262, 263; 262, 264; 263, identifier:data_raw; 264, string:'Iab'; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 270; 267, subscript; 267, 268; 267, 269; 268, identifier:data; 269, string:'mdelay'; 270, subscript; 270, 271; 270, 272; 271, identifier:data_raw; 272, string:'mdelay'; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 278; 275, subscript; 275, 276; 275, 277; 276, identifier:data; 277, string:'Tm'; 278, subscript; 278, 279; 278, 280; 279, identifier:data_raw; 280, string:'Tm'; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 286; 283, subscript; 283, 284; 283, 285; 284, identifier:data; 285, string:'Mx'; 286, subscript; 286, 287; 286, 288; 287, identifier:data_raw; 288, string:'Mx'; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 294; 291, subscript; 291, 292; 291, 293; 292, identifier:data; 293, string:'chargeability'; 294, subscript; 294, 295; 294, 296; 295, identifier:data_raw; 296, string:'m'; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 302; 299, subscript; 299, 300; 299, 301; 300, identifier:data; 301, string:'q'; 302, subscript; 302, 303; 302, 304; 303, identifier:data_raw; 304, string:'q'; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:rec_max; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:kwargs; 311, identifier:get; 312, argument_list; 312, 313; 312, 314; 313, string:'reciprocals'; 314, None; 315, if_statement; 315, 316; 315, 319; 316, comparison_operator:is; 316, 317; 316, 318; 317, identifier:rec_max; 318, None; 319, block; 319, 320; 319, 325; 320, expression_statement; 320, 321; 321, call; 321, 322; 321, 323; 322, identifier:print; 323, argument_list; 323, 324; 324, string:'renumbering electrode numbers'; 325, expression_statement; 325, 326; 326, assignment; 326, 327; 326, 334; 327, subscript; 327, 328; 327, 329; 328, identifier:data; 329, list:['a', 'b', 'm', 'n']; 329, 330; 329, 331; 329, 332; 329, 333; 330, string:'a'; 331, string:'b'; 332, string:'m'; 333, string:'n'; 334, binary_operator:-; 334, 335; 334, 338; 335, binary_operator:+; 335, 336; 335, 337; 336, identifier:rec_max; 337, integer:1; 338, subscript; 338, 339; 338, 340; 339, identifier:data; 340, list:['a', 'b', 'm', 'n']; 340, 341; 340, 342; 340, 343; 340, 344; 341, string:'a'; 342, string:'b'; 343, string:'m'; 344, string:'n'; 345, return_statement; 345, 346; 346, expression_list; 346, 347; 346, 348; 346, 349; 347, identifier:data; 348, None; 349, None | def import_bin(filename, **kwargs):
metadata, data_raw = _import_bin(filename)
skip_rows = kwargs.get('skip_rows', 0)
if skip_rows > 0:
data_raw.drop(data_raw.index[range(0, skip_rows)], inplace=True)
data_raw = data_raw.reset_index()
if kwargs.get('check_meas_nums', True):
if data_raw['measurement_num'].iloc[0] != 0:
print('WARNING: Measurement numbers do not start with 0 ' +
'(did you download ALL data?)')
if not np.all(np.diff(data_raw['measurement_num'])) == 1:
print(
'WARNING '
'Measurement numbers are not consecutive. '
'Perhaps the first measurement belongs to another measurement?'
' Use the skip_rows parameter to skip those measurements'
)
diff = data_raw['measurement_num'].diff()[1:]
jump = np.where(diff != 1)[0]
if len(jump) > 0:
print('WARNING: One or more jumps in measurement numbers detected')
print('The jump indices are:')
for jump_nr in jump:
print(jump_nr)
print('Removing data points subsequent to the first jump')
data_raw = data_raw.iloc[0:jump[0] + 1, :]
if data_raw.shape[0] == 0:
return pd.DataFrame(columns=['a', 'b', 'm', 'n', 'r']), None, None
data = _convert_coords_to_abmn_X(
data_raw[['x_a', 'x_b', 'x_m', 'x_n']],
**kwargs
)
data['r'] = data_raw['vp'] / data_raw['Iab']
data['Vmn'] = data_raw['vp']
data['vab'] = data_raw['vab']
data['Iab'] = data_raw['Iab']
data['mdelay'] = data_raw['mdelay']
data['Tm'] = data_raw['Tm']
data['Mx'] = data_raw['Mx']
data['chargeability'] = data_raw['m']
data['q'] = data_raw['q']
rec_max = kwargs.get('reciprocals', None)
if rec_max is not None:
print('renumbering electrode numbers')
data[['a', 'b', 'm', 'n']] = rec_max + 1 - data[['a', 'b', 'm', 'n']]
return data, None, None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 43; 2, function_name:datoms; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 3, 35; 3, 38; 3, 41; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:index; 7, string:'aevt'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:e; 10, string:''; 11, default_parameter; 11, 12; 11, 13; 12, identifier:a; 13, string:''; 14, default_parameter; 14, 15; 14, 16; 15, identifier:v; 16, string:''; 17, default_parameter; 17, 18; 17, 19; 18, identifier:limit; 19, integer:0; 20, default_parameter; 20, 21; 20, 22; 21, identifier:offset; 22, integer:0; 23, default_parameter; 23, 24; 23, 25; 24, identifier:chunk; 25, integer:100; 26, default_parameter; 26, 27; 26, 28; 27, identifier:start; 28, string:''; 29, default_parameter; 29, 30; 29, 31; 30, identifier:end; 31, string:''; 32, default_parameter; 32, 33; 32, 34; 33, identifier:since; 34, string:''; 35, default_parameter; 35, 36; 35, 37; 36, identifier:as_of; 37, string:''; 38, default_parameter; 38, 39; 38, 40; 39, identifier:history; 40, string:''; 41, dictionary_splat_pattern; 41, 42; 42, identifier:kwargs; 43, block; 43, 44; 43, 53; 43, 127; 43, 135; 43, 139; 44, assert_statement; 44, 45; 44, 52; 45, comparison_operator:in; 45, 46; 45, 47; 46, identifier:index; 47, list:['aevt','eavt','avet','vaet']; 47, 48; 47, 49; 47, 50; 47, 51; 48, string:'aevt'; 49, string:'eavt'; 50, string:'avet'; 51, string:'vaet'; 52, string:"non-existant index"; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:data; 56, dictionary; 56, 57; 56, 60; 56, 71; 56, 80; 56, 89; 56, 94; 56, 97; 56, 100; 56, 103; 56, 109; 56, 118; 57, pair; 57, 58; 57, 59; 58, string:'index'; 59, identifier:index; 60, pair; 60, 61; 60, 62; 61, string:'a'; 62, conditional_expression:if; 62, 63; 62, 69; 62, 70; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, string:':{0}'; 66, identifier:format; 67, argument_list; 67, 68; 68, identifier:a; 69, identifier:a; 70, string:''; 71, pair; 71, 72; 71, 73; 72, string:'v'; 73, conditional_expression:if; 73, 74; 73, 78; 73, 79; 74, call; 74, 75; 74, 76; 75, identifier:dump_edn_val; 76, argument_list; 76, 77; 77, identifier:v; 78, identifier:v; 79, string:''; 80, pair; 80, 81; 80, 82; 81, string:'e'; 82, conditional_expression:if; 82, 83; 82, 87; 82, 88; 83, call; 83, 84; 83, 85; 84, identifier:int; 85, argument_list; 85, 86; 86, identifier:e; 87, identifier:e; 88, string:''; 89, pair; 89, 90; 89, 91; 90, string:'offset'; 91, boolean_operator:or; 91, 92; 91, 93; 92, identifier:offset; 93, integer:0; 94, pair; 94, 95; 94, 96; 95, string:'start'; 96, identifier:start; 97, pair; 97, 98; 97, 99; 98, string:'end'; 99, identifier:end; 100, pair; 100, 101; 100, 102; 101, string:'limit'; 102, identifier:limit; 103, pair; 103, 104; 103, 105; 104, string:'history'; 105, conditional_expression:if; 105, 106; 105, 107; 105, 108; 106, string:'true'; 107, identifier:history; 108, string:''; 109, pair; 109, 110; 109, 111; 110, string:'as-of'; 111, conditional_expression:if; 111, 112; 111, 116; 111, 117; 112, call; 112, 113; 112, 114; 113, identifier:int; 114, argument_list; 114, 115; 115, identifier:as_of; 116, identifier:as_of; 117, string:''; 118, pair; 118, 119; 118, 120; 119, string:'since'; 120, conditional_expression:if; 120, 121; 120, 125; 120, 126; 121, call; 121, 122; 121, 123; 122, identifier:int; 123, argument_list; 123, 124; 124, identifier:since; 125, identifier:since; 126, string:''; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:data; 131, string:'limit'; 132, binary_operator:+; 132, 133; 132, 134; 133, identifier:offset; 134, identifier:chunk; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:rs; 138, True; 139, while_statement; 139, 140; 139, 151; 140, boolean_operator:and; 140, 141; 140, 142; 141, identifier:rs; 142, parenthesized_expression; 142, 143; 143, comparison_operator:<; 143, 144; 143, 147; 144, subscript; 144, 145; 144, 146; 145, identifier:data; 146, string:'offset'; 147, parenthesized_expression; 147, 148; 148, boolean_operator:or; 148, 149; 148, 150; 149, identifier:limit; 150, integer:1000000000; 151, block; 151, 152; 151, 162; 151, 182; 151, 193; 151, 205; 151, 225; 151, 232; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:ta; 155, call; 155, 156; 155, 161; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:datetime; 159, identifier:datetime; 160, identifier:now; 161, argument_list; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:rs; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:rest; 169, argument_list; 169, 170; 169, 171; 169, 176; 169, 179; 170, string:'GET'; 171, binary_operator:+; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:uri_db; 175, string:'-/datoms'; 176, keyword_argument; 176, 177; 176, 178; 177, identifier:data; 178, identifier:data; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:parse; 181, True; 182, if_statement; 182, 183; 182, 188; 183, not_operator; 183, 184; 184, call; 184, 185; 184, 186; 185, identifier:len; 186, argument_list; 186, 187; 187, identifier:rs; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:rs; 192, False; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:tb; 196, binary_operator:-; 196, 197; 196, 204; 197, call; 197, 198; 197, 203; 198, attribute; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:datetime; 201, identifier:datetime; 202, identifier:now; 203, argument_list; 204, identifier:ta; 205, print_statement; 205, 206; 206, call; 206, 207; 206, 208; 207, identifier:cl; 208, argument_list; 208, 209; 208, 224; 209, binary_operator:%; 209, 210; 209, 211; 210, string:'<<< fetched %i datoms at offset %i in %sms'; 211, tuple; 211, 212; 211, 216; 211, 219; 212, call; 212, 213; 212, 214; 213, identifier:len; 214, argument_list; 214, 215; 215, identifier:rs; 216, subscript; 216, 217; 216, 218; 217, identifier:data; 218, string:'offset'; 219, binary_operator:/; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:tb; 222, identifier:microseconds; 223, float:1000.0; 224, string:'cyan'; 225, for_statement; 225, 226; 225, 227; 225, 228; 226, identifier:r; 227, identifier:rs; 228, block; 228, 229; 229, expression_statement; 229, 230; 230, yield; 230, 231; 231, identifier:r; 232, expression_statement; 232, 233; 233, augmented_assignment:+=; 233, 234; 233, 237; 234, subscript; 234, 235; 234, 236; 235, identifier:data; 236, string:'offset'; 237, identifier:chunk | def datoms(self, index='aevt', e='', a='', v='',
limit=0, offset=0, chunk=100,
start='', end='', since='', as_of='', history='', **kwargs):
assert index in ['aevt','eavt','avet','vaet'], "non-existant index"
data = {'index': index,
'a': ':{0}'.format(a) if a else '',
'v': dump_edn_val(v) if v else '',
'e': int(e) if e else '',
'offset': offset or 0,
'start': start,
'end': end,
'limit': limit,
'history': 'true' if history else '',
'as-of': int(as_of) if as_of else '',
'since': int(since) if since else '',
}
data['limit'] = offset + chunk
rs = True
while rs and (data['offset'] < (limit or 1000000000)):
ta = datetime.datetime.now()
rs = self.rest('GET', self.uri_db + '-/datoms', data=data, parse=True)
if not len(rs):
rs = False
tb = datetime.datetime.now() - ta
print cl('<<< fetched %i datoms at offset %i in %sms' % (
len(rs), data['offset'], tb.microseconds/1000.0), 'cyan')
for r in rs: yield r
data['offset'] += chunk |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:add; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 17; 9, 30; 9, 147; 9, 149; 9, 172; 9, 174; 9, 203; 9, 205; 9, 367; 9, 369; 10, assert_statement; 10, 11; 10, 16; 11, comparison_operator:is; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:resp; 15, None; 16, string:"Transaction already committed"; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 23; 19, pattern_list; 19, 20; 19, 21; 19, 22; 20, identifier:entity; 21, identifier:av_pairs; 22, identifier:args; 23, expression_list; 23, 24; 23, 25; 23, 26; 24, None; 25, list:[]; 26, call; 26, 27; 26, 28; 27, identifier:list; 28, argument_list; 28, 29; 29, identifier:args; 30, if_statement; 30, 31; 30, 35; 31, call; 31, 32; 31, 33; 32, identifier:len; 33, argument_list; 33, 34; 34, identifier:args; 35, block; 35, 36; 35, 122; 35, 124; 36, if_statement; 36, 37; 36, 46; 36, 61; 37, call; 37, 38; 37, 39; 38, identifier:isinstance; 39, argument_list; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:args; 42, integer:0; 43, tuple; 43, 44; 43, 45; 44, identifier:int; 45, identifier:long; 46, block; 46, 47; 46, 49; 47, expression_statement; 47, 48; 48, string:" first arg is an entity or tempid"; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:entity; 52, call; 52, 53; 52, 54; 53, identifier:E; 54, argument_list; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:args; 57, integer:0; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:tx; 60, identifier:self; 61, elif_clause; 61, 62; 61, 69; 62, call; 62, 63; 62, 64; 63, identifier:isinstance; 64, argument_list; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:args; 67, integer:0; 68, identifier:E; 69, block; 69, 70; 69, 72; 70, expression_statement; 70, 71; 71, string:" dont resuse entity from another tx"; 72, if_statement; 72, 73; 72, 80; 72, 87; 73, comparison_operator:is; 73, 74; 73, 79; 74, attribute; 74, 75; 74, 78; 75, subscript; 75, 76; 75, 77; 76, identifier:args; 77, integer:0; 78, identifier:_tx; 79, identifier:self; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:entity; 84, subscript; 84, 85; 84, 86; 85, identifier:args; 86, integer:0; 87, else_clause; 87, 88; 88, block; 88, 89; 88, 116; 89, if_statement; 89, 90; 89, 98; 90, comparison_operator:>; 90, 91; 90, 97; 91, call; 91, 92; 91, 93; 92, identifier:int; 93, argument_list; 93, 94; 94, subscript; 94, 95; 94, 96; 95, identifier:args; 96, integer:0; 97, integer:0; 98, block; 98, 99; 98, 101; 99, expression_statement; 99, 100; 100, string:" use the entity id on a new obj"; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:entity; 104, call; 104, 105; 104, 106; 105, identifier:E; 106, argument_list; 106, 107; 106, 113; 107, call; 107, 108; 107, 109; 108, identifier:int; 109, argument_list; 109, 110; 110, subscript; 110, 111; 110, 112; 111, identifier:args; 112, integer:0; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:tx; 115, identifier:self; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:args; 120, integer:0; 121, None; 122, expression_statement; 122, 123; 123, string:" drop the first arg"; 124, if_statement; 124, 125; 124, 137; 125, boolean_operator:or; 125, 126; 125, 129; 126, comparison_operator:is; 126, 127; 126, 128; 127, identifier:entity; 128, None; 129, comparison_operator:in; 129, 130; 129, 133; 130, subscript; 130, 131; 130, 132; 131, identifier:args; 132, integer:0; 133, tuple; 133, 134; 133, 135; 133, 136; 134, None; 135, False; 136, integer:0; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:v; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:args; 144, identifier:pop; 145, argument_list; 145, 146; 146, integer:0; 147, expression_statement; 147, 148; 148, string:" auto generate a temp id?"; 149, if_statement; 149, 150; 149, 153; 150, comparison_operator:is; 150, 151; 150, 152; 151, identifier:entity; 152, None; 153, block; 153, 154; 153, 166; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:entity; 157, call; 157, 158; 157, 159; 158, identifier:E; 159, argument_list; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:ctmpid; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:tx; 165, identifier:self; 166, expression_statement; 166, 167; 167, augmented_assignment:-=; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:ctmpid; 171, integer:1; 172, expression_statement; 172, 173; 173, string:" a,v from kwargs"; 174, if_statement; 174, 175; 174, 183; 175, boolean_operator:and; 175, 176; 175, 182; 176, comparison_operator:==; 176, 177; 176, 181; 177, call; 177, 178; 177, 179; 178, identifier:len; 179, argument_list; 179, 180; 180, identifier:args; 181, integer:0; 182, identifier:kwargs; 183, block; 183, 184; 184, for_statement; 184, 185; 184, 188; 184, 193; 185, pattern_list; 185, 186; 185, 187; 186, identifier:a; 187, identifier:v; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:kwargs; 191, identifier:iteritems; 192, argument_list; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:addeav; 199, argument_list; 199, 200; 199, 201; 199, 202; 200, identifier:entity; 201, identifier:a; 202, identifier:v; 203, expression_statement; 203, 204; 204, string:" a,v from args "; 205, if_statement; 205, 206; 205, 210; 206, call; 206, 207; 206, 208; 207, identifier:len; 208, argument_list; 208, 209; 209, identifier:args; 210, block; 210, 211; 210, 223; 211, assert_statement; 211, 212; 211, 220; 212, comparison_operator:==; 212, 213; 212, 219; 213, binary_operator:%; 213, 214; 213, 218; 214, call; 214, 215; 214, 216; 215, identifier:len; 216, argument_list; 216, 217; 217, identifier:args; 218, integer:2; 219, integer:0; 220, binary_operator:%; 220, 221; 220, 222; 221, string:"imbalanced a,v in args: "; 222, identifier:args; 223, for_statement; 223, 224; 223, 227; 223, 231; 224, pattern_list; 224, 225; 224, 226; 225, identifier:first; 226, identifier:second; 227, call; 227, 228; 227, 229; 228, identifier:pairwise; 229, argument_list; 229, 230; 230, identifier:args; 231, block; 231, 232; 231, 247; 232, if_statement; 232, 233; 232, 240; 233, not_operator; 233, 234; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:first; 237, identifier:startswith; 238, argument_list; 238, 239; 239, string:':'; 240, block; 240, 241; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:first; 244, binary_operator:+; 244, 245; 244, 246; 245, string:':'; 246, identifier:first; 247, if_statement; 247, 248; 247, 255; 247, 290; 247, 323; 247, 357; 248, not_operator; 248, 249; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:first; 252, identifier:endswith; 253, argument_list; 253, 254; 254, string:'/'; 255, block; 255, 256; 255, 258; 255, 289; 256, expression_statement; 256, 257; 257, string:" longhand used: blah/blah "; 258, if_statement; 258, 259; 258, 264; 258, 278; 259, call; 259, 260; 259, 261; 260, identifier:isinstance; 261, argument_list; 261, 262; 261, 263; 262, identifier:second; 263, identifier:list; 264, block; 264, 265; 265, for_statement; 265, 266; 265, 267; 265, 268; 266, identifier:v; 267, identifier:second; 268, block; 268, 269; 269, expression_statement; 269, 270; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:self; 273, identifier:addeav; 274, argument_list; 274, 275; 274, 276; 274, 277; 275, identifier:entity; 276, identifier:first; 277, identifier:v; 278, else_clause; 278, 279; 279, block; 279, 280; 280, expression_statement; 280, 281; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:self; 284, identifier:addeav; 285, argument_list; 285, 286; 285, 287; 285, 288; 286, identifier:entity; 287, identifier:first; 288, identifier:second; 289, continue_statement; 290, elif_clause; 290, 291; 290, 296; 291, call; 291, 292; 291, 293; 292, identifier:isinstance; 293, argument_list; 293, 294; 293, 295; 294, identifier:second; 295, identifier:dict; 296, block; 296, 297; 296, 299; 297, expression_statement; 297, 298; 298, string:" shorthand used: blah/, dict "; 299, for_statement; 299, 300; 299, 303; 299, 308; 300, pattern_list; 300, 301; 300, 302; 301, identifier:a; 302, identifier:v; 303, call; 303, 304; 303, 307; 304, attribute; 304, 305; 304, 306; 305, identifier:second; 306, identifier:iteritems; 307, argument_list; 308, block; 308, 309; 308, 322; 309, expression_statement; 309, 310; 310, call; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:self; 313, identifier:addeav; 314, argument_list; 314, 315; 314, 316; 314, 321; 315, identifier:entity; 316, binary_operator:%; 316, 317; 316, 318; 317, string:"%s%s"; 318, tuple; 318, 319; 318, 320; 319, identifier:first; 320, identifier:a; 321, identifier:v; 322, continue_statement; 323, elif_clause; 323, 324; 323, 331; 324, call; 324, 325; 324, 326; 325, identifier:isinstance; 326, argument_list; 326, 327; 326, 328; 327, identifier:second; 328, tuple; 328, 329; 328, 330; 329, identifier:list; 330, identifier:tuple; 331, block; 331, 332; 331, 334; 332, expression_statement; 332, 333; 333, string:" shorthand used: blah/, list|tuple "; 334, for_statement; 334, 335; 334, 338; 334, 342; 335, pattern_list; 335, 336; 335, 337; 336, identifier:a; 337, identifier:v; 338, call; 338, 339; 338, 340; 339, identifier:pairwise; 340, argument_list; 340, 341; 341, identifier:second; 342, block; 342, 343; 342, 356; 343, expression_statement; 343, 344; 344, call; 344, 345; 344, 348; 345, attribute; 345, 346; 345, 347; 346, identifier:self; 347, identifier:addeav; 348, argument_list; 348, 349; 348, 350; 348, 355; 349, identifier:entity; 350, binary_operator:%; 350, 351; 350, 352; 351, string:"%s%s"; 352, tuple; 352, 353; 352, 354; 353, identifier:first; 354, identifier:a; 355, identifier:v; 356, continue_statement; 357, else_clause; 357, 358; 358, block; 358, 359; 359, raise_statement; 359, 360; 360, expression_list; 360, 361; 360, 362; 361, identifier:Exception; 362, binary_operator:%; 362, 363; 362, 364; 363, string:"invalid pair: %s : %s"; 364, tuple; 364, 365; 364, 366; 365, identifier:first; 366, identifier:second; 367, expression_statement; 367, 368; 368, string:"pass back the entity so it can be resolved after tx()"; 369, return_statement; 369, 370; 370, identifier:entity | def add(self, *args, **kwargs):
assert self.resp is None, "Transaction already committed"
entity, av_pairs, args = None, [], list(args)
if len(args):
if isinstance(args[0], (int, long)):
" first arg is an entity or tempid"
entity = E(args[0], tx=self)
elif isinstance(args[0], E):
" dont resuse entity from another tx"
if args[0]._tx is self:
entity = args[0]
else:
if int(args[0]) > 0:
" use the entity id on a new obj"
entity = E(int(args[0]), tx=self)
args[0] = None
" drop the first arg"
if entity is not None or args[0] in (None, False, 0):
v = args.pop(0)
" auto generate a temp id?"
if entity is None:
entity = E(self.ctmpid, tx=self)
self.ctmpid -= 1
" a,v from kwargs"
if len(args) == 0 and kwargs:
for a,v in kwargs.iteritems():
self.addeav(entity, a, v)
" a,v from args "
if len(args):
assert len(args) % 2 == 0, "imbalanced a,v in args: " % args
for first, second in pairwise(args):
if not first.startswith(':'):
first = ':' + first
if not first.endswith('/'):
" longhand used: blah/blah "
if isinstance(second, list):
for v in second:
self.addeav(entity, first, v)
else:
self.addeav(entity, first, second)
continue
elif isinstance(second, dict):
" shorthand used: blah/, dict "
for a,v in second.iteritems():
self.addeav(entity, "%s%s" % (first, a), v)
continue
elif isinstance(second, (list, tuple)):
" shorthand used: blah/, list|tuple "
for a,v in pairwise(second):
self.addeav(entity, "%s%s" % (first, a), v)
continue
else:
raise Exception, "invalid pair: %s : %s" % (first,second)
"pass back the entity so it can be resolved after tx()"
return entity |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:parsimonious_acr; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:tree; 5, identifier:character; 6, identifier:prediction_method; 7, identifier:states; 8, identifier:num_nodes; 9, identifier:num_tips; 10, block; 10, 11; 10, 18; 10, 24; 10, 28; 10, 41; 10, 50; 10, 173; 10, 259; 10, 356; 10, 371; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:initialise_parsimonious_states; 14, argument_list; 14, 15; 14, 16; 14, 17; 15, identifier:tree; 16, identifier:character; 17, identifier:states; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:uppass; 21, argument_list; 21, 22; 21, 23; 22, identifier:tree; 23, identifier:character; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:results; 27, list:[]; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:result; 31, dictionary; 31, 32; 31, 35; 31, 38; 32, pair; 32, 33; 32, 34; 33, identifier:STATES; 34, identifier:states; 35, pair; 35, 36; 35, 37; 36, identifier:NUM_NODES; 37, identifier:num_nodes; 38, pair; 38, 39; 38, 40; 39, identifier:NUM_TIPS; 40, identifier:num_tips; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:logger; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:logging; 47, identifier:getLogger; 48, argument_list; 48, 49; 49, string:'pastml'; 50, function_definition; 50, 51; 50, 52; 50, 55; 51, function_name:process_result; 52, parameters; 52, 53; 52, 54; 53, identifier:method; 54, identifier:feature; 55, block; 55, 56; 55, 69; 55, 77; 55, 96; 55, 102; 55, 114; 55, 154; 55, 160; 55, 166; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:out_feature; 59, conditional_expression:if; 59, 60; 59, 65; 59, 68; 60, call; 60, 61; 60, 62; 61, identifier:get_personalized_feature_name; 62, argument_list; 62, 63; 62, 64; 63, identifier:character; 64, identifier:method; 65, comparison_operator:!=; 65, 66; 65, 67; 66, identifier:prediction_method; 67, identifier:method; 68, identifier:character; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:res; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:result; 75, identifier:copy; 76, argument_list; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 89; 78, 90; 79, pattern_list; 79, 80; 79, 83; 79, 86; 80, subscript; 80, 81; 80, 82; 81, identifier:res; 82, identifier:NUM_SCENARIOS; 83, subscript; 83, 84; 83, 85; 84, identifier:res; 85, identifier:NUM_UNRESOLVED_NODES; 86, subscript; 86, 87; 86, 88; 87, identifier:res; 88, identifier:NUM_STATES_PER_NODE; 89, line_continuation:\; 90, call; 90, 91; 90, 92; 91, identifier:choose_parsimonious_states; 92, argument_list; 92, 93; 92, 94; 92, 95; 93, identifier:tree; 94, identifier:feature; 95, identifier:out_feature; 96, expression_statement; 96, 97; 97, augmented_assignment:/=; 97, 98; 97, 101; 98, subscript; 98, 99; 98, 100; 99, identifier:res; 100, identifier:NUM_STATES_PER_NODE; 101, identifier:num_nodes; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:res; 106, identifier:PERC_UNRESOLVED; 107, binary_operator:/; 107, 108; 107, 113; 108, binary_operator:*; 108, 109; 108, 112; 109, subscript; 109, 110; 109, 111; 110, identifier:res; 111, identifier:NUM_UNRESOLVED_NODES; 112, integer:100; 113, identifier:num_nodes; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:logger; 118, identifier:debug; 119, argument_list; 119, 120; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, concatenated_string; 122, 123; 122, 124; 123, string:'{} node{} unresolved ({:.2f}%) for {} by {}, '; 124, string:'i.e. {:.4f} state{} per node in average.'; 125, identifier:format; 126, argument_list; 126, 127; 126, 130; 126, 138; 126, 141; 126, 142; 126, 143; 126, 146; 127, subscript; 127, 128; 127, 129; 128, identifier:res; 129, identifier:NUM_UNRESOLVED_NODES; 130, conditional_expression:if; 130, 131; 130, 132; 130, 137; 131, string:'s are'; 132, comparison_operator:!=; 132, 133; 132, 136; 133, subscript; 133, 134; 133, 135; 134, identifier:res; 135, identifier:NUM_UNRESOLVED_NODES; 136, integer:1; 137, string:' is'; 138, subscript; 138, 139; 138, 140; 139, identifier:res; 140, identifier:PERC_UNRESOLVED; 141, identifier:character; 142, identifier:method; 143, subscript; 143, 144; 143, 145; 144, identifier:res; 145, identifier:NUM_STATES_PER_NODE; 146, conditional_expression:if; 146, 147; 146, 148; 146, 153; 147, string:'s'; 148, comparison_operator:>; 148, 149; 148, 152; 149, subscript; 149, 150; 149, 151; 150, identifier:res; 151, identifier:NUM_STATES_PER_NODE; 152, integer:1; 153, string:''; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:res; 158, identifier:CHARACTER; 159, identifier:out_feature; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:res; 164, identifier:METHOD; 165, identifier:method; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:results; 170, identifier:append; 171, argument_list; 171, 172; 172, identifier:res; 173, if_statement; 173, 174; 173, 179; 174, comparison_operator:in; 174, 175; 174, 176; 175, identifier:prediction_method; 176, set; 176, 177; 176, 178; 177, identifier:ACCTRAN; 178, identifier:MP; 179, block; 179, 180; 179, 188; 179, 201; 179, 208; 179, 218; 179, 224; 179, 232; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:feature; 183, call; 183, 184; 183, 185; 184, identifier:get_personalized_feature_name; 185, argument_list; 185, 186; 185, 187; 186, identifier:character; 187, identifier:PARS_STATES; 188, if_statement; 188, 189; 188, 192; 189, comparison_operator:==; 189, 190; 189, 191; 190, identifier:prediction_method; 191, identifier:MP; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:feature; 196, call; 196, 197; 196, 198; 197, identifier:get_personalized_feature_name; 198, argument_list; 198, 199; 198, 200; 199, identifier:feature; 200, identifier:ACCTRAN; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:acctran; 204, argument_list; 204, 205; 204, 206; 204, 207; 205, identifier:tree; 206, identifier:character; 207, identifier:feature; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:result; 212, identifier:STEPS; 213, call; 213, 214; 213, 215; 214, identifier:get_num_parsimonious_steps; 215, argument_list; 215, 216; 215, 217; 216, identifier:tree; 217, identifier:feature; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 221; 220, identifier:process_result; 221, argument_list; 221, 222; 221, 223; 222, identifier:ACCTRAN; 223, identifier:feature; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:bu_feature; 227, call; 227, 228; 227, 229; 228, identifier:get_personalized_feature_name; 229, argument_list; 229, 230; 229, 231; 230, identifier:character; 231, identifier:BU_PARS_STATES; 232, for_statement; 232, 233; 232, 234; 232, 239; 233, identifier:node; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:tree; 237, identifier:traverse; 238, argument_list; 239, block; 239, 240; 239, 252; 240, if_statement; 240, 241; 240, 244; 241, comparison_operator:==; 241, 242; 241, 243; 242, identifier:prediction_method; 243, identifier:ACCTRAN; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:node; 249, identifier:del_feature; 250, argument_list; 250, 251; 251, identifier:bu_feature; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:node; 256, identifier:del_feature; 257, argument_list; 257, 258; 258, identifier:feature; 259, if_statement; 259, 260; 259, 263; 260, comparison_operator:!=; 260, 261; 260, 262; 261, identifier:prediction_method; 262, identifier:ACCTRAN; 263, block; 263, 264; 263, 271; 263, 279; 263, 294; 263, 307; 263, 341; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 267; 266, identifier:downpass; 267, argument_list; 267, 268; 267, 269; 267, 270; 268, identifier:tree; 269, identifier:character; 270, identifier:states; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:feature; 274, call; 274, 275; 274, 276; 275, identifier:get_personalized_feature_name; 276, argument_list; 276, 277; 276, 278; 277, identifier:character; 278, identifier:PARS_STATES; 279, if_statement; 279, 280; 279, 283; 280, comparison_operator:==; 280, 281; 280, 282; 281, identifier:prediction_method; 282, identifier:DOWNPASS; 283, block; 283, 284; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 289; 286, subscript; 286, 287; 286, 288; 287, identifier:result; 288, identifier:STEPS; 289, call; 289, 290; 289, 291; 290, identifier:get_num_parsimonious_steps; 291, argument_list; 291, 292; 291, 293; 292, identifier:tree; 293, identifier:feature; 294, if_statement; 294, 295; 294, 300; 295, comparison_operator:in; 295, 296; 295, 297; 296, identifier:prediction_method; 297, set; 297, 298; 297, 299; 298, identifier:DOWNPASS; 299, identifier:MP; 300, block; 300, 301; 301, expression_statement; 301, 302; 302, call; 302, 303; 302, 304; 303, identifier:process_result; 304, argument_list; 304, 305; 304, 306; 305, identifier:DOWNPASS; 306, identifier:feature; 307, if_statement; 307, 308; 307, 313; 308, comparison_operator:in; 308, 309; 308, 310; 309, identifier:prediction_method; 310, set; 310, 311; 310, 312; 311, identifier:DELTRAN; 312, identifier:MP; 313, block; 313, 314; 313, 320; 313, 335; 314, expression_statement; 314, 315; 315, call; 315, 316; 315, 317; 316, identifier:deltran; 317, argument_list; 317, 318; 317, 319; 318, identifier:tree; 319, identifier:character; 320, if_statement; 320, 321; 320, 324; 321, comparison_operator:==; 321, 322; 321, 323; 322, identifier:prediction_method; 323, identifier:DELTRAN; 324, block; 324, 325; 325, expression_statement; 325, 326; 326, assignment; 326, 327; 326, 330; 327, subscript; 327, 328; 327, 329; 328, identifier:result; 329, identifier:STEPS; 330, call; 330, 331; 330, 332; 331, identifier:get_num_parsimonious_steps; 332, argument_list; 332, 333; 332, 334; 333, identifier:tree; 334, identifier:feature; 335, expression_statement; 335, 336; 336, call; 336, 337; 336, 338; 337, identifier:process_result; 338, argument_list; 338, 339; 338, 340; 339, identifier:DELTRAN; 340, identifier:feature; 341, for_statement; 341, 342; 341, 343; 341, 348; 342, identifier:node; 343, call; 343, 344; 343, 347; 344, attribute; 344, 345; 344, 346; 345, identifier:tree; 346, identifier:traverse; 347, argument_list; 348, block; 348, 349; 349, expression_statement; 349, 350; 350, call; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:node; 353, identifier:del_feature; 354, argument_list; 354, 355; 355, identifier:feature; 356, expression_statement; 356, 357; 357, call; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, identifier:logger; 360, identifier:debug; 361, argument_list; 361, 362; 362, call; 362, 363; 362, 366; 363, attribute; 363, 364; 363, 365; 364, string:"Parsimonious reconstruction for {} requires {} state changes."; 365, identifier:format; 366, argument_list; 366, 367; 366, 368; 367, identifier:character; 368, subscript; 368, 369; 368, 370; 369, identifier:result; 370, identifier:STEPS; 371, return_statement; 371, 372; 372, identifier:results | def parsimonious_acr(tree, character, prediction_method, states, num_nodes, num_tips):
initialise_parsimonious_states(tree, character, states)
uppass(tree, character)
results = []
result = {STATES: states, NUM_NODES: num_nodes, NUM_TIPS: num_tips}
logger = logging.getLogger('pastml')
def process_result(method, feature):
out_feature = get_personalized_feature_name(character, method) if prediction_method != method else character
res = result.copy()
res[NUM_SCENARIOS], res[NUM_UNRESOLVED_NODES], res[NUM_STATES_PER_NODE] \
= choose_parsimonious_states(tree, feature, out_feature)
res[NUM_STATES_PER_NODE] /= num_nodes
res[PERC_UNRESOLVED] = res[NUM_UNRESOLVED_NODES] * 100 / num_nodes
logger.debug('{} node{} unresolved ({:.2f}%) for {} by {}, '
'i.e. {:.4f} state{} per node in average.'
.format(res[NUM_UNRESOLVED_NODES], 's are' if res[NUM_UNRESOLVED_NODES] != 1 else ' is',
res[PERC_UNRESOLVED], character, method,
res[NUM_STATES_PER_NODE], 's' if res[NUM_STATES_PER_NODE] > 1 else ''))
res[CHARACTER] = out_feature
res[METHOD] = method
results.append(res)
if prediction_method in {ACCTRAN, MP}:
feature = get_personalized_feature_name(character, PARS_STATES)
if prediction_method == MP:
feature = get_personalized_feature_name(feature, ACCTRAN)
acctran(tree, character, feature)
result[STEPS] = get_num_parsimonious_steps(tree, feature)
process_result(ACCTRAN, feature)
bu_feature = get_personalized_feature_name(character, BU_PARS_STATES)
for node in tree.traverse():
if prediction_method == ACCTRAN:
node.del_feature(bu_feature)
node.del_feature(feature)
if prediction_method != ACCTRAN:
downpass(tree, character, states)
feature = get_personalized_feature_name(character, PARS_STATES)
if prediction_method == DOWNPASS:
result[STEPS] = get_num_parsimonious_steps(tree, feature)
if prediction_method in {DOWNPASS, MP}:
process_result(DOWNPASS, feature)
if prediction_method in {DELTRAN, MP}:
deltran(tree, character)
if prediction_method == DELTRAN:
result[STEPS] = get_num_parsimonious_steps(tree, feature)
process_result(DELTRAN, feature)
for node in tree.traverse():
node.del_feature(feature)
logger.debug("Parsimonious reconstruction for {} requires {} state changes."
.format(character, result[STEPS]))
return results |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:load_seit_data; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:directory; 5, default_parameter; 5, 6; 5, 7; 6, identifier:frequency_file; 7, string:'frequencies.dat'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:data_prefix; 10, string:'volt_'; 11, dictionary_splat_pattern; 11, 12; 12, identifier:kwargs; 13, block; 13, 14; 13, 29; 13, 47; 13, 62; 13, 66; 13, 96; 13, 105; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:frequencies; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:np; 20, identifier:loadtxt; 21, argument_list; 21, 22; 22, binary_operator:+; 22, 23; 22, 28; 23, binary_operator:+; 23, 24; 23, 25; 24, identifier:directory; 25, attribute; 25, 26; 25, 27; 26, identifier:os; 27, identifier:sep; 28, identifier:frequency_file; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:data_files; 32, call; 32, 33; 32, 34; 33, identifier:sorted; 34, argument_list; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:glob; 37, argument_list; 37, 38; 38, binary_operator:+; 38, 39; 38, 46; 39, binary_operator:+; 39, 40; 39, 45; 40, binary_operator:+; 40, 41; 40, 42; 41, identifier:directory; 42, attribute; 42, 43; 42, 44; 43, identifier:os; 44, identifier:sep; 45, identifier:data_prefix; 46, string:'*'; 47, if_statement; 47, 48; 47, 56; 48, comparison_operator:!=; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:frequencies; 51, identifier:size; 52, call; 52, 53; 52, 54; 53, identifier:len; 54, argument_list; 54, 55; 55, identifier:data_files; 56, block; 56, 57; 57, raise_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:Exception; 60, argument_list; 60, 61; 61, string:'number of frequencies does not match number of data files'; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:data_list; 65, list:[]; 66, for_statement; 66, 67; 66, 70; 66, 75; 67, pattern_list; 67, 68; 67, 69; 68, identifier:frequency; 69, identifier:filename; 70, call; 70, 71; 70, 72; 71, identifier:zip; 72, argument_list; 72, 73; 72, 74; 73, identifier:frequencies; 74, identifier:data_files; 75, block; 75, 76; 75, 83; 75, 89; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:subdata; 79, call; 79, 80; 79, 81; 80, identifier:load_mod_file; 81, argument_list; 81, 82; 82, identifier:filename; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:subdata; 87, string:'frequency'; 88, identifier:frequency; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:data_list; 93, identifier:append; 94, argument_list; 94, 95; 95, identifier:subdata; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:df; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:pd; 102, identifier:concat; 103, argument_list; 103, 104; 104, identifier:data_list; 105, return_statement; 105, 106; 106, expression_list; 106, 107; 106, 108; 106, 109; 107, identifier:df; 108, None; 109, None | def load_seit_data(directory, frequency_file='frequencies.dat',
data_prefix='volt_', **kwargs):
frequencies = np.loadtxt(directory + os.sep + frequency_file)
data_files = sorted(glob(directory + os.sep + data_prefix + '*'))
if frequencies.size != len(data_files):
raise Exception(
'number of frequencies does not match number of data files')
data_list = []
for frequency, filename in zip(frequencies, data_files):
subdata = load_mod_file(filename)
subdata['frequency'] = frequency
data_list.append(subdata)
df = pd.concat(data_list)
return df, None, None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:parse_date; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:date; 6, block; 6, 7; 6, 30; 6, 67; 7, if_statement; 7, 8; 7, 13; 8, comparison_operator:is; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:date_format; 12, None; 13, block; 13, 14; 14, return_statement; 14, 15; 15, call; 15, 16; 15, 29; 16, attribute; 16, 17; 16, 28; 17, call; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:datetime; 21, identifier:datetime; 22, identifier:strptime; 23, argument_list; 23, 24; 23, 25; 24, identifier:date; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:date_format; 28, identifier:date; 29, argument_list; 30, if_statement; 30, 31; 30, 38; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:re; 34, identifier:match; 35, argument_list; 35, 36; 35, 37; 36, string:'\d{8}$'; 37, identifier:date; 38, block; 38, 39; 39, return_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:datetime; 43, identifier:date; 44, argument_list; 44, 45; 45, list_splat; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:map; 48, argument_list; 48, 49; 48, 50; 49, identifier:int; 50, tuple; 50, 51; 50, 56; 50, 62; 51, subscript; 51, 52; 51, 53; 52, identifier:date; 53, slice; 53, 54; 53, 55; 54, colon; 55, integer:4; 56, subscript; 56, 57; 56, 58; 57, identifier:date; 58, slice; 58, 59; 58, 60; 58, 61; 59, integer:4; 60, colon; 61, integer:6; 62, subscript; 62, 63; 62, 64; 63, identifier:date; 64, slice; 64, 65; 64, 66; 65, integer:6; 66, colon; 67, try_statement; 67, 68; 67, 134; 68, block; 68, 69; 68, 79; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:parts; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:date_delim; 75, identifier:split; 76, argument_list; 76, 77; 76, 78; 77, identifier:date; 78, integer:2; 79, if_statement; 79, 80; 79, 86; 80, comparison_operator:==; 80, 81; 80, 85; 81, call; 81, 82; 81, 83; 82, identifier:len; 83, argument_list; 83, 84; 84, identifier:parts; 85, integer:3; 86, block; 86, 87; 87, if_statement; 87, 88; 87, 96; 87, 109; 88, comparison_operator:==; 88, 89; 88, 95; 89, call; 89, 90; 89, 91; 90, identifier:len; 91, argument_list; 91, 92; 92, subscript; 92, 93; 92, 94; 93, identifier:parts; 94, integer:0; 95, integer:4; 96, block; 96, 97; 97, return_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:datetime; 101, identifier:date; 102, argument_list; 102, 103; 103, list_splat; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:map; 106, argument_list; 106, 107; 106, 108; 107, identifier:int; 108, identifier:parts; 109, elif_clause; 109, 110; 109, 118; 110, comparison_operator:==; 110, 111; 110, 117; 111, call; 111, 112; 111, 113; 112, identifier:len; 113, argument_list; 113, 114; 114, subscript; 114, 115; 114, 116; 115, identifier:parts; 116, integer:2; 117, integer:4; 118, block; 118, 119; 119, return_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:datetime; 123, identifier:date; 124, argument_list; 124, 125; 125, list_splat; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:map; 128, argument_list; 128, 129; 128, 130; 129, identifier:int; 130, call; 130, 131; 130, 132; 131, identifier:reversed; 132, argument_list; 132, 133; 133, identifier:parts; 134, except_clause; 134, 135; 134, 136; 134, 137; 135, identifier:TypeError; 136, identifier:ValueError; 137, block; 137, 138; 138, raise_statement; 138, 139; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:reader; 142, identifier:DataError; 143, argument_list; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, string:'Bad date format: "{}"'; 147, identifier:format; 148, argument_list; 148, 149; 149, identifier:date | def parse_date(self, date):
if self.date_format is not None:
return datetime.datetime.strptime(date, self.date_format).date()
if re.match('\d{8}$', date):
return datetime.date(*map(int, (date[:4], date[4:6], date[6:])))
try:
parts = date_delim.split(date, 2)
if len(parts) == 3:
if len(parts[0]) == 4:
return datetime.date(*map(int, parts))
elif len(parts[2]) == 4:
return datetime.date(*map(int, reversed(parts)))
except TypeError, ValueError:
raise reader.DataError('Bad date format: "{}"'.format(date)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:commit; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:if_match; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:wait; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:timeout; 13, None; 14, block; 14, 15; 14, 37; 14, 52; 14, 60; 14, 91; 14, 102; 14, 117; 14, 121; 14, 180; 15, if_statement; 15, 16; 15, 20; 16, not_operator; 16, 17; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_changes; 20, block; 20, 21; 20, 36; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:LOG; 25, identifier:debug; 26, argument_list; 26, 27; 26, 28; 26, 33; 27, string:"No changes available for %s: %s"; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:__class__; 32, identifier:__name__; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:resource_id; 36, return_statement; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:LOG; 41, identifier:debug; 42, argument_list; 42, 43; 42, 44; 42, 49; 43, string:"Apply all the changes on the current %s: %s"; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:__class__; 48, identifier:__name__; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:resource_id; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:client; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_get_client; 59, argument_list; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:endpoint; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:_endpoint; 68, identifier:format; 69, argument_list; 69, 70; 69, 77; 69, 84; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:resource_id; 72, boolean_operator:or; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:resource_id; 76, string:""; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:parent_id; 79, boolean_operator:or; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:parent_id; 83, string:""; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:grandparent_id; 86, boolean_operator:or; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:grandparent_id; 90, string:""; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:request_body; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:dump; 98, argument_list; 98, 99; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:include_read_only; 101, False; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:response; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:client; 108, identifier:update_resource; 109, argument_list; 109, 110; 109, 111; 109, 114; 110, identifier:endpoint; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:data; 113, identifier:request_body; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:if_match; 116, identifier:if_match; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:elapsed_time; 120, integer:0; 121, while_statement; 121, 122; 121, 123; 121, 171; 122, identifier:wait; 123, block; 123, 124; 123, 130; 123, 138; 123, 146; 123, 160; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:refresh; 129, argument_list; 130, if_statement; 130, 131; 130, 136; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:is_ready; 135, argument_list; 136, block; 136, 137; 137, break_statement; 138, expression_statement; 138, 139; 139, augmented_assignment:+=; 139, 140; 139, 141; 140, identifier:elapsed_time; 141, attribute; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:CONFIG; 144, identifier:HNV; 145, identifier:retry_interval; 146, if_statement; 146, 147; 146, 152; 147, boolean_operator:and; 147, 148; 147, 149; 148, identifier:timeout; 149, comparison_operator:>; 149, 150; 149, 151; 150, identifier:elapsed_time; 151, identifier:timeout; 152, block; 152, 153; 153, raise_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:exception; 157, identifier:TimeOut; 158, argument_list; 158, 159; 159, string:"The request timed out."; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:time; 164, identifier:sleep; 165, argument_list; 165, 166; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:CONFIG; 169, identifier:HNV; 170, identifier:retry_interval; 171, else_clause; 171, 172; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:_reset_model; 178, argument_list; 178, 179; 179, identifier:response; 180, return_statement; 180, 181; 181, identifier:self | def commit(self, if_match=None, wait=True, timeout=None):
if not self._changes:
LOG.debug("No changes available for %s: %s",
self.__class__.__name__, self.resource_id)
return
LOG.debug("Apply all the changes on the current %s: %s",
self.__class__.__name__, self.resource_id)
client = self._get_client()
endpoint = self._endpoint.format(
resource_id=self.resource_id or "",
parent_id=self.parent_id or "",
grandparent_id=self.grandparent_id or "")
request_body = self.dump(include_read_only=False)
response = client.update_resource(endpoint, data=request_body,
if_match=if_match)
elapsed_time = 0
while wait:
self.refresh()
if self.is_ready():
break
elapsed_time += CONFIG.HNV.retry_interval
if timeout and elapsed_time > timeout:
raise exception.TimeOut("The request timed out.")
time.sleep(CONFIG.HNV.retry_interval)
else:
self._reset_model(response)
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:plot_histograms; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:ertobj; 5, identifier:keys; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 30; 8, 44; 8, 56; 8, 60; 8, 70; 8, 124; 8, 414; 8, 423; 9, if_statement; 9, 10; 9, 17; 9, 22; 10, call; 10, 11; 10, 12; 11, identifier:isinstance; 12, argument_list; 12, 13; 12, 14; 13, identifier:ertobj; 14, attribute; 14, 15; 14, 16; 15, identifier:pd; 16, identifier:DataFrame; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:df; 21, identifier:ertobj; 22, else_clause; 22, 23; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:df; 27, attribute; 27, 28; 27, 29; 28, identifier:ertobj; 29, identifier:data; 30, if_statement; 30, 31; 30, 38; 31, comparison_operator:==; 31, 32; 31, 37; 32, subscript; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:df; 35, identifier:shape; 36, integer:0; 37, integer:0; 38, block; 38, 39; 39, raise_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:Exception; 42, argument_list; 42, 43; 43, string:'No data present, cannot plot'; 44, if_statement; 44, 45; 44, 50; 45, call; 45, 46; 45, 47; 46, identifier:isinstance; 47, argument_list; 47, 48; 47, 49; 48, identifier:keys; 49, identifier:str; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:keys; 54, list:[keys, ]; 54, 55; 55, identifier:keys; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:figures; 59, dictionary; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:merge_figs; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:kwargs; 66, identifier:get; 67, argument_list; 67, 68; 67, 69; 68, string:'merge'; 69, True; 70, if_statement; 70, 71; 70, 72; 71, identifier:merge_figs; 72, block; 72, 73; 72, 77; 72, 84; 72, 90; 72, 98; 72, 115; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:nr_x; 76, integer:2; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:nr_y; 80, call; 80, 81; 80, 82; 81, identifier:len; 82, argument_list; 82, 83; 83, identifier:keys; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:size_x; 87, binary_operator:/; 87, 88; 87, 89; 88, integer:15; 89, float:2.54; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:size_y; 93, binary_operator:/; 93, 94; 93, 97; 94, binary_operator:*; 94, 95; 94, 96; 95, integer:5; 96, identifier:nr_y; 97, float:2.54; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 103; 100, pattern_list; 100, 101; 100, 102; 101, identifier:fig; 102, identifier:axes_all; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:plt; 106, identifier:subplots; 107, argument_list; 107, 108; 107, 109; 107, 110; 108, identifier:nr_y; 109, identifier:nr_x; 110, keyword_argument; 110, 111; 110, 112; 111, identifier:figsize; 112, tuple; 112, 113; 112, 114; 113, identifier:size_x; 114, identifier:size_y; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:axes_all; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:np; 121, identifier:atleast_2d; 122, argument_list; 122, 123; 123, identifier:axes_all; 124, for_statement; 124, 125; 124, 128; 124, 132; 125, pattern_list; 125, 126; 125, 127; 126, identifier:row_nr; 127, identifier:key; 128, call; 128, 129; 128, 130; 129, identifier:enumerate; 130, argument_list; 130, 131; 131, identifier:keys; 132, block; 132, 133; 132, 143; 132, 151; 132, 163; 132, 174; 132, 187; 132, 199; 132, 210; 132, 246; 132, 252; 132, 265; 132, 277; 132, 284; 132, 300; 132, 315; 132, 330; 132, 398; 132, 404; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 136; 135, identifier:print; 136, argument_list; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, string:'Generating histogram plot for key: {0}'; 140, identifier:format; 141, argument_list; 141, 142; 142, identifier:key; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:subdata_raw; 146, attribute; 146, 147; 146, 150; 147, subscript; 147, 148; 147, 149; 148, identifier:df; 149, identifier:key; 150, identifier:values; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:subdata; 154, subscript; 154, 155; 154, 156; 155, identifier:subdata_raw; 156, unary_operator:~; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:np; 160, identifier:isnan; 161, argument_list; 161, 162; 162, identifier:subdata_raw; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:subdata; 166, subscript; 166, 167; 166, 168; 167, identifier:subdata; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:np; 171, identifier:isfinite; 172, argument_list; 172, 173; 173, identifier:subdata; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:subdata_log10_with_nan; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:np; 180, identifier:log10; 181, argument_list; 181, 182; 182, subscript; 182, 183; 182, 184; 183, identifier:subdata; 184, comparison_operator:>; 184, 185; 184, 186; 185, identifier:subdata; 186, integer:0; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:subdata_log10; 190, subscript; 190, 191; 190, 192; 191, identifier:subdata_log10_with_nan; 192, unary_operator:~; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:np; 196, identifier:isnan; 197, argument_list; 197, 198; 198, identifier:subdata_log10_with_nan; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:subdata_log10; 202, subscript; 202, 203; 202, 204; 203, identifier:subdata_log10; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:np; 207, identifier:isfinite; 208, argument_list; 208, 209; 209, identifier:subdata_log10; 210, if_statement; 210, 211; 210, 212; 210, 223; 211, identifier:merge_figs; 212, block; 212, 213; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:axes; 216, call; 216, 217; 216, 222; 217, attribute; 217, 218; 217, 221; 218, subscript; 218, 219; 218, 220; 219, identifier:axes_all; 220, identifier:row_nr; 221, identifier:squeeze; 222, argument_list; 223, else_clause; 223, 224; 224, block; 224, 225; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 230; 227, pattern_list; 227, 228; 227, 229; 228, identifier:fig; 229, identifier:axes; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:plt; 233, identifier:subplots; 234, argument_list; 234, 235; 234, 236; 234, 237; 235, integer:1; 236, integer:2; 237, keyword_argument; 237, 238; 237, 239; 238, identifier:figsize; 239, tuple; 239, 240; 239, 243; 240, binary_operator:/; 240, 241; 240, 242; 241, integer:10; 242, float:2.54; 243, binary_operator:/; 243, 244; 243, 245; 244, integer:5; 245, float:2.54; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:ax; 249, subscript; 249, 250; 249, 251; 250, identifier:axes; 251, integer:0; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:ax; 256, identifier:hist; 257, argument_list; 257, 258; 257, 259; 258, identifier:subdata; 259, call; 259, 260; 259, 261; 260, identifier:_get_nr_bins; 261, argument_list; 261, 262; 262, attribute; 262, 263; 262, 264; 263, identifier:subdata; 264, identifier:size; 265, expression_statement; 265, 266; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:ax; 269, identifier:set_xlabel; 270, argument_list; 270, 271; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:units; 274, identifier:get_label; 275, argument_list; 275, 276; 276, identifier:key; 277, expression_statement; 277, 278; 278, call; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:ax; 281, identifier:set_ylabel; 282, argument_list; 282, 283; 283, string:'count'; 284, expression_statement; 284, 285; 285, call; 285, 286; 285, 291; 286, attribute; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:ax; 289, identifier:xaxis; 290, identifier:set_major_locator; 291, argument_list; 291, 292; 292, call; 292, 293; 292, 298; 293, attribute; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:mpl; 296, identifier:ticker; 297, identifier:MaxNLocator; 298, argument_list; 298, 299; 299, integer:5; 300, expression_statement; 300, 301; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:ax; 304, identifier:tick_params; 305, argument_list; 305, 306; 305, 309; 305, 312; 306, keyword_argument; 306, 307; 306, 308; 307, identifier:axis; 308, string:'both'; 309, keyword_argument; 309, 310; 309, 311; 310, identifier:which; 311, string:'major'; 312, keyword_argument; 312, 313; 312, 314; 313, identifier:labelsize; 314, integer:6; 315, expression_statement; 315, 316; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:ax; 319, identifier:tick_params; 320, argument_list; 320, 321; 320, 324; 320, 327; 321, keyword_argument; 321, 322; 321, 323; 322, identifier:axis; 323, string:'both'; 324, keyword_argument; 324, 325; 324, 326; 325, identifier:which; 326, string:'minor'; 327, keyword_argument; 327, 328; 327, 329; 328, identifier:labelsize; 329, integer:6; 330, if_statement; 330, 331; 330, 336; 330, 395; 331, comparison_operator:>; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:subdata_log10; 334, identifier:size; 335, integer:0; 336, block; 336, 337; 336, 343; 336, 356; 336, 372; 336, 379; 337, expression_statement; 337, 338; 338, assignment; 338, 339; 338, 340; 339, identifier:ax; 340, subscript; 340, 341; 340, 342; 341, identifier:axes; 342, integer:1; 343, expression_statement; 343, 344; 344, call; 344, 345; 344, 348; 345, attribute; 345, 346; 345, 347; 346, identifier:ax; 347, identifier:hist; 348, argument_list; 348, 349; 348, 350; 349, identifier:subdata_log10; 350, call; 350, 351; 350, 352; 351, identifier:_get_nr_bins; 352, argument_list; 352, 353; 353, attribute; 353, 354; 353, 355; 354, identifier:subdata; 355, identifier:size; 356, expression_statement; 356, 357; 357, call; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, identifier:ax; 360, identifier:set_xlabel; 361, argument_list; 361, 362; 362, binary_operator:+; 362, 363; 362, 371; 363, binary_operator:+; 363, 364; 363, 365; 364, string:r'$log_{10}($'; 365, call; 365, 366; 365, 369; 366, attribute; 366, 367; 366, 368; 367, identifier:units; 368, identifier:get_label; 369, argument_list; 369, 370; 370, identifier:key; 371, string:')'; 372, expression_statement; 372, 373; 373, call; 373, 374; 373, 377; 374, attribute; 374, 375; 374, 376; 375, identifier:ax; 376, identifier:set_ylabel; 377, argument_list; 377, 378; 378, string:'count'; 379, expression_statement; 379, 380; 380, call; 380, 381; 380, 386; 381, attribute; 381, 382; 381, 385; 382, attribute; 382, 383; 382, 384; 383, identifier:ax; 384, identifier:xaxis; 385, identifier:set_major_locator; 386, argument_list; 386, 387; 387, call; 387, 388; 387, 393; 388, attribute; 388, 389; 388, 392; 389, attribute; 389, 390; 389, 391; 390, identifier:mpl; 391, identifier:ticker; 392, identifier:MaxNLocator; 393, argument_list; 393, 394; 394, integer:5; 395, else_clause; 395, 396; 396, block; 396, 397; 397, pass_statement; 398, expression_statement; 398, 399; 399, call; 399, 400; 399, 403; 400, attribute; 400, 401; 400, 402; 401, identifier:fig; 402, identifier:tight_layout; 403, argument_list; 404, if_statement; 404, 405; 404, 407; 405, not_operator; 405, 406; 406, identifier:merge_figs; 407, block; 407, 408; 408, expression_statement; 408, 409; 409, assignment; 409, 410; 409, 413; 410, subscript; 410, 411; 410, 412; 411, identifier:figures; 412, identifier:key; 413, identifier:fig; 414, if_statement; 414, 415; 414, 416; 415, identifier:merge_figs; 416, block; 416, 417; 417, expression_statement; 417, 418; 418, assignment; 418, 419; 418, 422; 419, subscript; 419, 420; 419, 421; 420, identifier:figures; 421, string:'all'; 422, identifier:fig; 423, return_statement; 423, 424; 424, identifier:figures | def plot_histograms(ertobj, keys, **kwargs):
if isinstance(ertobj, pd.DataFrame):
df = ertobj
else:
df = ertobj.data
if df.shape[0] == 0:
raise Exception('No data present, cannot plot')
if isinstance(keys, str):
keys = [keys, ]
figures = {}
merge_figs = kwargs.get('merge', True)
if merge_figs:
nr_x = 2
nr_y = len(keys)
size_x = 15 / 2.54
size_y = 5 * nr_y / 2.54
fig, axes_all = plt.subplots(nr_y, nr_x, figsize=(size_x, size_y))
axes_all = np.atleast_2d(axes_all)
for row_nr, key in enumerate(keys):
print('Generating histogram plot for key: {0}'.format(key))
subdata_raw = df[key].values
subdata = subdata_raw[~np.isnan(subdata_raw)]
subdata = subdata[np.isfinite(subdata)]
subdata_log10_with_nan = np.log10(subdata[subdata > 0])
subdata_log10 = subdata_log10_with_nan[~np.isnan(
subdata_log10_with_nan)
]
subdata_log10 = subdata_log10[np.isfinite(subdata_log10)]
if merge_figs:
axes = axes_all[row_nr].squeeze()
else:
fig, axes = plt.subplots(1, 2, figsize=(10 / 2.54, 5 / 2.54))
ax = axes[0]
ax.hist(
subdata,
_get_nr_bins(subdata.size),
)
ax.set_xlabel(
units.get_label(key)
)
ax.set_ylabel('count')
ax.xaxis.set_major_locator(mpl.ticker.MaxNLocator(5))
ax.tick_params(axis='both', which='major', labelsize=6)
ax.tick_params(axis='both', which='minor', labelsize=6)
if subdata_log10.size > 0:
ax = axes[1]
ax.hist(
subdata_log10,
_get_nr_bins(subdata.size),
)
ax.set_xlabel(r'$log_{10}($' + units.get_label(key) + ')')
ax.set_ylabel('count')
ax.xaxis.set_major_locator(mpl.ticker.MaxNLocator(5))
else:
pass
fig.tight_layout()
if not merge_figs:
figures[key] = fig
if merge_figs:
figures['all'] = fig
return figures |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:plot_histograms_extra_dims; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:dataobj; 5, identifier:keys; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 30; 8, 59; 8, 63; 8, 100; 8, 104; 8, 111; 8, 121; 8, 145; 8, 155; 8, 163; 8, 171; 8, 185; 8, 193; 8, 201; 8, 224; 8, 233; 8, 237; 8, 426; 8, 445; 8, 465; 8, 471; 9, if_statement; 9, 10; 9, 17; 9, 22; 10, call; 10, 11; 10, 12; 11, identifier:isinstance; 12, argument_list; 12, 13; 12, 14; 13, identifier:dataobj; 14, attribute; 14, 15; 14, 16; 15, identifier:pd; 16, identifier:DataFrame; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:df_raw; 21, identifier:dataobj; 22, else_clause; 22, 23; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:df_raw; 27, attribute; 27, 28; 27, 29; 28, identifier:dataobj; 29, identifier:data; 30, if_statement; 30, 31; 30, 38; 30, 53; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:kwargs; 34, identifier:get; 35, argument_list; 35, 36; 35, 37; 36, string:'subquery'; 37, False; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:df; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:df_raw; 45, identifier:query; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:kwargs; 50, identifier:get; 51, argument_list; 51, 52; 52, string:'subquery'; 53, else_clause; 53, 54; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:df; 58, identifier:df_raw; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:split_timestamps; 62, True; 63, if_statement; 63, 64; 63, 65; 63, 88; 64, identifier:split_timestamps; 65, block; 65, 66; 65, 75; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:group_timestamps; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:df; 72, identifier:groupby; 73, argument_list; 73, 74; 74, string:'timestep'; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:N_ts; 78, call; 78, 79; 78, 80; 79, identifier:len; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:group_timestamps; 85, identifier:groups; 86, identifier:keys; 87, argument_list; 88, else_clause; 88, 89; 89, block; 89, 90; 89, 96; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:group_timestamps; 93, tuple; 93, 94; 93, 95; 94, string:'all'; 95, identifier:df; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:N_ts; 99, integer:1; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:columns; 103, identifier:keys; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:N_c; 107, call; 107, 108; 107, 109; 108, identifier:len; 109, argument_list; 109, 110; 110, identifier:columns; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:plot_log10; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:kwargs; 117, identifier:get; 118, argument_list; 118, 119; 118, 120; 119, string:'log10plot'; 120, False; 121, if_statement; 121, 122; 121, 123; 121, 134; 122, identifier:plot_log10; 123, block; 123, 124; 123, 130; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:transformers; 127, list:['lin', 'log10']; 127, 128; 127, 129; 128, string:'lin'; 129, string:'log10'; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:N_log10; 133, integer:2; 134, else_clause; 134, 135; 135, block; 135, 136; 135, 141; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:transformers; 139, list:['lin', ]; 139, 140; 140, string:'lin'; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:N_log10; 144, integer:1; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:Nx_max; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:kwargs; 151, identifier:get; 152, argument_list; 152, 153; 152, 154; 153, string:'Nx'; 154, integer:4; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:N; 158, binary_operator:*; 158, 159; 158, 162; 159, binary_operator:*; 159, 160; 159, 161; 160, identifier:N_ts; 161, identifier:N_c; 162, identifier:N_log10; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:Nx; 166, call; 166, 167; 166, 168; 167, identifier:min; 168, argument_list; 168, 169; 168, 170; 169, identifier:Nx_max; 170, identifier:N; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:Ny; 174, call; 174, 175; 174, 176; 175, identifier:int; 176, argument_list; 176, 177; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:np; 180, identifier:ceil; 181, argument_list; 181, 182; 182, binary_operator:/; 182, 183; 182, 184; 183, identifier:N; 184, identifier:Nx; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:size_x; 188, binary_operator:/; 188, 189; 188, 192; 189, binary_operator:*; 189, 190; 189, 191; 190, integer:5; 191, identifier:Nx; 192, float:2.54; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:size_y; 196, binary_operator:/; 196, 197; 196, 200; 197, binary_operator:*; 197, 198; 197, 199; 198, integer:5; 199, identifier:Ny; 200, float:2.54; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 206; 203, pattern_list; 203, 204; 203, 205; 204, identifier:fig; 205, identifier:axes; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:plt; 209, identifier:subplots; 210, argument_list; 210, 211; 210, 212; 210, 213; 210, 218; 210, 221; 211, identifier:Ny; 212, identifier:Nx; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:figsize; 215, tuple; 215, 216; 215, 217; 216, identifier:size_x; 217, identifier:size_y; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:sharex; 220, True; 221, keyword_argument; 221, 222; 221, 223; 222, identifier:sharey; 223, True; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:axes; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:np; 230, identifier:atleast_2d; 231, argument_list; 231, 232; 232, identifier:axes; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:index; 236, integer:0; 237, for_statement; 237, 238; 237, 241; 237, 242; 238, pattern_list; 238, 239; 238, 240; 239, identifier:ts_name; 240, identifier:tgroup; 241, identifier:group_timestamps; 242, block; 242, 243; 243, for_statement; 243, 244; 243, 245; 243, 246; 244, identifier:column; 245, identifier:columns; 246, block; 246, 247; 247, for_statement; 247, 248; 247, 249; 247, 250; 248, identifier:transformer; 249, identifier:transformers; 250, block; 250, 251; 250, 259; 250, 271; 250, 282; 250, 327; 250, 335; 250, 348; 250, 360; 250, 367; 250, 383; 250, 398; 250, 413; 250, 422; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:subdata_raw; 254, attribute; 254, 255; 254, 258; 255, subscript; 255, 256; 255, 257; 256, identifier:tgroup; 257, identifier:column; 258, identifier:values; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:subdata; 262, subscript; 262, 263; 262, 264; 263, identifier:subdata_raw; 264, unary_operator:~; 264, 265; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:np; 268, identifier:isnan; 269, argument_list; 269, 270; 270, identifier:subdata_raw; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:subdata; 274, subscript; 274, 275; 274, 276; 275, identifier:subdata; 276, call; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:np; 279, identifier:isfinite; 280, argument_list; 280, 281; 281, identifier:subdata; 282, if_statement; 282, 283; 282, 286; 283, comparison_operator:==; 283, 284; 283, 285; 284, identifier:transformer; 285, string:'log10'; 286, block; 286, 287; 286, 300; 286, 312; 286, 323; 287, expression_statement; 287, 288; 288, assignment; 288, 289; 288, 290; 289, identifier:subdata_log10_with_nan; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:np; 293, identifier:log10; 294, argument_list; 294, 295; 295, subscript; 295, 296; 295, 297; 296, identifier:subdata; 297, comparison_operator:>; 297, 298; 297, 299; 298, identifier:subdata; 299, integer:0; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:subdata_log10; 303, subscript; 303, 304; 303, 305; 304, identifier:subdata_log10_with_nan; 305, unary_operator:~; 305, 306; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:np; 309, identifier:isnan; 310, argument_list; 310, 311; 311, identifier:subdata_log10_with_nan; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 315; 314, identifier:subdata_log10; 315, subscript; 315, 316; 315, 317; 316, identifier:subdata_log10; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:np; 320, identifier:isfinite; 321, argument_list; 321, 322; 322, identifier:subdata_log10; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:subdata; 326, identifier:subdata_log10; 327, expression_statement; 327, 328; 328, assignment; 328, 329; 328, 330; 329, identifier:ax; 330, subscript; 330, 331; 330, 334; 331, attribute; 331, 332; 331, 333; 332, identifier:axes; 333, identifier:flat; 334, identifier:index; 335, expression_statement; 335, 336; 336, call; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:ax; 339, identifier:hist; 340, argument_list; 340, 341; 340, 342; 341, identifier:subdata; 342, call; 342, 343; 342, 344; 343, identifier:_get_nr_bins; 344, argument_list; 344, 345; 345, attribute; 345, 346; 345, 347; 346, identifier:subdata; 347, identifier:size; 348, expression_statement; 348, 349; 349, call; 349, 350; 349, 353; 350, attribute; 350, 351; 350, 352; 351, identifier:ax; 352, identifier:set_xlabel; 353, argument_list; 353, 354; 354, call; 354, 355; 354, 358; 355, attribute; 355, 356; 355, 357; 356, identifier:units; 357, identifier:get_label; 358, argument_list; 358, 359; 359, identifier:column; 360, expression_statement; 360, 361; 361, call; 361, 362; 361, 365; 362, attribute; 362, 363; 362, 364; 363, identifier:ax; 364, identifier:set_ylabel; 365, argument_list; 365, 366; 366, string:'count'; 367, expression_statement; 367, 368; 368, call; 368, 369; 368, 374; 369, attribute; 369, 370; 369, 373; 370, attribute; 370, 371; 370, 372; 371, identifier:ax; 372, identifier:xaxis; 373, identifier:set_major_locator; 374, argument_list; 374, 375; 375, call; 375, 376; 375, 381; 376, attribute; 376, 377; 376, 380; 377, attribute; 377, 378; 377, 379; 378, identifier:mpl; 379, identifier:ticker; 380, identifier:MaxNLocator; 381, argument_list; 381, 382; 382, integer:3; 383, expression_statement; 383, 384; 384, call; 384, 385; 384, 388; 385, attribute; 385, 386; 385, 387; 386, identifier:ax; 387, identifier:tick_params; 388, argument_list; 388, 389; 388, 392; 388, 395; 389, keyword_argument; 389, 390; 389, 391; 390, identifier:axis; 391, string:'both'; 392, keyword_argument; 392, 393; 392, 394; 393, identifier:which; 394, string:'major'; 395, keyword_argument; 395, 396; 395, 397; 396, identifier:labelsize; 397, integer:6; 398, expression_statement; 398, 399; 399, call; 399, 400; 399, 403; 400, attribute; 400, 401; 400, 402; 401, identifier:ax; 402, identifier:tick_params; 403, argument_list; 403, 404; 403, 407; 403, 410; 404, keyword_argument; 404, 405; 404, 406; 405, identifier:axis; 406, string:'both'; 407, keyword_argument; 407, 408; 407, 409; 408, identifier:which; 409, string:'minor'; 410, keyword_argument; 410, 411; 410, 412; 411, identifier:labelsize; 412, integer:6; 413, expression_statement; 413, 414; 414, call; 414, 415; 414, 418; 415, attribute; 415, 416; 415, 417; 416, identifier:ax; 417, identifier:set_title; 418, argument_list; 418, 419; 419, binary_operator:%; 419, 420; 419, 421; 420, string:"timestep: %d"; 421, identifier:ts_name; 422, expression_statement; 422, 423; 423, augmented_assignment:+=; 423, 424; 423, 425; 424, identifier:index; 425, integer:1; 426, for_statement; 426, 427; 426, 428; 426, 437; 427, identifier:ax; 428, attribute; 428, 429; 428, 436; 429, subscript; 429, 430; 429, 431; 429, 433; 430, identifier:axes; 431, slice; 431, 432; 432, colon; 433, slice; 433, 434; 433, 435; 434, integer:1; 435, colon; 436, identifier:flat; 437, block; 437, 438; 438, expression_statement; 438, 439; 439, call; 439, 440; 439, 443; 440, attribute; 440, 441; 440, 442; 441, identifier:ax; 442, identifier:set_ylabel; 443, argument_list; 443, 444; 444, string:''; 445, for_statement; 445, 446; 445, 447; 445, 457; 446, identifier:ax; 447, attribute; 447, 448; 447, 456; 448, subscript; 448, 449; 448, 450; 448, 454; 449, identifier:axes; 450, slice; 450, 451; 450, 452; 451, colon; 452, unary_operator:-; 452, 453; 453, integer:1; 454, slice; 454, 455; 455, colon; 456, identifier:flat; 457, block; 457, 458; 458, expression_statement; 458, 459; 459, call; 459, 460; 459, 463; 460, attribute; 460, 461; 460, 462; 461, identifier:ax; 462, identifier:set_xlabel; 463, argument_list; 463, 464; 464, string:''; 465, expression_statement; 465, 466; 466, call; 466, 467; 466, 470; 467, attribute; 467, 468; 467, 469; 468, identifier:fig; 469, identifier:tight_layout; 470, argument_list; 471, return_statement; 471, 472; 472, identifier:fig | def plot_histograms_extra_dims(dataobj, keys, **kwargs):
if isinstance(dataobj, pd.DataFrame):
df_raw = dataobj
else:
df_raw = dataobj.data
if kwargs.get('subquery', False):
df = df_raw.query(kwargs.get('subquery'))
else:
df = df_raw
split_timestamps = True
if split_timestamps:
group_timestamps = df.groupby('timestep')
N_ts = len(group_timestamps.groups.keys())
else:
group_timestamps = ('all', df)
N_ts = 1
columns = keys
N_c = len(columns)
plot_log10 = kwargs.get('log10plot', False)
if plot_log10:
transformers = ['lin', 'log10']
N_log10 = 2
else:
transformers = ['lin', ]
N_log10 = 1
Nx_max = kwargs.get('Nx', 4)
N = N_ts * N_c * N_log10
Nx = min(Nx_max, N)
Ny = int(np.ceil(N / Nx))
size_x = 5 * Nx / 2.54
size_y = 5 * Ny / 2.54
fig, axes = plt.subplots(Ny, Nx, figsize=(size_x, size_y), sharex=True,
sharey=True)
axes = np.atleast_2d(axes)
index = 0
for ts_name, tgroup in group_timestamps:
for column in columns:
for transformer in transformers:
subdata_raw = tgroup[column].values
subdata = subdata_raw[~np.isnan(subdata_raw)]
subdata = subdata[np.isfinite(subdata)]
if transformer == 'log10':
subdata_log10_with_nan = np.log10(subdata[subdata > 0])
subdata_log10 = subdata_log10_with_nan[~np.isnan(
subdata_log10_with_nan)
]
subdata_log10 = subdata_log10[np.isfinite(subdata_log10)]
subdata = subdata_log10
ax = axes.flat[index]
ax.hist(
subdata,
_get_nr_bins(subdata.size),
)
ax.set_xlabel(
units.get_label(column)
)
ax.set_ylabel('count')
ax.xaxis.set_major_locator(mpl.ticker.MaxNLocator(3))
ax.tick_params(axis='both', which='major', labelsize=6)
ax.tick_params(axis='both', which='minor', labelsize=6)
ax.set_title("timestep: %d" % ts_name)
index += 1
for ax in axes[:, 1:].flat:
ax.set_ylabel('')
for ax in axes[:-1, :].flat:
ax.set_xlabel('')
fig.tight_layout()
return fig |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 24; 2, function_name:request; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 4, identifier:self; 5, identifier:method; 6, identifier:url; 7, default_parameter; 7, 8; 7, 9; 8, identifier:params; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:headers; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:data; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:json; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:token_refresh_attempts; 21, integer:2; 22, dictionary_splat_pattern; 22, 23; 23, identifier:kwargs; 24, block; 24, 25; 24, 54; 24, 60; 24, 69; 24, 79; 24, 88; 24, 97; 24, 122; 24, 132; 24, 146; 24, 175; 25, if_statement; 25, 26; 25, 32; 26, call; 26, 27; 26, 28; 27, identifier:all; 28, argument_list; 28, 29; 29, list:[data, json]; 29, 30; 29, 31; 30, identifier:data; 31, identifier:json; 32, block; 32, 33; 32, 40; 32, 47; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:msg; 36, parenthesized_expression; 36, 37; 37, concatenated_string; 37, 38; 37, 39; 38, string:'"data" and "json" request parameters can not be used '; 39, string:'at the same time'; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:logging; 44, identifier:warn; 45, argument_list; 45, 46; 46, identifier:msg; 47, raise_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:exceptions; 51, identifier:GCPHTTPError; 52, argument_list; 52, 53; 53, identifier:msg; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:req_headers; 57, boolean_operator:or; 57, 58; 57, 59; 58, identifier:headers; 59, dictionary; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:req_headers; 64, identifier:update; 65, argument_list; 65, 66; 66, attribute; 66, 67; 66, 68; 67, identifier:_utils; 68, identifier:DEFAULT_REQUEST_HEADERS; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:req_kwargs; 72, dictionary; 72, 73; 72, 76; 73, pair; 73, 74; 73, 75; 74, string:'params'; 75, identifier:params; 76, pair; 76, 77; 76, 78; 77, string:'headers'; 78, identifier:req_headers; 79, if_statement; 79, 80; 79, 81; 80, identifier:data; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:req_kwargs; 86, string:'data'; 87, identifier:data; 88, if_statement; 88, 89; 88, 90; 89, identifier:json; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, subscript; 93, 94; 93, 95; 94, identifier:req_kwargs; 95, string:'json'; 96, identifier:json; 97, if_statement; 97, 98; 97, 99; 98, identifier:token_refresh_attempts; 99, block; 99, 100; 100, if_statement; 100, 101; 100, 108; 101, not_operator; 101, 102; 102, await; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:valid_token_set; 107, argument_list; 108, block; 108, 109; 108, 118; 109, expression_statement; 109, 110; 110, await; 110, 111; 111, call; 111, 112; 111, 117; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:_auth_client; 116, identifier:refresh_token; 117, argument_list; 118, expression_statement; 118, 119; 119, augmented_assignment:-=; 119, 120; 119, 121; 120, identifier:token_refresh_attempts; 121, integer:1; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:req_headers; 126, identifier:update; 127, argument_list; 127, 128; 128, dictionary; 128, 129; 129, pair; 129, 130; 129, 131; 130, string:'Authorization'; 131, string:f'Bearer {self._auth_client.token}'; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:request_id; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:kwargs; 138, identifier:get; 139, argument_list; 139, 140; 139, 141; 140, string:'request_id'; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:uuid; 144, identifier:uuid4; 145, argument_list; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:logging; 150, identifier:debug; 151, argument_list; 151, 152; 152, call; 152, 153; 152, 158; 153, attribute; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:_utils; 156, identifier:REQ_LOG_FMT; 157, identifier:format; 158, argument_list; 158, 159; 158, 162; 158, 169; 158, 172; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:request_id; 161, identifier:request_id; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:method; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:method; 167, identifier:upper; 168, argument_list; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:url; 171, identifier:url; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:kwargs; 174, identifier:req_kwargs; 175, try_statement; 175, 176; 175, 306; 175, 338; 175, 348; 176, block; 176, 177; 177, with_statement; 177, 178; 177, 194; 178, with_clause; 178, 179; 179, with_item; 179, 180; 180, as_pattern; 180, 181; 180, 192; 181, call; 181, 182; 181, 187; 182, attribute; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:_session; 186, identifier:request; 187, argument_list; 187, 188; 187, 189; 187, 190; 188, identifier:method; 189, identifier:url; 190, dictionary_splat; 190, 191; 191, identifier:req_kwargs; 192, as_pattern_target; 192, 193; 193, identifier:resp; 194, block; 194, 195; 194, 224; 194, 239; 194, 293; 194, 299; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:log_kw; 198, dictionary; 198, 199; 198, 202; 198, 209; 198, 214; 198, 219; 199, pair; 199, 200; 199, 201; 200, string:'request_id'; 201, identifier:request_id; 202, pair; 202, 203; 202, 204; 203, string:'method'; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:method; 207, identifier:upper; 208, argument_list; 209, pair; 209, 210; 209, 211; 210, string:'url'; 211, attribute; 211, 212; 211, 213; 212, identifier:resp; 213, identifier:url; 214, pair; 214, 215; 214, 216; 215, string:'status'; 216, attribute; 216, 217; 216, 218; 217, identifier:resp; 218, identifier:status; 219, pair; 219, 220; 219, 221; 220, string:'reason'; 221, attribute; 221, 222; 221, 223; 222, identifier:resp; 223, identifier:reason; 224, expression_statement; 224, 225; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:logging; 228, identifier:debug; 229, argument_list; 229, 230; 230, call; 230, 231; 230, 236; 231, attribute; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:_utils; 234, identifier:RESP_LOG_FMT; 235, identifier:format; 236, argument_list; 236, 237; 237, dictionary_splat; 237, 238; 238, identifier:log_kw; 239, if_statement; 239, 240; 239, 245; 240, comparison_operator:in; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:resp; 243, identifier:status; 244, identifier:REFRESH_STATUS_CODES; 245, block; 245, 246; 245, 255; 245, 284; 246, expression_statement; 246, 247; 247, call; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:logging; 250, identifier:warning; 251, argument_list; 251, 252; 252, concatenated_string; 252, 253; 252, 254; 253, string:f'[{request_id}] HTTP Status Code {resp.status}'; 254, string:f' returned requesting {resp.url}: {resp.reason}'; 255, if_statement; 255, 256; 255, 257; 256, identifier:token_refresh_attempts; 257, block; 257, 258; 257, 267; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:logging; 262, identifier:info; 263, argument_list; 263, 264; 264, concatenated_string; 264, 265; 264, 266; 265, string:f'[{request_id}] Attempting request to {resp.url} '; 266, string:'again.'; 267, return_statement; 267, 268; 268, await; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:self; 272, identifier:request; 273, argument_list; 273, 274; 273, 275; 273, 276; 273, 279; 273, 282; 274, identifier:method; 275, identifier:url; 276, keyword_argument; 276, 277; 276, 278; 277, identifier:token_refresh_attempts; 278, identifier:token_refresh_attempts; 279, keyword_argument; 279, 280; 279, 281; 280, identifier:request_id; 281, identifier:request_id; 282, dictionary_splat; 282, 283; 283, identifier:req_kwargs; 284, expression_statement; 284, 285; 285, call; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:logging; 288, identifier:warning; 289, argument_list; 289, 290; 290, concatenated_string; 290, 291; 290, 292; 291, string:f'[{request_id}] Max attempts refreshing auth token '; 292, string:f'exhausted while requesting {resp.url}'; 293, expression_statement; 293, 294; 294, call; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:resp; 297, identifier:raise_for_status; 298, argument_list; 299, return_statement; 299, 300; 300, await; 300, 301; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:resp; 304, identifier:text; 305, argument_list; 306, except_clause; 306, 307; 306, 313; 307, as_pattern; 307, 308; 307, 311; 308, attribute; 308, 309; 308, 310; 309, identifier:aiohttp; 310, identifier:ClientResponseError; 311, as_pattern_target; 311, 312; 312, identifier:e; 313, block; 313, 314; 313, 318; 313, 328; 314, expression_statement; 314, 315; 315, assignment; 315, 316; 315, 317; 316, identifier:msg; 317, string:f'[{request_id}] HTTP error response from {resp.url}: {e}'; 318, expression_statement; 318, 319; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:logging; 322, identifier:error; 323, argument_list; 323, 324; 323, 325; 324, identifier:msg; 325, keyword_argument; 325, 326; 325, 327; 326, identifier:exc_info; 327, identifier:e; 328, raise_statement; 328, 329; 329, call; 329, 330; 329, 333; 330, attribute; 330, 331; 330, 332; 331, identifier:exceptions; 332, identifier:GCPHTTPResponseError; 333, argument_list; 333, 334; 333, 335; 334, identifier:msg; 335, attribute; 335, 336; 335, 337; 336, identifier:resp; 337, identifier:status; 338, except_clause; 338, 339; 338, 345; 339, as_pattern; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, identifier:exceptions; 342, identifier:GCPHTTPResponseError; 343, as_pattern_target; 343, 344; 344, identifier:e; 345, block; 345, 346; 346, raise_statement; 346, 347; 347, identifier:e; 348, except_clause; 348, 349; 348, 353; 349, as_pattern; 349, 350; 349, 351; 350, identifier:Exception; 351, as_pattern_target; 351, 352; 352, identifier:e; 353, block; 353, 354; 353, 358; 353, 368; 354, expression_statement; 354, 355; 355, assignment; 355, 356; 355, 357; 356, identifier:msg; 357, string:f'[{request_id}] Request call failed: {e}'; 358, expression_statement; 358, 359; 359, call; 359, 360; 359, 363; 360, attribute; 360, 361; 360, 362; 361, identifier:logging; 362, identifier:error; 363, argument_list; 363, 364; 363, 365; 364, identifier:msg; 365, keyword_argument; 365, 366; 365, 367; 366, identifier:exc_info; 367, identifier:e; 368, raise_statement; 368, 369; 369, call; 369, 370; 369, 373; 370, attribute; 370, 371; 370, 372; 371, identifier:exceptions; 372, identifier:GCPHTTPError; 373, argument_list; 373, 374; 374, identifier:msg | async def request(self, method, url, params=None, headers=None,
data=None, json=None, token_refresh_attempts=2,
**kwargs):
if all([data, json]):
msg = ('"data" and "json" request parameters can not be used '
'at the same time')
logging.warn(msg)
raise exceptions.GCPHTTPError(msg)
req_headers = headers or {}
req_headers.update(_utils.DEFAULT_REQUEST_HEADERS)
req_kwargs = {
'params': params,
'headers': req_headers,
}
if data:
req_kwargs['data'] = data
if json:
req_kwargs['json'] = json
if token_refresh_attempts:
if not await self.valid_token_set():
await self._auth_client.refresh_token()
token_refresh_attempts -= 1
req_headers.update(
{'Authorization': f'Bearer {self._auth_client.token}'}
)
request_id = kwargs.get('request_id', uuid.uuid4())
logging.debug(_utils.REQ_LOG_FMT.format(
request_id=request_id,
method=method.upper(),
url=url,
kwargs=req_kwargs))
try:
async with self._session.request(method, url, **req_kwargs) as resp:
log_kw = {
'request_id': request_id,
'method': method.upper(),
'url': resp.url,
'status': resp.status,
'reason': resp.reason
}
logging.debug(_utils.RESP_LOG_FMT.format(**log_kw))
if resp.status in REFRESH_STATUS_CODES:
logging.warning(
f'[{request_id}] HTTP Status Code {resp.status}'
f' returned requesting {resp.url}: {resp.reason}')
if token_refresh_attempts:
logging.info(
f'[{request_id}] Attempting request to {resp.url} '
'again.')
return await self.request(
method, url,
token_refresh_attempts=token_refresh_attempts,
request_id=request_id,
**req_kwargs)
logging.warning(
f'[{request_id}] Max attempts refreshing auth token '
f'exhausted while requesting {resp.url}')
resp.raise_for_status()
return await resp.text()
except aiohttp.ClientResponseError as e:
msg = f'[{request_id}] HTTP error response from {resp.url}: {e}'
logging.error(msg, exc_info=e)
raise exceptions.GCPHTTPResponseError(msg, resp.status)
except exceptions.GCPHTTPResponseError as e:
raise e
except Exception as e:
msg = f'[{request_id}] Request call failed: {e}'
logging.error(msg, exc_info=e)
raise exceptions.GCPHTTPError(msg) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:unflatten; 3, parameters; 3, 4; 3, 5; 4, identifier:processed; 5, identifier:merge_rules; 6, block; 6, 7; 6, 13; 6, 179; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:unflattened; 10, call; 10, 11; 10, 12; 11, identifier:OrderedDict; 12, argument_list; 13, for_statement; 13, 14; 13, 15; 13, 16; 14, identifier:key; 15, identifier:processed; 16, block; 16, 17; 16, 21; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:current_node; 20, identifier:unflattened; 21, for_statement; 21, 22; 21, 25; 21, 30; 22, pattern_list; 22, 23; 22, 24; 23, identifier:end; 24, identifier:part; 25, call; 25, 26; 25, 27; 26, identifier:enumerate; 27, argument_list; 27, 28; 27, 29; 28, identifier:key; 29, integer:1; 30, block; 30, 31; 30, 105; 30, 114; 30, 124; 30, 148; 30, 169; 30, 175; 31, if_statement; 31, 32; 31, 37; 32, call; 32, 33; 32, 34; 33, identifier:isinstance; 34, argument_list; 34, 35; 34, 36; 35, identifier:part; 36, identifier:IdValue; 37, block; 37, 38; 37, 104; 38, for_statement; 38, 39; 38, 40; 38, 41; 38, 62; 39, identifier:node; 40, identifier:current_node; 41, block; 41, 42; 42, if_statement; 42, 43; 42, 56; 43, boolean_operator:and; 43, 44; 43, 49; 44, call; 44, 45; 44, 46; 45, identifier:isinstance; 46, argument_list; 46, 47; 46, 48; 47, identifier:node; 48, identifier:IdDict; 49, comparison_operator:==; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:node; 52, identifier:identifier; 53, attribute; 53, 54; 53, 55; 54, identifier:part; 55, identifier:identifier; 56, block; 56, 57; 56, 61; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:current_node; 60, identifier:node; 61, break_statement; 62, else_clause; 62, 63; 63, block; 63, 64; 63, 70; 63, 78; 63, 93; 63, 100; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:new_node; 67, call; 67, 68; 67, 69; 68, identifier:IdDict; 69, argument_list; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:new_node; 74, identifier:identifier; 75, attribute; 75, 76; 75, 77; 76, identifier:part; 77, identifier:identifier; 78, if_statement; 78, 79; 78, 84; 79, comparison_operator:is; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:part; 82, identifier:original_value; 83, None; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:new_node; 89, string:'id'; 90, attribute; 90, 91; 90, 92; 91, identifier:part; 92, identifier:original_value; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:current_node; 97, identifier:append; 98, argument_list; 98, 99; 99, identifier:new_node; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:current_node; 103, identifier:new_node; 104, continue_statement; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:node; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:current_node; 111, identifier:get; 112, argument_list; 112, 113; 113, identifier:part; 114, if_statement; 114, 115; 114, 118; 115, comparison_operator:is; 115, 116; 115, 117; 116, identifier:node; 117, None; 118, block; 118, 119; 118, 123; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:current_node; 122, identifier:node; 123, continue_statement; 124, if_statement; 124, 125; 124, 131; 125, comparison_operator:==; 125, 126; 125, 130; 126, call; 126, 127; 126, 128; 127, identifier:len; 128, argument_list; 128, 129; 129, identifier:key; 130, identifier:end; 131, block; 131, 132; 131, 147; 132, if_statement; 132, 133; 132, 138; 133, comparison_operator:is; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:processed; 136, identifier:key; 137, None; 138, block; 138, 139; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 144; 141, subscript; 141, 142; 141, 143; 142, identifier:current_node; 143, identifier:part; 144, subscript; 144, 145; 144, 146; 145, identifier:processed; 146, identifier:key; 147, continue_statement; 148, if_statement; 148, 149; 148, 156; 148, 161; 149, call; 149, 150; 149, 151; 150, identifier:isinstance; 151, argument_list; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:key; 154, identifier:end; 155, identifier:IdValue; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:new_node; 160, list:[]; 161, else_clause; 161, 162; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:new_node; 166, call; 166, 167; 166, 168; 167, identifier:OrderedDict; 168, argument_list; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 174; 171, subscript; 171, 172; 171, 173; 172, identifier:current_node; 173, identifier:part; 174, identifier:new_node; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:current_node; 178, identifier:new_node; 179, return_statement; 179, 180; 180, identifier:unflattened | def unflatten(processed, merge_rules):
unflattened = OrderedDict()
for key in processed:
current_node = unflattened
for end, part in enumerate(key, 1):
if isinstance(part, IdValue):
for node in current_node:
if isinstance(node, IdDict) and node.identifier == part.identifier:
current_node = node
break
else:
new_node = IdDict()
new_node.identifier = part.identifier
if part.original_value is not None:
new_node['id'] = part.original_value
current_node.append(new_node)
current_node = new_node
continue
node = current_node.get(part)
if node is not None:
current_node = node
continue
if len(key) == end:
if processed[key] is not None:
current_node[part] = processed[key]
continue
if isinstance(key[end], IdValue):
new_node = []
else:
new_node = OrderedDict()
current_node[part] = new_node
current_node = new_node
return unflattened |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:translate; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 105; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:translations; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 15; 11, identifier:lang; 12, attribute; 12, 13; 12, 14; 13, identifier:settings; 14, identifier:LANGUAGES; 15, block; 15, 16; 15, 28; 15, 57; 16, if_statement; 16, 17; 16, 26; 17, comparison_operator:==; 17, 18; 17, 21; 18, subscript; 18, 19; 18, 20; 19, identifier:lang; 20, integer:0; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_get_default_language; 25, argument_list; 26, block; 26, 27; 27, continue_statement; 28, if_statement; 28, 29; 28, 34; 29, comparison_operator:is; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:translatable_slug; 33, None; 34, block; 34, 35; 35, if_statement; 35, 36; 35, 43; 36, comparison_operator:not; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:translatable_slug; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:translatable_fields; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:translatable_fields; 49, binary_operator:+; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:translatable_fields; 53, tuple; 53, 54; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:translatable_slug; 57, for_statement; 57, 58; 57, 59; 57, 62; 58, identifier:field; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:translatable_fields; 62, block; 62, 63; 62, 98; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, pattern_list; 65, 66; 65, 67; 66, identifier:trans; 67, identifier:created; 68, call; 68, 69; 68, 74; 69, attribute; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:Translation; 72, identifier:objects; 73, identifier:get_or_create; 74, argument_list; 74, 75; 74, 80; 74, 90; 74, 93; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:object_id; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:id; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:content_type; 82, call; 82, 83; 82, 88; 83, attribute; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:ContentType; 86, identifier:objects; 87, identifier:get_for_model; 88, argument_list; 88, 89; 89, identifier:self; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:field; 92, identifier:field; 93, keyword_argument; 93, 94; 93, 95; 94, identifier:lang; 95, subscript; 95, 96; 95, 97; 96, identifier:lang; 97, integer:0; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:translations; 102, identifier:append; 103, argument_list; 103, 104; 104, identifier:trans; 105, return_statement; 105, 106; 106, identifier:translations | def translate(self):
translations = []
for lang in settings.LANGUAGES:
if lang[0] == self._get_default_language():
continue
if self.translatable_slug is not None:
if self.translatable_slug not in self.translatable_fields:
self.translatable_fields = self.translatable_fields + (self.translatable_slug,)
for field in self.translatable_fields:
trans, created = Translation.objects.get_or_create(
object_id=self.id,
content_type=ContentType.objects.get_for_model(self),
field=field,
lang=lang[0],
)
translations.append(trans)
return translations |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:set_translation; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:lang; 6, identifier:field; 7, identifier:text; 8, block; 8, 9; 8, 13; 8, 32; 8, 45; 8, 51; 8, 57; 8, 86; 8, 129; 8, 139; 8, 147; 8, 159; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:auto_slug_obj; 12, None; 13, if_statement; 13, 14; 13, 21; 14, comparison_operator:==; 14, 15; 14, 16; 15, identifier:lang; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_get_default_language; 20, argument_list; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:CanNotTranslate; 25, argument_list; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:_; 28, argument_list; 28, 29; 29, concatenated_string; 29, 30; 29, 31; 30, string:'You are not supposed to translate the default language. '; 31, string:'Use the model fields for translations in default language'; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:trans_obj; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:get_translation_obj; 39, argument_list; 39, 40; 39, 41; 39, 42; 40, identifier:lang; 41, identifier:field; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:create; 44, True; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:trans_obj; 49, identifier:translation; 50, identifier:text; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:trans_obj; 55, identifier:save; 56, argument_list; 57, if_statement; 57, 58; 57, 59; 58, identifier:INSTALLED_AUTOSLUG; 59, block; 59, 60; 60, if_statement; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:translatable_slug; 64, block; 64, 65; 65, try_statement; 65, 66; 65, 82; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:auto_slug_obj; 70, attribute; 70, 71; 70, 81; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:_meta; 76, identifier:get_field; 77, argument_list; 77, 78; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:translatable_slug; 81, identifier:populate_from; 82, except_clause; 82, 83; 82, 84; 83, identifier:AttributeError; 84, block; 84, 85; 85, pass_statement; 86, if_statement; 86, 87; 86, 88; 87, identifier:auto_slug_obj; 88, block; 88, 89; 88, 104; 88, 114; 88, 123; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:tobj; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:get_translation_obj; 96, argument_list; 96, 97; 96, 98; 96, 101; 97, identifier:lang; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:translatable_slug; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:create; 103, True; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:translation; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:get_translation; 111, argument_list; 111, 112; 111, 113; 112, identifier:lang; 113, identifier:auto_slug_obj; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:tobj; 118, identifier:translation; 119, call; 119, 120; 119, 121; 120, identifier:slugify; 121, argument_list; 121, 122; 122, identifier:translation; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:tobj; 127, identifier:save; 128, argument_list; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:key; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:_get_translation_cache_key; 136, argument_list; 136, 137; 136, 138; 137, identifier:lang; 138, identifier:field; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:cache; 143, identifier:set; 144, argument_list; 144, 145; 144, 146; 145, identifier:key; 146, identifier:text; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:cache; 151, identifier:delete; 152, argument_list; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:_get_translations_cache_key; 157, argument_list; 157, 158; 158, identifier:lang; 159, return_statement; 159, 160; 160, identifier:trans_obj | def set_translation(self, lang, field, text):
auto_slug_obj = None
if lang == self._get_default_language():
raise CanNotTranslate(
_('You are not supposed to translate the default language. '
'Use the model fields for translations in default language')
)
trans_obj = self.get_translation_obj(lang, field, create=True)
trans_obj.translation = text
trans_obj.save()
if INSTALLED_AUTOSLUG:
if self.translatable_slug:
try:
auto_slug_obj = self._meta.get_field(self.translatable_slug).populate_from
except AttributeError:
pass
if auto_slug_obj:
tobj = self.get_translation_obj(lang, self.translatable_slug, create=True)
translation = self.get_translation(lang, auto_slug_obj)
tobj.translation = slugify(translation)
tobj.save()
key = self._get_translation_cache_key(lang, field)
cache.set(key, text)
cache.delete(self._get_translations_cache_key(lang))
return trans_obj |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:jsonify; 3, parameters; 3, 4; 3, 5; 3, 9; 4, identifier:o; 5, default_parameter; 5, 6; 5, 7; 6, identifier:max_depth; 7, unary_operator:-; 7, 8; 8, integer:1; 9, default_parameter; 9, 10; 9, 11; 10, identifier:parse_enums; 11, identifier:PARSE_KEEP; 12, block; 12, 13; 12, 20; 12, 24; 12, 183; 13, if_statement; 13, 14; 13, 17; 14, comparison_operator:==; 14, 15; 14, 16; 15, identifier:max_depth; 16, integer:0; 17, block; 17, 18; 18, return_statement; 18, 19; 19, identifier:o; 20, expression_statement; 20, 21; 21, augmented_assignment:-=; 21, 22; 21, 23; 22, identifier:max_depth; 23, integer:1; 24, if_statement; 24, 25; 24, 30; 24, 122; 24, 144; 24, 166; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 29; 28, identifier:o; 29, identifier:dict; 30, block; 30, 31; 30, 42; 30, 103; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:keyattrs; 34, call; 34, 35; 34, 36; 35, identifier:getattr; 36, argument_list; 36, 37; 36, 40; 36, 41; 37, attribute; 37, 38; 37, 39; 38, identifier:o; 39, identifier:__class__; 40, string:'_altnames'; 41, dictionary; 42, function_definition; 42, 43; 42, 44; 42, 47; 43, function_name:_getter; 44, parameters; 44, 45; 44, 46; 45, identifier:key; 46, identifier:value; 47, block; 47, 48; 47, 58; 47, 67; 47, 77; 47, 90; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:key; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:keyattrs; 54, identifier:get; 55, argument_list; 55, 56; 55, 57; 56, identifier:key; 57, identifier:key; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:other; 61, call; 61, 62; 61, 63; 62, identifier:getattr; 63, argument_list; 63, 64; 63, 65; 63, 66; 64, identifier:o; 65, identifier:key; 66, identifier:value; 67, if_statement; 67, 68; 67, 72; 68, call; 68, 69; 68, 70; 69, identifier:callable; 70, argument_list; 70, 71; 71, identifier:other; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:other; 76, identifier:value; 77, if_statement; 77, 78; 77, 83; 78, call; 78, 79; 78, 80; 79, identifier:isinstance; 80, argument_list; 80, 81; 80, 82; 81, identifier:key; 82, identifier:Enum; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:key; 87, attribute; 87, 88; 87, 89; 88, identifier:key; 89, identifier:name; 90, return_statement; 90, 91; 91, expression_list; 91, 92; 91, 93; 92, identifier:key; 93, call; 93, 94; 93, 95; 94, identifier:jsonify; 95, argument_list; 95, 96; 95, 97; 95, 100; 96, identifier:other; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:max_depth; 99, identifier:max_depth; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:parse_enums; 102, identifier:parse_enums; 103, return_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:dict; 106, generator_expression; 106, 107; 106, 112; 107, call; 107, 108; 107, 109; 108, identifier:_getter; 109, argument_list; 109, 110; 109, 111; 110, identifier:key; 111, identifier:value; 112, for_in_clause; 112, 113; 112, 116; 113, pattern_list; 113, 114; 113, 115; 114, identifier:key; 115, identifier:value; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:six; 119, identifier:iteritems; 120, argument_list; 120, 121; 121, identifier:o; 122, elif_clause; 122, 123; 122, 128; 123, call; 123, 124; 123, 125; 124, identifier:isinstance; 125, argument_list; 125, 126; 125, 127; 126, identifier:o; 127, identifier:list; 128, block; 128, 129; 129, return_statement; 129, 130; 130, list_comprehension; 130, 131; 130, 141; 131, call; 131, 132; 131, 133; 132, identifier:jsonify; 133, argument_list; 133, 134; 133, 135; 133, 138; 134, identifier:x; 135, keyword_argument; 135, 136; 135, 137; 136, identifier:max_depth; 137, identifier:max_depth; 138, keyword_argument; 138, 139; 138, 140; 139, identifier:parse_enums; 140, identifier:parse_enums; 141, for_in_clause; 141, 142; 141, 143; 142, identifier:x; 143, identifier:o; 144, elif_clause; 144, 145; 144, 150; 145, call; 145, 146; 145, 147; 146, identifier:isinstance; 147, argument_list; 147, 148; 147, 149; 148, identifier:o; 149, identifier:tuple; 150, block; 150, 151; 151, return_statement; 151, 152; 152, generator_expression; 152, 153; 152, 163; 153, call; 153, 154; 153, 155; 154, identifier:jsonify; 155, argument_list; 155, 156; 155, 157; 155, 160; 156, identifier:x; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:max_depth; 159, identifier:max_depth; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:parse_enums; 162, identifier:parse_enums; 163, for_in_clause; 163, 164; 163, 165; 164, identifier:x; 165, identifier:o; 166, elif_clause; 166, 167; 166, 172; 167, call; 167, 168; 167, 169; 168, identifier:isinstance; 169, argument_list; 169, 170; 169, 171; 170, identifier:o; 171, identifier:Enum; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:o; 176, call; 176, 177; 176, 178; 177, identifier:_parse_enum; 178, argument_list; 178, 179; 178, 180; 179, identifier:o; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:parse_enums; 182, identifier:parse_enums; 183, return_statement; 183, 184; 184, identifier:o | def jsonify(o, max_depth=-1, parse_enums=PARSE_KEEP):
if max_depth == 0:
return o
max_depth -= 1
if isinstance(o, dict):
keyattrs = getattr(o.__class__, '_altnames', {})
def _getter(key, value):
key = keyattrs.get(key, key)
other = getattr(o, key, value)
if callable(other):
other = value
if isinstance(key, Enum):
key = key.name
return key, jsonify(other, max_depth=max_depth, parse_enums=parse_enums)
return dict(_getter(key, value) for key, value in six.iteritems(o))
elif isinstance(o, list):
return [jsonify(x, max_depth=max_depth, parse_enums=parse_enums) for x in o]
elif isinstance(o, tuple):
return (jsonify(x, max_depth=max_depth, parse_enums=parse_enums) for x in o)
elif isinstance(o, Enum):
o = _parse_enum(o, parse_enums=parse_enums)
return o |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:b58encode; 3, parameters; 3, 4; 3, 5; 4, identifier:val; 5, default_parameter; 5, 6; 5, 7; 6, identifier:charset; 7, identifier:DEFAULT_CHARSET; 8, block; 8, 9; 8, 63; 8, 85; 8, 101; 8, 108; 8, 121; 8, 128; 8, 137; 8, 144; 8, 152; 8, 174; 8, 184; 8, 196; 9, function_definition; 9, 10; 9, 11; 9, 22; 10, function_name:_b58encode_int; 11, parameters; 11, 12; 11, 13; 12, identifier:int_; 13, default_parameter; 13, 14; 13, 15; 14, identifier:default; 15, call; 15, 16; 15, 17; 16, identifier:bytes; 17, argument_list; 17, 18; 18, list:[charset[0]]; 18, 19; 19, subscript; 19, 20; 19, 21; 20, identifier:charset; 21, integer:0; 22, block; 22, 23; 22, 31; 22, 35; 22, 61; 23, if_statement; 23, 24; 23, 28; 24, boolean_operator:and; 24, 25; 24, 27; 25, not_operator; 25, 26; 26, identifier:int_; 27, identifier:default; 28, block; 28, 29; 29, return_statement; 29, 30; 30, identifier:default; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:output; 34, string:b''; 35, while_statement; 35, 36; 35, 37; 36, identifier:int_; 37, block; 37, 38; 37, 48; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 43; 40, pattern_list; 40, 41; 40, 42; 41, identifier:int_; 42, identifier:idx; 43, call; 43, 44; 43, 45; 44, identifier:divmod; 45, argument_list; 45, 46; 45, 47; 46, identifier:int_; 47, identifier:base; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:output; 51, binary_operator:+; 51, 52; 51, 60; 52, subscript; 52, 53; 52, 54; 53, identifier:charset; 54, slice; 54, 55; 54, 56; 54, 57; 55, identifier:idx; 56, colon; 57, binary_operator:+; 57, 58; 57, 59; 58, identifier:idx; 59, integer:1; 60, identifier:output; 61, return_statement; 61, 62; 62, identifier:output; 63, if_statement; 63, 64; 63, 70; 64, not_operator; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:isinstance; 67, argument_list; 67, 68; 67, 69; 68, identifier:val; 69, identifier:bytes; 70, block; 70, 71; 71, raise_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:TypeError; 74, argument_list; 74, 75; 75, binary_operator:%; 75, 76; 75, 79; 76, concatenated_string; 76, 77; 76, 78; 77, string:"a bytes-like object is required, not '%s', "; 78, string:"use .encode('ascii') to encode unicode strings"; 79, attribute; 79, 80; 79, 84; 80, call; 80, 81; 80, 82; 81, identifier:type; 82, argument_list; 82, 83; 83, identifier:val; 84, identifier:__name__; 85, if_statement; 85, 86; 85, 91; 86, call; 86, 87; 86, 88; 87, identifier:isinstance; 88, argument_list; 88, 89; 88, 90; 89, identifier:charset; 90, identifier:str; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:charset; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:charset; 98, identifier:encode; 99, argument_list; 99, 100; 100, string:'ascii'; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:base; 104, call; 104, 105; 104, 106; 105, identifier:len; 106, argument_list; 106, 107; 107, identifier:charset; 108, if_statement; 108, 109; 108, 113; 109, not_operator; 109, 110; 110, comparison_operator:==; 110, 111; 110, 112; 111, identifier:base; 112, integer:58; 113, block; 113, 114; 114, raise_statement; 114, 115; 115, call; 115, 116; 115, 117; 116, identifier:ValueError; 117, argument_list; 117, 118; 118, binary_operator:%; 118, 119; 118, 120; 119, string:'charset base must be 58, not %s'; 120, identifier:base; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:pad_len; 124, call; 124, 125; 124, 126; 125, identifier:len; 126, argument_list; 126, 127; 127, identifier:val; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:val; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:val; 134, identifier:lstrip; 135, argument_list; 135, 136; 136, string:b'\0'; 137, expression_statement; 137, 138; 138, augmented_assignment:-=; 138, 139; 138, 140; 139, identifier:pad_len; 140, call; 140, 141; 140, 142; 141, identifier:len; 142, argument_list; 142, 143; 143, identifier:val; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 149; 146, pattern_list; 146, 147; 146, 148; 147, identifier:p; 148, identifier:acc; 149, expression_list; 149, 150; 149, 151; 150, integer:1; 151, integer:0; 152, for_statement; 152, 153; 152, 154; 152, 161; 153, identifier:char; 154, call; 154, 155; 154, 156; 155, identifier:deque; 156, argument_list; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:reversed; 159, argument_list; 159, 160; 160, identifier:val; 161, block; 161, 162; 161, 168; 162, expression_statement; 162, 163; 163, augmented_assignment:+=; 163, 164; 163, 165; 164, identifier:acc; 165, binary_operator:*; 165, 166; 165, 167; 166, identifier:p; 167, identifier:char; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:p; 171, binary_operator:<<; 171, 172; 171, 173; 172, identifier:p; 173, integer:8; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:result; 177, call; 177, 178; 177, 179; 178, identifier:_b58encode_int; 179, argument_list; 179, 180; 179, 181; 180, identifier:acc; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:default; 183, False; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:prefix; 187, binary_operator:*; 187, 188; 187, 195; 188, call; 188, 189; 188, 190; 189, identifier:bytes; 190, argument_list; 190, 191; 191, list:[charset[0]]; 191, 192; 192, subscript; 192, 193; 192, 194; 193, identifier:charset; 194, integer:0; 195, identifier:pad_len; 196, return_statement; 196, 197; 197, binary_operator:+; 197, 198; 197, 199; 198, identifier:prefix; 199, identifier:result | def b58encode(val, charset=DEFAULT_CHARSET):
def _b58encode_int(int_, default=bytes([charset[0]])):
if not int_ and default:
return default
output = b''
while int_:
int_, idx = divmod(int_, base)
output = charset[idx:idx+1] + output
return output
if not isinstance(val, bytes):
raise TypeError(
"a bytes-like object is required, not '%s', "
"use .encode('ascii') to encode unicode strings" %
type(val).__name__)
if isinstance(charset, str):
charset = charset.encode('ascii')
base = len(charset)
if not base == 58:
raise ValueError('charset base must be 58, not %s' % base)
pad_len = len(val)
val = val.lstrip(b'\0')
pad_len -= len(val)
p, acc = 1, 0
for char in deque(reversed(val)):
acc += p * char
p = p << 8
result = _b58encode_int(acc, default=False)
prefix = bytes([charset[0]]) * pad_len
return prefix + result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:m2m_callback; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 4, identifier:sender; 5, identifier:instance; 6, identifier:action; 7, identifier:reverse; 8, identifier:model; 9, identifier:pk_set; 10, identifier:using; 11, dictionary_splat_pattern; 11, 12; 12, identifier:kwargs; 13, block; 13, 14; 14, if_statement; 14, 15; 14, 25; 15, boolean_operator:and; 15, 16; 15, 20; 16, call; 16, 17; 16, 18; 17, identifier:validate_instance; 18, argument_list; 18, 19; 19, identifier:instance; 20, subscript; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:settings; 23, identifier:AUTOMATED_LOGGING; 24, string:'to_database'; 25, block; 25, 26; 26, if_statement; 26, 27; 26, 32; 27, comparison_operator:in; 27, 28; 27, 29; 28, identifier:action; 29, list:["post_add", 'post_remove']; 29, 30; 29, 31; 30, string:"post_add"; 31, string:'post_remove'; 32, block; 32, 33; 32, 50; 32, 127; 32, 211; 32, 217; 32, 223; 32, 351; 32, 357; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:modification; 36, list_comprehension; 36, 37; 36, 47; 37, call; 37, 38; 37, 43; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:model; 41, identifier:objects; 42, identifier:get; 43, argument_list; 43, 44; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:pk; 46, identifier:x; 47, for_in_clause; 47, 48; 47, 49; 48, identifier:x; 49, identifier:pk_set; 50, if_statement; 50, 51; 50, 64; 50, 71; 51, boolean_operator:and; 51, 52; 51, 61; 52, comparison_operator:in; 52, 53; 52, 54; 53, string:'al_chl'; 54, call; 54, 55; 54, 60; 55, attribute; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:instance; 58, identifier:__dict__; 59, identifier:keys; 60, argument_list; 61, attribute; 61, 62; 61, 63; 62, identifier:instance; 63, identifier:al_chl; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:changelog; 68, attribute; 68, 69; 68, 70; 69, identifier:instance; 70, identifier:al_chl; 71, else_clause; 71, 72; 72, block; 72, 73; 72, 79; 72, 87; 72, 98; 72, 113; 72, 121; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:changelog; 76, call; 76, 77; 76, 78; 77, identifier:ModelChangelog; 78, argument_list; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:changelog; 83, identifier:information; 84, call; 84, 85; 84, 86; 85, identifier:ModelObject; 86, argument_list; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 94; 89, attribute; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:changelog; 92, identifier:information; 93, identifier:value; 94, call; 94, 95; 94, 96; 95, identifier:repr; 96, argument_list; 96, 97; 97, identifier:instance; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:changelog; 103, identifier:information; 104, identifier:type; 105, call; 105, 106; 105, 111; 106, attribute; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:ContentType; 109, identifier:objects; 110, identifier:get_for_model; 111, argument_list; 111, 112; 112, identifier:instance; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 120; 115, attribute; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:changelog; 118, identifier:information; 119, identifier:save; 120, argument_list; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:changelog; 125, identifier:save; 126, argument_list; 127, for_statement; 127, 128; 127, 129; 127, 130; 128, identifier:f; 129, identifier:modification; 130, block; 130, 131; 130, 137; 130, 146; 130, 180; 130, 186; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:obj; 134, call; 134, 135; 134, 136; 135, identifier:ModelObject; 136, argument_list; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:obj; 141, identifier:value; 142, call; 142, 143; 142, 144; 143, identifier:repr; 144, argument_list; 144, 145; 145, identifier:f; 146, try_statement; 146, 147; 146, 161; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:obj; 152, identifier:type; 153, call; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:ContentType; 157, identifier:objects; 158, identifier:get_for_model; 159, argument_list; 159, 160; 160, identifier:f; 161, except_clause; 161, 162; 161, 163; 162, identifier:Exception; 163, block; 163, 164; 163, 173; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:logger; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:logging; 170, identifier:getLogger; 171, argument_list; 171, 172; 172, identifier:__name__; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:logger; 177, identifier:debug; 178, argument_list; 178, 179; 179, string:'Could not determin the type of the modification.'; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:obj; 184, identifier:save; 185, argument_list; 186, if_statement; 186, 187; 186, 190; 186, 200; 187, comparison_operator:==; 187, 188; 187, 189; 188, identifier:action; 189, string:'post_add'; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 198; 193, attribute; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:changelog; 196, identifier:inserted; 197, identifier:add; 198, argument_list; 198, 199; 199, identifier:obj; 200, else_clause; 200, 201; 201, block; 201, 202; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 209; 204, attribute; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:changelog; 207, identifier:removed; 208, identifier:add; 209, argument_list; 209, 210; 210, identifier:obj; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:changelog; 215, identifier:save; 216, argument_list; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:instance; 221, identifier:al_chl; 222, identifier:changelog; 223, if_statement; 223, 224; 223, 233; 223, 240; 224, comparison_operator:in; 224, 225; 224, 226; 225, string:'al_evt'; 226, call; 226, 227; 226, 232; 227, attribute; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:instance; 230, identifier:__dict__; 231, identifier:keys; 232, argument_list; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:target; 237, attribute; 237, 238; 237, 239; 238, identifier:instance; 239, identifier:al_evt; 240, else_clause; 240, 241; 241, block; 241, 242; 241, 248; 241, 256; 241, 267; 241, 273; 241, 286; 241, 303; 241, 311; 241, 322; 241, 337; 241, 345; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:target; 245, call; 245, 246; 245, 247; 246, identifier:Model; 247, argument_list; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:target; 252, identifier:user; 253, call; 253, 254; 253, 255; 254, identifier:get_current_user; 255, argument_list; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:target; 260, identifier:action; 261, conditional_expression:if; 261, 262; 261, 263; 261, 266; 262, integer:2; 263, comparison_operator:==; 263, 264; 263, 265; 264, identifier:action; 265, string:'post_add'; 266, integer:2; 267, expression_statement; 267, 268; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:target; 271, identifier:save; 272, argument_list; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:ct; 276, attribute; 276, 277; 276, 285; 277, call; 277, 278; 277, 283; 278, attribute; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:ContentType; 281, identifier:objects; 282, identifier:get_for_model; 283, argument_list; 283, 284; 284, identifier:instance; 285, identifier:app_label; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:target; 290, identifier:application; 291, subscript; 291, 292; 291, 302; 292, call; 292, 293; 292, 298; 293, attribute; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:Application; 296, identifier:objects; 297, identifier:get_or_create; 298, argument_list; 298, 299; 299, keyword_argument; 299, 300; 299, 301; 300, identifier:name; 301, identifier:ct; 302, integer:0; 303, expression_statement; 303, 304; 304, assignment; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:target; 307, identifier:information; 308, call; 308, 309; 308, 310; 309, identifier:ModelObject; 310, argument_list; 311, expression_statement; 311, 312; 312, assignment; 312, 313; 312, 318; 313, attribute; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:target; 316, identifier:information; 317, identifier:value; 318, call; 318, 319; 318, 320; 319, identifier:repr; 320, argument_list; 320, 321; 321, identifier:instance; 322, expression_statement; 322, 323; 323, assignment; 323, 324; 323, 329; 324, attribute; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:target; 327, identifier:information; 328, identifier:type; 329, call; 329, 330; 329, 335; 330, attribute; 330, 331; 330, 334; 331, attribute; 331, 332; 331, 333; 332, identifier:ContentType; 333, identifier:objects; 334, identifier:get_for_model; 335, argument_list; 335, 336; 336, identifier:instance; 337, expression_statement; 337, 338; 338, call; 338, 339; 338, 344; 339, attribute; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, identifier:target; 342, identifier:information; 343, identifier:save; 344, argument_list; 345, expression_statement; 345, 346; 346, assignment; 346, 347; 346, 350; 347, attribute; 347, 348; 347, 349; 348, identifier:instance; 349, identifier:al_evt; 350, identifier:target; 351, expression_statement; 351, 352; 352, assignment; 352, 353; 352, 356; 353, attribute; 353, 354; 353, 355; 354, identifier:target; 355, identifier:modification; 356, identifier:changelog; 357, expression_statement; 357, 358; 358, call; 358, 359; 358, 362; 359, attribute; 359, 360; 359, 361; 360, identifier:target; 361, identifier:save; 362, argument_list | def m2m_callback(sender, instance, action, reverse, model, pk_set, using, **kwargs):
if validate_instance(instance) and settings.AUTOMATED_LOGGING['to_database']:
if action in ["post_add", 'post_remove']:
modification = [model.objects.get(pk=x) for x in pk_set]
if 'al_chl' in instance.__dict__.keys() and instance.al_chl:
changelog = instance.al_chl
else:
changelog = ModelChangelog()
changelog.information = ModelObject()
changelog.information.value = repr(instance)
changelog.information.type = ContentType.objects.get_for_model(instance)
changelog.information.save()
changelog.save()
for f in modification:
obj = ModelObject()
obj.value = repr(f)
try:
obj.type = ContentType.objects.get_for_model(f)
except Exception:
logger = logging.getLogger(__name__)
logger.debug('Could not determin the type of the modification.')
obj.save()
if action == 'post_add':
changelog.inserted.add(obj)
else:
changelog.removed.add(obj)
changelog.save()
instance.al_chl = changelog
if 'al_evt' in instance.__dict__.keys():
target = instance.al_evt
else:
target = Model()
target.user = get_current_user()
target.action = 2 if action == 'post_add' else 2
target.save()
ct = ContentType.objects.get_for_model(instance).app_label
target.application = Application.objects.get_or_create(name=ct)[0]
target.information = ModelObject()
target.information.value = repr(instance)
target.information.type = ContentType.objects.get_for_model(instance)
target.information.save()
instance.al_evt = target
target.modification = changelog
target.save() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:normalize_allele_name; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:raw_allele; 5, default_parameter; 5, 6; 5, 7; 6, identifier:omit_dra1; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:infer_class2_pair; 10, True; 11, block; 11, 12; 11, 19; 11, 28; 11, 38; 11, 46; 11, 51; 11, 77; 11, 126; 11, 135; 11, 141; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:cache_key; 15, tuple; 15, 16; 15, 17; 15, 18; 16, identifier:raw_allele; 17, identifier:omit_dra1; 18, identifier:infer_class2_pair; 19, if_statement; 19, 20; 19, 23; 20, comparison_operator:in; 20, 21; 20, 22; 21, identifier:cache_key; 22, identifier:_normalized_allele_cache; 23, block; 23, 24; 24, return_statement; 24, 25; 25, subscript; 25, 26; 25, 27; 26, identifier:_normalized_allele_cache; 27, identifier:cache_key; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:parsed_alleles; 31, call; 31, 32; 31, 33; 32, identifier:parse_classi_or_classii_allele_name; 33, argument_list; 33, 34; 33, 35; 34, identifier:raw_allele; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:infer_pair; 37, identifier:infer_class2_pair; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:species; 41, attribute; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:parsed_alleles; 44, integer:0; 45, identifier:species; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:normalized_list; 49, list:[species]; 49, 50; 50, identifier:species; 51, if_statement; 51, 52; 51, 60; 52, boolean_operator:and; 52, 53; 52, 54; 53, identifier:omit_dra1; 54, comparison_operator:==; 54, 55; 54, 59; 55, call; 55, 56; 55, 57; 56, identifier:len; 57, argument_list; 57, 58; 58, identifier:parsed_alleles; 59, integer:2; 60, block; 60, 61; 60, 67; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 66; 63, pattern_list; 63, 64; 63, 65; 64, identifier:alpha; 65, identifier:beta; 66, identifier:parsed_alleles; 67, if_statement; 67, 68; 67, 71; 68, comparison_operator:==; 68, 69; 68, 70; 69, identifier:alpha; 70, identifier:_DRA1_0101; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:parsed_alleles; 75, list:[beta]; 75, 76; 76, identifier:beta; 77, for_statement; 77, 78; 77, 79; 77, 80; 78, identifier:parsed_allele; 79, identifier:parsed_alleles; 80, block; 80, 81; 81, if_statement; 81, 82; 81, 90; 81, 109; 82, comparison_operator:>; 82, 83; 82, 89; 83, call; 83, 84; 83, 85; 84, identifier:len; 85, argument_list; 85, 86; 86, attribute; 86, 87; 86, 88; 87, identifier:parsed_allele; 88, identifier:allele_family; 89, integer:0; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:normalized_list; 95, identifier:append; 96, argument_list; 96, 97; 97, binary_operator:%; 97, 98; 97, 99; 98, string:"%s*%s:%s"; 99, tuple; 99, 100; 99, 103; 99, 106; 100, attribute; 100, 101; 100, 102; 101, identifier:parsed_allele; 102, identifier:gene; 103, attribute; 103, 104; 103, 105; 104, identifier:parsed_allele; 105, identifier:allele_family; 106, attribute; 106, 107; 106, 108; 107, identifier:parsed_allele; 108, identifier:allele_code; 109, else_clause; 109, 110; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:normalized_list; 115, identifier:append; 116, argument_list; 116, 117; 117, binary_operator:%; 117, 118; 117, 119; 118, string:"%s%s"; 119, tuple; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:parsed_allele; 122, identifier:gene; 123, attribute; 123, 124; 123, 125; 124, identifier:parsed_allele; 125, identifier:allele_code; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:normalized; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, string:"-"; 132, identifier:join; 133, argument_list; 133, 134; 134, identifier:normalized_list; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:_normalized_allele_cache; 139, identifier:cache_key; 140, identifier:normalized; 141, return_statement; 141, 142; 142, identifier:normalized | def normalize_allele_name(raw_allele, omit_dra1=False, infer_class2_pair=True):
cache_key = (raw_allele, omit_dra1, infer_class2_pair)
if cache_key in _normalized_allele_cache:
return _normalized_allele_cache[cache_key]
parsed_alleles = parse_classi_or_classii_allele_name(
raw_allele, infer_pair=infer_class2_pair)
species = parsed_alleles[0].species
normalized_list = [species]
if omit_dra1 and len(parsed_alleles) == 2:
alpha, beta = parsed_alleles
if alpha == _DRA1_0101:
parsed_alleles = [beta]
for parsed_allele in parsed_alleles:
if len(parsed_allele.allele_family) > 0:
normalized_list.append("%s*%s:%s" % (
parsed_allele.gene,
parsed_allele.allele_family,
parsed_allele.allele_code))
else:
normalized_list.append("%s%s" % (
parsed_allele.gene,
parsed_allele.allele_code))
normalized = "-".join(normalized_list)
_normalized_allele_cache[cache_key] = normalized
return normalized |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.