sequence stringlengths 388 5.57k | docstring stringlengths 11 171 |
|---|---|
0 module [1];1 function_definition [2,3,5];2 function_name [] check_dataset_metadata;3 parameters [4];4 identifier [] client;5 block [6,16,22,63];6 expression_statement [7];7 assignment [8,9];8 identifier [] old_metadata;9 call [10,11];10 identifier [] list;11 argument_list [12];12 call [13,14];13 identifier [] _dataset_metadata_pre_0_3_4;14 argument_list [15];15 identifier [] client;16 if_statement [17,19];17 not_operator [18];18 identifier [] old_metadata;19 block [20];20 return_statement [21];21 True [];22 expression_statement [23];23 call [24,27];24 attribute [25,26];25 identifier [] click;26 identifier [] secho;27 argument_list [28];28 binary_operator [29,62] +;29 binary_operator [30,35] +;30 binary_operator [31,32] +;31 identifier [] WARNING;32 concatenated_string [33,34];33 string [] There are metadata files in the old location.;34 string [] \n (use "renku migrate datasets" to move them)\n\n\t;35 call [36,39];36 attribute [37,38];37 string [] \n\t;38 identifier [] join;39 generator_expression [40,59];40 call [41,44];41 attribute [42,43];42 identifier [] click;43 identifier [] style;44 argument_list [45,56];45 call [46,47];46 identifier [] str;47 argument_list [48];48 call [49,52];49 attribute [50,51];50 identifier [] path;51 identifier [] relative_to;52 argument_list [53];53 attribute [54,55];54 identifier [] client;55 identifier [] path;56 keyword_argument [57,58];57 identifier [] fg;58 string [] yellow;59 for_in_clause [60,61];60 identifier [] path;61 identifier [] old_metadata;62 string [] \n;63 return_statement [64];64 False [] | Check location of dataset metadata. |
0 module [1];1 function_definition [2,3,5,11];2 function_name [] file_names;3 parameters [4];4 identifier [] self;5 type [6];6 generic_type [7,8];7 identifier [] Iterable;8 type_parameter [9];9 type [10];10 identifier [] str;11 block [12];12 if_statement [13,18,31];13 call [14,17];14 attribute [15,16];15 identifier [] self;16 identifier [] is_sharded;17 argument_list [];18 block [19];19 expression_statement [20];20 yield [21];21 call [22,30];22 attribute [23,29];23 call [24,25];24 identifier [] ShardedFile;25 argument_list [26];26 attribute [27,28];27 identifier [] self;28 identifier [] filename_spec;29 identifier [] get_filenames;30 argument_list [];31 elif_clause [32,35];32 attribute [33,34];33 identifier [] self;34 identifier [] filename_spec;35 block [36];36 expression_statement [37];37 yield [38];38 attribute [39,40];39 identifier [] self;40 identifier [] filename_spec | Generates all file names that are used to generate file_handles. |
0 module [1];1 function_definition [2,3,5];2 function_name [] snapshot;3 parameters [4];4 identifier [] self;5 block [6];6 return_statement [7];7 call [8,9];8 identifier [] dict;9 generator_expression [10,21];10 tuple [11,12];11 identifier [] n;12 call [13,20];13 attribute [14,19];14 subscript [15,18];15 attribute [16,17];16 identifier [] self;17 identifier [] _slots;18 identifier [] n;19 identifier [] get;20 argument_list [];21 for_in_clause [22,23];22 identifier [] n;23 call [24,29];24 attribute [25,28];25 attribute [26,27];26 identifier [] self;27 identifier [] _slots;28 identifier [] keys;29 argument_list [] | Return a dictionary of current slots by reference. |
0 module [1];1 function_definition [2,3,20,22];2 function_name [] move_to_pat;3 parameters [4,8,15];4 typed_parameter [5,6];5 identifier [] pat;6 type [7];7 identifier [] str;8 typed_default_parameter [9,10,14];9 identifier [] offset;10 type [11];11 tuple [12,13];12 identifier [] float;13 identifier [] float;14 None [];15 typed_default_parameter [16,17,19];16 identifier [] tolerance;17 type [18];18 identifier [] int;19 integer [] 0;20 type [21];21 None [];22 block [23,59,66,118];23 with_statement [24,34];24 with_clause [25];25 with_item [26];26 as_pattern [27,32];27 call [28,31];28 attribute [29,30];29 identifier [] tempfile;30 identifier [] NamedTemporaryFile;31 argument_list [];32 as_pattern_target [33];33 identifier [] f;34 block [35,48];35 expression_statement [36];36 call [37,40];37 attribute [38,39];38 identifier [] subprocess;39 identifier [] call;40 argument_list [41,45];41 unary_operator [42] +;42 attribute [43,44];43 identifier [] f;44 identifier [] name;45 keyword_argument [46,47];46 identifier [] shell;47 True [];48 expression_statement [49];49 assignment [50,51];50 identifier [] loc;51 call [52,53];52 identifier [] visgrep;53 argument_list [54,57,58];54 attribute [55,56];55 identifier [] f;56 identifier [] name;57 identifier [] pat;58 identifier [] tolerance;59 expression_statement [60];60 assignment [61,62];61 identifier [] pat_size;62 call [63,64];63 identifier [] get_png_dim;64 argument_list [65];65 identifier [] pat;66 if_statement [67,70,91];67 comparison_operator [68,69] is;68 identifier [] offset;69 None [];70 block [71];71 expression_statement [72];72 assignment [73,76];73 pattern_list [74,75];74 identifier [] x;75 identifier [] y;76 list_comprehension [77,82];77 binary_operator [78,79] +;78 identifier [] l;79 binary_operator [80,81] //;80 identifier [] ps;81 integer [] 2;82 for_in_clause [83,86];83 pattern_list [84,85];84 identifier [] l;85 identifier [] ps;86 call [87,88];87 identifier [] zip;88 argument_list [89,90];89 identifier [] loc;90 identifier [] pat_size;91 else_clause [92];92 block [93];93 expression_statement [94];94 assignment [95,98];95 pattern_list [96,97];96 identifier [] x;97 identifier [] y;98 list_comprehension [99,107];99 binary_operator [100,101] +;100 identifier [] l;101 binary_operator [102,103] *;102 identifier [] ps;103 () [104];104 binary_operator [105,106] /;105 identifier [] off;106 integer [] 100;107 for_in_clause [108,112];108 pattern_list [109,110,111];109 identifier [] off;110 identifier [] l;111 identifier [] ps;112 call [113,114];113 identifier [] zip;114 argument_list [115,116,117];115 identifier [] offset;116 identifier [] loc;117 identifier [] pat_size;118 expression_statement [119];119 call [120,121];120 identifier [] mouse_move;121 argument_list [122,123];122 identifier [] x;123 identifier [] y | See help for click_on_pat |
0 module [1];1 function_definition [2,3,13];2 function_name [] build_where_stmt;3 parameters [4,5,6,7,10];4 identifier [] self;5 identifier [] ident;6 identifier [] filters;7 default_parameter [8,9];8 identifier [] q_filters;9 None [];10 default_parameter [11,12];11 identifier [] source_class;12 None [];13 block [14];14 if_statement [15,18,44];15 comparison_operator [16,17] is not;16 identifier [] q_filters;17 None [];18 block [19,30];19 expression_statement [20];20 assignment [21,22];21 identifier [] stmts;22 call [23,26];23 attribute [24,25];24 identifier [] self;25 identifier [] _parse_q_filters;26 argument_list [27,28,29];27 identifier [] ident;28 identifier [] q_filters;29 identifier [] source_class;30 if_statement [31,32];31 identifier [] stmts;32 block [33];33 expression_statement [34];34 call [35,42];35 attribute [36,41];36 subscript [37,40];37 attribute [38,39];38 identifier [] self;39 identifier [] _ast;40 string [] where;41 identifier [] append;42 argument_list [43];43 identifier [] stmts;44 else_clause [45];45 block [46,50,162];46 expression_statement [47];47 assignment [48,49];48 identifier [] stmts;49 list [] [];50 for_statement [51,52,53];51 identifier [] row;52 identifier [] filters;53 block [54,58,80];54 expression_statement [55];55 assignment [56,57];56 identifier [] negate;57 False [];58 if_statement [59,69];59 boolean_operator [60,63] and;60 comparison_operator [61,62] in;61 string [] __NOT__;62 identifier [] row;63 comparison_operator [64,68] ==;64 call [65,66];65 identifier [] len;66 argument_list [67];67 identifier [] row;68 integer [] 1;69 block [70,74];70 expression_statement [71];71 assignment [72,73];72 identifier [] negate;73 True [];74 expression_statement [75];75 assignment [76,77];76 identifier [] row;77 subscript [78,79];78 identifier [] row;79 string [] __NOT__;80 for_statement [81,84,89];81 pattern_list [82,83];82 identifier [] prop;83 identifier [] op_and_val;84 call [85,88];85 attribute [86,87];86 identifier [] row;87 identifier [] items;88 argument_list [];89 block [90,96,155];90 expression_statement [91];91 assignment [92,95];92 pattern_list [93,94];93 identifier [] op;94 identifier [] val;95 identifier [] op_and_val;96 if_statement [97,100,116];97 comparison_operator [98,99] in;98 identifier [] op;99 identifier [] _UNARY_OPERATORS;100 block [101];101 expression_statement [102];102 assignment [103,104];103 identifier [] statement;104 call [105,108];105 attribute [106,107];106 string [] {0} {1}.{2} {3};107 identifier [] format;108 argument_list [109,113,114,115];109 conditional_expression [110,111,112] if;110 string [] NOT;111 identifier [] negate;112 string [];113 identifier [] ident;114 identifier [] prop;115 identifier [] op;116 else_clause [117];117 block [118,131,147];118 expression_statement [119];119 assignment [120,121];120 identifier [] place_holder;121 call [122,125];122 attribute [123,124];123 identifier [] self;124 identifier [] _register_place_holder;125 argument_list [126];126 binary_operator [127,130] +;127 binary_operator [128,129] +;128 identifier [] ident;129 string [] _;130 identifier [] prop;131 expression_statement [132];132 assignment [133,134];133 identifier [] statement;134 call [135,138];135 attribute [136,137];136 string [] {0} {1}.{2} {3} {{{4}}};137 identifier [] format;138 argument_list [139,143,144,145,146];139 conditional_expression [140,141,142] if;140 string [] NOT;141 identifier [] negate;142 string [];143 identifier [] ident;144 identifier [] prop;145 identifier [] op;146 identifier [] place_holder;147 expression_statement [148];148 assignment [149,154];149 subscript [150,153];150 attribute [151,152];151 identifier [] self;152 identifier [] _query_params;153 identifier [] place_holder;154 identifier [] val;155 expression_statement [156];156 call [157,160];157 attribute [158,159];158 identifier [] stmts;159 identifier [] append;160 argument_list [161];161 identifier [] statement;162 expression_statement [163];163 call [164,171];164 attribute [165,170];165 subscript [166,169];166 attribute [167,168];167 identifier [] self;168 identifier [] _ast;169 string [] where;170 identifier [] append;171 argument_list [172];172 call [173,176];173 attribute [174,175];174 string [] AND;175 identifier [] join;176 argument_list [177];177 identifier [] stmts | construct a where statement from some filters |
0 module [1];1 function_definition [2,3,9];2 function_name [] sunionstore;3 parameters [4,5,6,7];4 identifier [] self;5 identifier [] destkey;6 identifier [] key;7 list_splat_pattern [8];8 identifier [] keys;9 block [10];10 return_statement [11];11 call [12,15];12 attribute [13,14];13 identifier [] self;14 identifier [] execute;15 argument_list [16,17,18,19];16 string [] b'SUNIONSTORE';17 identifier [] destkey;18 identifier [] key;19 list_splat [20];20 identifier [] keys | Add multiple sets and store the resulting set in a key. |
0 module [1];1 function_definition [2,3,5];2 function_name [] kml;3 parameters [4];4 identifier [] self;5 block [6,14];6 expression_statement [7];7 assignment [8,9];8 identifier [] url;9 binary_operator [10,13] +;10 attribute [11,12];11 identifier [] self;12 identifier [] _url;13 string [] /kml;14 return_statement [15];15 call [16,19];16 attribute [17,18];17 identifier [] _kml;18 identifier [] KML;19 argument_list [20,23,28,33,38];20 keyword_argument [21,22];21 identifier [] url;22 identifier [] url;23 keyword_argument [24,25];24 identifier [] securityHandler;25 attribute [26,27];26 identifier [] self;27 identifier [] _securityHandler;28 keyword_argument [29,30];29 identifier [] proxy_url;30 attribute [31,32];31 identifier [] self;32 identifier [] _proxy_url;33 keyword_argument [34,35];34 identifier [] proxy_port;35 attribute [36,37];36 identifier [] self;37 identifier [] _proxy_port;38 keyword_argument [39,40];39 identifier [] initialize;40 True [] | returns the kml functions for server |
0 module [1];1 function_definition [2,3,9];2 function_name [] _writeblocks;3 parameters [4,5,6,7,8];4 identifier [] cls;5 identifier [] blocks;6 identifier [] available;7 identifier [] cont_size;8 identifier [] padding_func;9 block [10,16,37,44,50,62,72,89,101];10 expression_statement [11];11 assignment [12,13];12 identifier [] data;13 call [14,15];14 identifier [] bytearray;15 argument_list [];16 for_statement [17,18,19];17 identifier [] block;18 identifier [] blocks;19 block [20,28];20 if_statement [21,26];21 call [22,23];22 identifier [] isinstance;23 argument_list [24,25];24 identifier [] block;25 identifier [] Padding;26 block [27];27 continue_statement [];28 expression_statement [29];29 augmented_assignment [30,31] +=;30 identifier [] data;31 call [32,35];32 attribute [33,34];33 identifier [] cls;34 identifier [] _writeblock;35 argument_list [36];36 identifier [] block;37 expression_statement [38];38 assignment [39,40];39 identifier [] blockssize;40 call [41,42];41 identifier [] len;42 argument_list [43];43 identifier [] data;44 expression_statement [45];45 assignment [46,47];46 identifier [] padding_block;47 call [48,49];48 identifier [] Padding;49 argument_list [];50 expression_statement [51];51 augmented_assignment [52,53] +=;52 identifier [] blockssize;53 call [54,55];54 identifier [] len;55 argument_list [56];56 call [57,60];57 attribute [58,59];58 identifier [] cls;59 identifier [] _writeblock;60 argument_list [61];61 identifier [] padding_block;62 expression_statement [63];63 assignment [64,65];64 identifier [] info;65 call [66,67];66 identifier [] PaddingInfo;67 argument_list [68,71];68 binary_operator [69,70] -;69 identifier [] available;70 identifier [] blockssize;71 identifier [] cont_size;72 expression_statement [73];73 assignment [74,77];74 attribute [75,76];75 identifier [] padding_block;76 identifier [] length;77 call [78,79];78 identifier [] min;79 argument_list [80,86];80 call [81,84];81 attribute [82,83];82 identifier [] info;83 identifier [] _get_padding;84 argument_list [85];85 identifier [] padding_func;86 attribute [87,88];87 identifier [] cls;88 identifier [] _MAX_SIZE;89 expression_statement [90];90 augmented_assignment [91,92] +=;91 identifier [] data;92 call [93,96];93 attribute [94,95];94 identifier [] cls;95 identifier [] _writeblock;96 argument_list [97,98];97 identifier [] padding_block;98 keyword_argument [99,100];99 identifier [] is_last;100 True [];101 return_statement [102];102 identifier [] data | Render metadata block as a byte string. |
0 module [1];1 function_definition [2,3,7];2 function_name [] _search_vals;3 parameters [4,5,6];4 identifier [] self;5 identifier [] compiled_pattern;6 identifier [] fld_val;7 block [8,12,48];8 expression_statement [9];9 assignment [10,11];10 identifier [] matches;11 list [] [];12 if_statement [13,18,32];13 call [14,15];14 identifier [] isinstance;15 argument_list [16,17];16 identifier [] fld_val;17 identifier [] set;18 block [19];19 for_statement [20,21,22];20 identifier [] val;21 identifier [] fld_val;22 block [23];23 expression_statement [24];24 call [25,28];25 attribute [26,27];26 identifier [] self;27 identifier [] _search_val;28 argument_list [29,30,31];29 identifier [] matches;30 identifier [] compiled_pattern;31 identifier [] val;32 elif_clause [33,38];33 call [34,35];34 identifier [] isinstance;35 argument_list [36,37];36 identifier [] fld_val;37 identifier [] str;38 block [39];39 expression_statement [40];40 call [41,44];41 attribute [42,43];42 identifier [] self;43 identifier [] _search_val;44 argument_list [45,46,47];45 identifier [] matches;46 identifier [] compiled_pattern;47 identifier [] fld_val;48 return_statement [49];49 identifier [] matches | Search for user-regex in scalar or iterable data values. |
0 module [1];1 function_definition [2,3,5];2 function_name [] asJSON;3 parameters [4];4 identifier [] self;5 block [6,12,37];6 expression_statement [7];7 assignment [8,9];8 identifier [] value;9 attribute [10,11];10 identifier [] self;11 identifier [] _json;12 if_statement [13,16];13 comparison_operator [14,15] is;14 identifier [] value;15 None [];16 block [17,31];17 expression_statement [18];18 assignment [19,20];19 identifier [] value;20 call [21,24];21 attribute [22,23];22 identifier [] json;23 identifier [] dumps;24 argument_list [25,28];25 attribute [26,27];26 identifier [] self;27 identifier [] asDictionary;28 keyword_argument [29,30];29 identifier [] default;30 identifier [] _date_handler;31 expression_statement [32];32 assignment [33,36];33 attribute [34,35];34 identifier [] self;35 identifier [] _json;36 identifier [] value;37 return_statement [38];38 attribute [39,40];39 identifier [] self;40 identifier [] _json | returns a geometry as JSON |
0 module [1];1 function_definition [2,3,6];2 function_name [] parse;3 parameters [4,5];4 identifier [] self;5 identifier [] obj;6 block [7];7 for_statement [8,11,20];8 pattern_list [9,10];9 identifier [] k;10 identifier [] default;11 call [12,19];12 attribute [13,18];13 attribute [14,17];14 attribute [15,16];15 identifier [] obj;16 identifier [] __class__;17 identifier [] defaults;18 identifier [] items;19 argument_list [];20 block [21,28,34,42];21 expression_statement [22];22 assignment [23,24];23 identifier [] typ;24 call [25,26];25 identifier [] type;26 argument_list [27];27 identifier [] default;28 if_statement [29,32];29 comparison_operator [30,31] is;30 identifier [] typ;31 identifier [] str;32 block [33];33 continue_statement [];34 expression_statement [35];35 assignment [36,37];36 identifier [] v;37 call [38,39];38 identifier [] getattr;39 argument_list [40,41];40 identifier [] obj;41 identifier [] k;42 if_statement [43,46,59,76];43 comparison_operator [44,45] is;44 identifier [] typ;45 identifier [] int;46 block [47];47 expression_statement [48];48 call [49,50];49 identifier [] setattr;50 argument_list [51,52,53];51 identifier [] obj;52 identifier [] k;53 call [54,55];54 identifier [] int;55 argument_list [56];56 boolean_operator [57,58] or;57 identifier [] v;58 identifier [] default;59 elif_clause [60,63];60 comparison_operator [61,62] is;61 identifier [] typ;62 identifier [] float;63 block [64];64 expression_statement [65];65 call [66,67];66 identifier [] setattr;67 argument_list [68,69,70];68 identifier [] obj;69 identifier [] k;70 call [71,72];71 identifier [] float;72 argument_list [73];73 boolean_operator [74,75] or;74 identifier [] v;75 identifier [] default;76 elif_clause [77,80];77 comparison_operator [78,79] is;78 identifier [] typ;79 identifier [] bool;80 block [81];81 expression_statement [82];82 call [83,84];83 identifier [] setattr;84 argument_list [85,86,87];85 identifier [] obj;86 identifier [] k;87 call [88,89];88 identifier [] bool;89 argument_list [90];90 call [91,92];91 identifier [] int;92 argument_list [93];93 boolean_operator [94,95] or;94 identifier [] v;95 identifier [] default | Parse the object's properties according to its default types. |
0 module [1];1 function_definition [2,3,5];2 function_name [] _get_monitoring_heartbeat;3 parameters [4];4 identifier [] self;5 block [6,14,25];6 expression_statement [7];7 assignment [8,9];8 identifier [] target;9 binary_operator [10,13] +;10 attribute [11,12];11 identifier [] self;12 identifier [] uri;13 string [] /monitoring/heartbeat;14 expression_statement [15];15 assignment [16,17];16 identifier [] response;17 call [18,23];18 attribute [19,22];19 attribute [20,21];20 identifier [] self;21 identifier [] session;22 identifier [] get;23 argument_list [24];24 identifier [] target;25 return_statement [26];26 identifier [] response | Tests whether or not the ACS service being monitored is alive. |
0 module [1];1 function_definition [2,3,6];2 function_name [] closeEvent;3 parameters [4,5];4 identifier [] self;5 identifier [] event;6 block [7,16,24,36,48];7 expression_statement [8];8 assignment [9,10];9 identifier [] max_dataset_history;10 call [11,14];11 attribute [12,13];12 identifier [] self;13 identifier [] value;14 argument_list [15];15 string [] max_dataset_history;16 expression_statement [17];17 call [18,19];18 identifier [] keep_recent_datasets;19 argument_list [20,21];20 identifier [] max_dataset_history;21 attribute [22,23];22 identifier [] self;23 identifier [] info;24 expression_statement [25];25 call [26,29];26 attribute [27,28];27 identifier [] settings;28 identifier [] setValue;29 argument_list [30,31];30 string [] window/geometry;31 call [32,35];32 attribute [33,34];33 identifier [] self;34 identifier [] saveGeometry;35 argument_list [];36 expression_statement [37];37 call [38,41];38 attribute [39,40];39 identifier [] settings;40 identifier [] setValue;41 argument_list [42,43];42 string [] window/state;43 call [44,47];44 attribute [45,46];45 identifier [] self;46 identifier [] saveState;47 argument_list [];48 expression_statement [49];49 call [50,53];50 attribute [51,52];51 identifier [] event;52 identifier [] accept;53 argument_list [] | save the name of the last open dataset. |
0 module [1];1 function_definition [2,3,5];2 function_name [] _workaround_no_vector_images;3 parameters [4];4 identifier [] project;5 block [6,13,27];6 expression_statement [7];7 assignment [8,9];8 identifier [] RED;9 tuple [10,11,12];10 integer [] 255;11 integer [] 0;12 integer [] 0;13 expression_statement [14];14 assignment [15,16];15 identifier [] PLACEHOLDER;16 call [17,22];17 attribute [18,21];18 attribute [19,20];19 identifier [] kurt;20 identifier [] Image;21 identifier [] new;22 argument_list [23,26];23 tuple [24,25];24 integer [] 32;25 integer [] 32;26 identifier [] RED;27 for_statement [28,29,37];28 identifier [] scriptable;29 binary_operator [30,34] +;30 list [31] [project.stage];31 attribute [32,33];32 identifier [] project;33 identifier [] stage;34 attribute [35,36];35 identifier [] project;36 identifier [] sprites;37 block [38];38 for_statement [39,40,43];39 identifier [] costume;40 attribute [41,42];41 identifier [] scriptable;42 identifier [] costumes;43 block [44];44 if_statement [45,52];45 comparison_operator [46,51] ==;46 attribute [47,50];47 attribute [48,49];48 identifier [] costume;49 identifier [] image;50 identifier [] format;51 string [] SVG;52 block [53,64];53 expression_statement [54];54 yield [55];55 binary_operator [56,57] %;56 string [] %s - %s;57 tuple [58,61];58 attribute [59,60];59 identifier [] scriptable;60 identifier [] name;61 attribute [62,63];62 identifier [] costume;63 identifier [] name;64 expression_statement [65];65 assignment [66,69];66 attribute [67,68];67 identifier [] costume;68 identifier [] image;69 identifier [] PLACEHOLDER | Replace vector images with fake ones. |
0 module [1];1 function_definition [2,3,6];2 function_name [] _cert_file;3 parameters [4,5];4 identifier [] name;5 identifier [] cert_type;6 block [7];7 return_statement [8];8 call [9,14];9 attribute [10,13];10 attribute [11,12];11 identifier [] os;12 identifier [] path;13 identifier [] join;14 argument_list [15,16,17];15 identifier [] LE_LIVE;16 identifier [] name;17 call [18,21];18 attribute [19,20];19 string [] {0}.pem;20 identifier [] format;21 argument_list [22];22 identifier [] cert_type | Return expected path of a Let's Encrypt live cert |
0 module [1];1 function_definition [2,3,4];2 function_name [] register_templatetags;3 parameters [];4 block [5,11,19];5 import_from_statement [6,9];6 dotted_name [7,8];7 identifier [] turboengine;8 identifier [] conf;9 dotted_name [10];10 identifier [] settings;11 import_from_statement [12,17];12 dotted_name [13,14,15,16];13 identifier [] google;14 identifier [] appengine;15 identifier [] ext;16 identifier [] webapp;17 dotted_name [18];18 identifier [] template;19 for_statement [20,21,24];20 identifier [] python_file;21 attribute [22,23];22 identifier [] settings;23 identifier [] TEMPLATE_PATH;24 block [25];25 expression_statement [26];26 call [27,30];27 attribute [28,29];28 identifier [] template;29 identifier [] register_template_library;30 argument_list [31];31 identifier [] python_file | Register templatetags defined in settings as basic templatetags |
0 module [1];1 function_definition [2,3,4];2 function_name [] handle_command_line;3 parameters [];4 block [5,22,55];5 expression_statement [6];6 assignment [7,8];7 identifier [] phrase;8 boolean_operator [9,21] or;9 call [10,13];10 attribute [11,12];11 string [];12 identifier [] join;13 argument_list [14];14 subscript [15,18];15 attribute [16,17];16 identifier [] sys;17 identifier [] argv;18 slice [19,20];19 integer [] 1;20 colon [];21 string [] random;22 try_statement [23,31];23 block [24];24 expression_statement [25];25 assignment [26,27];26 identifier [] giphy;27 call [28,29];28 identifier [] get_random_giphy;29 argument_list [30];30 identifier [] phrase;31 except_clause [32,33];32 identifier [] ValueError;33 block [34,48];34 expression_statement [35];35 call [36,41];36 attribute [37,40];37 attribute [38,39];38 identifier [] sys;39 identifier [] stderr;40 identifier [] write;41 argument_list [42];42 call [43,46];43 attribute [44,45];44 string [] Unable to find any GIFs for {!r}\n;45 identifier [] format;46 argument_list [47];47 identifier [] phrase;48 expression_statement [49];49 call [50,53];50 attribute [51,52];51 identifier [] sys;52 identifier [] exit;53 argument_list [54];54 integer [] 1;55 expression_statement [56];56 call [57,58];57 identifier [] display;58 argument_list [59];59 call [60,61];60 identifier [] fetch_image;61 argument_list [62];62 identifier [] giphy | Display an image for the phrase in sys.argv, if possible |
0 module [1];1 function_definition [2,3,5];2 function_name [] use_plenary_log_view;3 parameters [4];4 identifier [] self;5 block [6,12];6 expression_statement [7];7 assignment [8,11];8 attribute [9,10];9 identifier [] self;10 identifier [] _log_view;11 identifier [] PLENARY;12 for_statement [13,14,19];13 identifier [] session;14 call [15,18];15 attribute [16,17];16 identifier [] self;17 identifier [] _get_provider_sessions;18 argument_list [];19 block [20];20 try_statement [21,28];21 block [22];22 expression_statement [23];23 call [24,27];24 attribute [25,26];25 identifier [] session;26 identifier [] use_plenary_log_view;27 argument_list [];28 except_clause [29,30];29 identifier [] AttributeError;30 block [31];31 pass_statement [] | Pass through to provider LogEntryLogSession.use_plenary_log_view |
0 module [1];1 function_definition [2,3,6];2 function_name [] _associate_placeable;3 parameters [4,5];4 identifier [] self;5 identifier [] location;6 block [7,12,21,27];7 if_statement [8,10];8 not_operator [9];9 identifier [] location;10 block [11];11 return_statement [];12 expression_statement [13];13 assignment [14,17];14 pattern_list [15,16];15 identifier [] placeable;16 identifier [] _;17 call [18,19];18 identifier [] unpack_location;19 argument_list [20];20 identifier [] location;21 expression_statement [22];22 assignment [23,26];23 attribute [24,25];24 identifier [] self;25 identifier [] previous_placeable;26 identifier [] placeable;27 if_statement [28,42];28 boolean_operator [29,33] or;29 not_operator [30];30 attribute [31,32];31 identifier [] self;32 identifier [] placeables;33 () [34];34 comparison_operator [35,36] !=;35 identifier [] placeable;36 subscript [37,40];37 attribute [38,39];38 identifier [] self;39 identifier [] placeables;40 unary_operator [41] -;41 integer [] 1;42 block [43];43 expression_statement [44];44 call [45,50];45 attribute [46,49];46 attribute [47,48];47 identifier [] self;48 identifier [] placeables;49 identifier [] append;50 argument_list [51];51 identifier [] placeable | Saves a reference to a placeable |
0 module [1];1 function_definition [2,3,7];2 function_name [] build_event_graph;3 parameters [4,5,6];4 identifier [] graph;5 identifier [] tree;6 identifier [] node;7 block [8,17,24,31,39,58,65];8 if_statement [9,15];9 comparison_operator [10,14] in;10 call [11,12];11 identifier [] node_key;12 argument_list [13];13 identifier [] node;14 identifier [] graph;15 block [16];16 return_statement [];17 expression_statement [18];18 assignment [19,20];19 identifier [] type;20 call [21,22];21 identifier [] get_type;22 argument_list [23];23 identifier [] node;24 expression_statement [25];25 assignment [26,27];26 identifier [] text;27 call [28,29];28 identifier [] get_text;29 argument_list [30];30 identifier [] node;31 expression_statement [32];32 assignment [33,34];33 identifier [] label;34 binary_operator [35,36] %;35 string [] %s (%s);36 tuple [37,38];37 identifier [] type;38 identifier [] text;39 expression_statement [40];40 call [41,44];41 attribute [42,43];42 identifier [] graph;43 identifier [] add_node;44 argument_list [45,49,52,55];45 call [46,47];46 identifier [] node_key;47 argument_list [48];48 identifier [] node;49 keyword_argument [50,51];50 identifier [] type;51 identifier [] type;52 keyword_argument [53,54];53 identifier [] label;54 identifier [] label;55 keyword_argument [56,57];56 identifier [] text;57 identifier [] text;58 expression_statement [59];59 assignment [60,61];60 identifier [] args;61 call [62,63];62 identifier [] get_args;63 argument_list [64];64 identifier [] node;65 for_statement [66,71,76];66 pattern_list [67,68];67 identifier [] arg_role;68 tuple_pattern [69,70];69 identifier [] arg_id;70 identifier [] arg_tag;71 call [72,75];72 attribute [73,74];73 identifier [] args;74 identifier [] items;75 argument_list [];76 block [77,85,94,101];77 expression_statement [78];78 assignment [79,80];79 identifier [] arg;80 call [81,82];81 identifier [] get_node_by_id;82 argument_list [83,84];83 identifier [] tree;84 identifier [] arg_id;85 if_statement [86,89];86 comparison_operator [87,88] is;87 identifier [] arg;88 None [];89 block [90];90 expression_statement [91];91 assignment [92,93];92 identifier [] arg;93 identifier [] arg_tag;94 expression_statement [95];95 call [96,97];96 identifier [] build_event_graph;97 argument_list [98,99,100];98 identifier [] graph;99 identifier [] tree;100 identifier [] arg;101 expression_statement [102];102 call [103,106];103 attribute [104,105];104 identifier [] graph;105 identifier [] add_edge;106 argument_list [107,111,115,118];107 call [108,109];108 identifier [] node_key;109 argument_list [110];110 identifier [] node;111 call [112,113];112 identifier [] node_key;113 argument_list [114];114 identifier [] arg;115 keyword_argument [116,117];116 identifier [] type;117 identifier [] arg_role;118 keyword_argument [119,120];119 identifier [] label;120 identifier [] arg_role | Return a DiGraph of a specific event structure, built recursively |
0 module [1];1 function_definition [2,3,16];2 function_name [] chunks;3 parameters [4,5,8,11];4 identifier [] self;5 default_parameter [6,7];6 identifier [] num_chunks;7 integer [] 100;8 default_parameter [9,10];9 identifier [] chunk_size;10 integer [] 2;11 default_parameter [12,13];12 identifier [] random_state;13 attribute [14,15];14 identifier [] np;15 identifier [] random;16 block [17,32,48,74,78,168,182];17 expression_statement [18];18 assignment [19,20];19 identifier [] chunks;20 unary_operator [21] -;21 call [22,25];22 attribute [23,24];23 identifier [] np;24 identifier [] ones_like;25 argument_list [26,29];26 attribute [27,28];27 identifier [] self;28 identifier [] known_label_idx;29 keyword_argument [30,31];30 identifier [] dtype;31 identifier [] int;32 expression_statement [33];33 assignment [34,37];34 pattern_list [35,36];35 identifier [] uniq;36 identifier [] lookup;37 call [38,41];38 attribute [39,40];39 identifier [] np;40 identifier [] unique;41 argument_list [42,45];42 attribute [43,44];43 identifier [] self;44 identifier [] known_labels;45 keyword_argument [46,47];46 identifier [] return_inverse;47 True [];48 expression_statement [49];49 assignment [50,51];50 identifier [] all_inds;51 list_comprehension [52,65];52 call [53,54];53 identifier [] set;54 argument_list [55];55 subscript [56,64];56 call [57,60];57 attribute [58,59];58 identifier [] np;59 identifier [] where;60 argument_list [61];61 comparison_operator [62,63] ==;62 identifier [] lookup;63 identifier [] c;64 integer [] 0;65 for_in_clause [66,67];66 identifier [] c;67 call [68,69];68 identifier [] xrange;69 argument_list [70];70 call [71,72];71 identifier [] len;72 argument_list [73];73 identifier [] uniq;74 expression_statement [75];75 assignment [76,77];76 identifier [] idx;77 integer [] 0;78 while_statement [79,84];79 boolean_operator [80,83] and;80 comparison_operator [81,82] <;81 identifier [] idx;82 identifier [] num_chunks;83 identifier [] all_inds;84 block [85,116,122,135,151,158,164];85 if_statement [86,92,97];86 comparison_operator [87,91] ==;87 call [88,89];88 identifier [] len;89 argument_list [90];90 identifier [] all_inds;91 integer [] 1;92 block [93];93 expression_statement [94];94 assignment [95,96];95 identifier [] c;96 integer [] 0;97 else_clause [98];98 block [99];99 expression_statement [100];100 assignment [101,102];101 identifier [] c;102 call [103,106];103 attribute [104,105];104 identifier [] random_state;105 identifier [] randint;106 argument_list [107,108];107 integer [] 0;108 keyword_argument [109,110];109 identifier [] high;110 binary_operator [111,115] -;111 call [112,113];112 identifier [] len;113 argument_list [114];114 identifier [] all_inds;115 integer [] 1;116 expression_statement [117];117 assignment [118,119];118 identifier [] inds;119 subscript [120,121];120 identifier [] all_inds;121 identifier [] c;122 if_statement [123,129];123 comparison_operator [124,128] <;124 call [125,126];125 identifier [] len;126 argument_list [127];127 identifier [] inds;128 identifier [] chunk_size;129 block [130,134];130 delete_statement [131];131 subscript [132,133];132 identifier [] all_inds;133 identifier [] c;134 continue_statement [];135 expression_statement [136];136 assignment [137,138];137 identifier [] ii;138 call [139,142];139 attribute [140,141];140 identifier [] random_state;141 identifier [] choice;142 argument_list [143,147,148];143 call [144,145];144 identifier [] list;145 argument_list [146];146 identifier [] inds;147 identifier [] chunk_size;148 keyword_argument [149,150];149 identifier [] replace;150 False [];151 expression_statement [152];152 call [153,156];153 attribute [154,155];154 identifier [] inds;155 identifier [] difference_update;156 argument_list [157];157 identifier [] ii;158 expression_statement [159];159 assignment [160,163];160 subscript [161,162];161 identifier [] chunks;162 identifier [] ii;163 identifier [] idx;164 expression_statement [165];165 augmented_assignment [166,167] +=;166 identifier [] idx;167 integer [] 1;168 if_statement [169,172];169 comparison_operator [170,171] <;170 identifier [] idx;171 identifier [] num_chunks;172 block [173];173 raise_statement [174];174 call [175,176];175 identifier [] ValueError;176 argument_list [177];177 binary_operator [178,179] %;178 string [] Unable to make %d chunks of %d examples each;179 tuple [180,181];180 identifier [] num_chunks;181 identifier [] chunk_size;182 return_statement [183];183 identifier [] chunks | the random state object to be passed must be a numpy random seed |
0 module [1];1 function_definition [2,3,6];2 function_name [] dataReceived;3 parameters [4,5];4 identifier [] self;5 identifier [] data;6 block [7,17,27];7 expression_statement [8];8 augmented_assignment [9,12] +=;9 attribute [10,11];10 identifier [] self;11 identifier [] bytes_in;12 () [13];13 call [14,15];14 identifier [] len;15 argument_list [16];16 identifier [] data;17 expression_statement [18];18 assignment [19,22];19 attribute [20,21];20 identifier [] self;21 identifier [] buffer_in;22 binary_operator [23,26] +;23 attribute [24,25];24 identifier [] self;25 identifier [] buffer_in;26 identifier [] data;27 while_statement [28,33];28 call [29,32];29 attribute [30,31];30 identifier [] self;31 identifier [] CheckDataReceived;32 argument_list [];33 block [34];34 pass_statement [] | Called from Twisted whenever data is received. |
0 module [1];1 function_definition [2,3,9];2 function_name [] load_file;3 parameters [4,5,6,7,8];4 identifier [] self;5 identifier [] cursor;6 identifier [] target;7 identifier [] fname;8 identifier [] options;9 block [10,12];10 expression_statement [11];11 string [] Parses and loads a single file into the target table.;12 with_statement [13,22];13 with_clause [14];14 with_item [15];15 as_pattern [16,20];16 call [17,18];17 identifier [] open;18 argument_list [19];19 identifier [] fname;20 as_pattern_target [21];21 identifier [] fin;22 block [23,36,46,81,90,112];23 expression_statement [24];24 call [25,28];25 attribute [26,27];26 identifier [] log;27 identifier [] debug;28 argument_list [29];29 call [30,33];30 attribute [31,32];31 string [] opening {0} in {1} load_file;32 identifier [] format;33 argument_list [34,35];34 identifier [] fname;35 identifier [] __name__;36 expression_statement [37];37 assignment [38,39];38 identifier [] encoding;39 call [40,43];40 attribute [41,42];41 identifier [] options;42 identifier [] get;43 argument_list [44,45];44 string [] encoding;45 string [] utf-8;46 if_statement [47,52,67];47 comparison_operator [48,49] in;48 identifier [] target;49 attribute [50,51];50 identifier [] self;51 identifier [] processors;52 block [53];53 expression_statement [54];54 assignment [55,56];55 identifier [] reader;56 call [57,62];57 subscript [58,61];58 attribute [59,60];59 identifier [] self;60 identifier [] processors;61 identifier [] target;62 argument_list [63,64];63 identifier [] fin;64 keyword_argument [65,66];65 identifier [] encoding;66 identifier [] encoding;67 else_clause [68];68 block [69];69 expression_statement [70];70 assignment [71,72];71 identifier [] reader;72 call [73,76];73 attribute [74,75];74 identifier [] self;75 identifier [] default_processor;76 argument_list [77,78];77 identifier [] fin;78 keyword_argument [79,80];79 identifier [] encoding;80 identifier [] encoding;81 expression_statement [82];82 assignment [83,84];83 identifier [] columns;84 call [85,86];85 identifier [] getattr;86 argument_list [87,88,89];87 identifier [] reader;88 string [] output_columns;89 None [];90 for_statement [91,92,105];91 identifier [] _;92 call [93,94];93 identifier [] xrange;94 argument_list [95];95 call [96,97];96 identifier [] int;97 argument_list [98];98 call [99,102];99 attribute [100,101];100 identifier [] options;101 identifier [] get;102 argument_list [103,104];103 string [] skip-lines;104 integer [] 0;105 block [106];106 expression_statement [107];107 call [108,111];108 attribute [109,110];109 identifier [] fin;110 identifier [] readline;111 argument_list [];112 expression_statement [113];113 call [114,117];114 attribute [115,116];115 identifier [] cursor;116 identifier [] copy_from;117 argument_list [118,119,124];118 identifier [] reader;119 subscript [120,123];120 attribute [121,122];121 identifier [] self;122 identifier [] qualified_names;123 identifier [] target;124 keyword_argument [125,126];125 identifier [] columns;126 identifier [] columns | Parses and loads a single file into the target table. |
0 module [1];1 function_definition [2,3,5];2 function_name [] loginfo;3 parameters [4];4 identifier [] method;5 block [6,97];6 function_definition [7,8,11];7 function_name [] loginfo_method;8 parameters [9,10];9 identifier [] self;10 identifier [] rinput;11 block [12,18,87,95];12 expression_statement [13];13 assignment [14,15];14 identifier [] klass;15 attribute [16,17];16 identifier [] rinput;17 identifier [] __class__;18 for_statement [19,20,25];19 identifier [] key;20 call [21,24];21 attribute [22,23];22 identifier [] klass;23 identifier [] stored;24 argument_list [];25 block [26,34];26 expression_statement [27];27 assignment [28,29];28 identifier [] val;29 call [30,31];30 identifier [] getattr;31 argument_list [32,33];32 identifier [] rinput;33 identifier [] key;34 if_statement [35,40,56,84];35 call [36,37];36 identifier [] isinstance;37 argument_list [38,39];38 identifier [] val;39 identifier [] DataFrame;40 block [41];41 expression_statement [42];42 call [43,48];43 attribute [44,47];44 attribute [45,46];45 identifier [] self;46 identifier [] logger;47 identifier [] debug;48 argument_list [49,50];49 string [] DataFrame %s;50 call [51,54];51 attribute [52,53];52 identifier [] info;53 identifier [] gather_info_dframe;54 argument_list [55];55 identifier [] val;56 elif_clause [57,62];57 call [58,59];58 identifier [] isinstance;59 argument_list [60,61];60 identifier [] val;61 identifier [] ObservationResult;62 block [63];63 for_statement [64,65,68];64 identifier [] f;65 attribute [66,67];66 identifier [] val;67 identifier [] images;68 block [69];69 expression_statement [70];70 call [71,76];71 attribute [72,75];72 attribute [73,74];73 identifier [] self;74 identifier [] logger;75 identifier [] debug;76 argument_list [77,78];77 string [] OB DataFrame %s;78 call [79,82];79 attribute [80,81];80 identifier [] info;81 identifier [] gather_info_dframe;82 argument_list [83];83 identifier [] f;84 else_clause [85];85 block [86];86 pass_statement [];87 expression_statement [88];88 assignment [89,90];89 identifier [] result;90 call [91,92];91 identifier [] method;92 argument_list [93,94];93 identifier [] self;94 identifier [] rinput;95 return_statement [96];96 identifier [] result;97 return_statement [98];98 identifier [] loginfo_method | Log the contents of Recipe Input |
0 module [1];1 function_definition [2,3,14,16];2 function_name [] cgi_method_is_post;3 parameters [4];4 typed_parameter [5,6];5 identifier [] environ;6 type [7];7 generic_type [8,9];8 identifier [] Dict;9 type_parameter [10,12];10 type [11];11 identifier [] str;12 type [13];13 identifier [] str;14 type [15];15 identifier [] bool;16 block [17,27,33];17 expression_statement [18];18 assignment [19,20];19 identifier [] method;20 call [21,24];21 attribute [22,23];22 identifier [] environ;23 identifier [] get;24 argument_list [25,26];25 string [] REQUEST_METHOD;26 None [];27 if_statement [28,30];28 not_operator [29];29 identifier [] method;30 block [31];31 return_statement [32];32 False [];33 return_statement [34];34 comparison_operator [35,40] ==;35 call [36,39];36 attribute [37,38];37 identifier [] method;38 identifier [] upper;39 argument_list [];40 string [] POST | Determines if the CGI method was ``POST``, given the CGI environment. |
0 module [1];1 function_definition [2,3,10];2 function_name [] retrieve;3 parameters [4,5,6,8];4 identifier [] self;5 identifier [] request;6 list_splat_pattern [7];7 identifier [] args;8 dictionary_splat_pattern [9];9 identifier [] kwargs;10 block [11,26,34,38,57,61,95];11 expression_statement [12];12 assignment [13,14];13 identifier [] when_param;14 call [15,23];15 attribute [16,22];16 call [17,18];17 identifier [] get_query_params;18 argument_list [19];19 attribute [20,21];20 identifier [] self;21 identifier [] request;22 identifier [] get;23 argument_list [24,25];24 string [] preview;25 None [];26 expression_statement [27];27 assignment [28,29];28 identifier [] pk;29 subscript [30,33];30 attribute [31,32];31 identifier [] self;32 identifier [] kwargs;33 string [] pk;34 expression_statement [35];35 assignment [36,37];36 identifier [] when;37 None [];38 if_statement [39,40];39 identifier [] when_param;40 block [41];41 try_statement [42,50];42 block [43];43 expression_statement [44];44 assignment [45,46];45 identifier [] when;46 call [47,48];47 identifier [] parse_date;48 argument_list [49];49 identifier [] when_param;50 except_clause [51,52];51 identifier [] ValueError;52 block [53];53 expression_statement [54];54 assignment [55,56];55 identifier [] when;56 None [];57 expression_statement [58];58 assignment [59,60];59 identifier [] pzone;60 None [];61 if_statement [62,63,80];62 identifier [] when;63 block [64];64 expression_statement [65];65 assignment [66,67];66 identifier [] pzone;67 call [68,73];68 attribute [69,72];69 attribute [70,71];70 identifier [] PZone;71 identifier [] objects;72 identifier [] preview;73 argument_list [74,77];74 keyword_argument [75,76];75 identifier [] pk;76 identifier [] pk;77 keyword_argument [78,79];78 identifier [] when;79 identifier [] when;80 else_clause [81];81 block [82];82 expression_statement [83];83 assignment [84,85];84 identifier [] pzone;85 call [86,91];86 attribute [87,90];87 attribute [88,89];88 identifier [] PZone;89 identifier [] objects;90 identifier [] applied;91 argument_list [92];92 keyword_argument [93,94];93 identifier [] pk;94 identifier [] pk;95 return_statement [96];96 call [97,98];97 identifier [] Response;98 argument_list [99,105];99 attribute [100,104];100 call [101,102];101 identifier [] PZoneSerializer;102 argument_list [103];103 identifier [] pzone;104 identifier [] data;105 keyword_argument [106,107];106 identifier [] content_type;107 string [] application/json | Retrieve pzone as a preview or applied if no preview is provided. |
0 module [1];1 function_definition [2,3,6];2 function_name [] _reduce_sizes;3 parameters [4,5];4 identifier [] self;5 identifier [] bbox_list;6 block [7];7 return_statement [8];8 list_comprehension [9,30];9 call [10,26];10 attribute [11,25];11 call [12,13];12 identifier [] BBox;13 argument_list [14,22];14 attribute [15,21];15 call [16,19];16 attribute [17,18];17 identifier [] self;18 identifier [] _intersection_area;19 argument_list [20];20 identifier [] bbox;21 identifier [] bounds;22 attribute [23,24];23 identifier [] self;24 identifier [] crs;25 identifier [] transform;26 argument_list [27];27 attribute [28,29];28 identifier [] bbox;29 identifier [] crs;30 for_in_clause [31,32];31 identifier [] bbox;32 identifier [] bbox_list | Reduces sizes of bounding boxes |
0 module [1];1 function_definition [2,3,5];2 function_name [] finalize_options;3 parameters [4];4 identifier [] self;5 block [6,13,67];6 expression_statement [7];7 call [8,11];8 attribute [9,10];9 identifier [] install;10 identifier [] finalize_options;11 argument_list [12];12 identifier [] self;13 if_statement [14,19,24];14 comparison_operator [15,18] is;15 attribute [16,17];16 identifier [] self;17 identifier [] prefix;18 None [];19 block [20];20 expression_statement [21];21 assignment [22,23];22 identifier [] man_dir;23 None [];24 else_clause [25];25 block [26,42];26 expression_statement [27];27 assignment [28,29];28 identifier [] man_dir;29 call [30,35];30 attribute [31,34];31 attribute [32,33];32 identifier [] os;33 identifier [] path;34 identifier [] join;35 argument_list [36,39,40,41];36 attribute [37,38];37 identifier [] self;38 identifier [] prefix;39 string [] share;40 string [] man;41 string [] man1;42 if_statement [43,48];43 comparison_operator [44,47] is not;44 attribute [45,46];45 identifier [] self;46 identifier [] root;47 None [];48 block [49];49 expression_statement [50];50 assignment [51,52];51 identifier [] man_dir;52 call [53,58];53 attribute [54,57];54 attribute [55,56];55 identifier [] os;56 identifier [] path;57 identifier [] join;58 argument_list [59,62];59 attribute [60,61];60 identifier [] self;61 identifier [] root;62 subscript [63,64];63 identifier [] man_dir;64 slice [65,66];65 integer [] 1;66 colon [];67 expression_statement [68];68 assignment [69,72];69 attribute [70,71];70 identifier [] self;71 identifier [] _custom_man_dir;72 identifier [] man_dir | Alter the installation path. |
0 module [1];1 function_definition [2,3,7];2 function_name [] conditions_met;3 parameters [4,5,6];4 identifier [] self;5 identifier [] instance;6 identifier [] state;7 block [8,17];8 expression_statement [9];9 assignment [10,11];10 identifier [] transition;11 call [12,15];12 attribute [13,14];13 identifier [] self;14 identifier [] get_transition;15 argument_list [16];16 identifier [] state;17 if_statement [18,21,24,33];18 comparison_operator [19,20] is;19 identifier [] transition;20 None [];21 block [22];22 return_statement [23];23 False [];24 elif_clause [25,30];25 comparison_operator [26,29] is;26 attribute [27,28];27 identifier [] transition;28 identifier [] conditions;29 None [];30 block [31];31 return_statement [32];32 True [];33 else_clause [34];34 block [35];35 return_statement [36];36 call [37,38];37 identifier [] all;38 argument_list [39];39 call [40,41];40 identifier [] map;41 argument_list [42,49];42 lambda [43,45];43 lambda_parameters [44];44 identifier [] condition;45 call [46,47];46 identifier [] condition;47 argument_list [48];48 identifier [] instance;49 attribute [50,51];50 identifier [] transition;51 identifier [] conditions | Check if all conditions have been met |
0 module [1];1 function_definition [2,3,4];2 function_name [] main;3 parameters [];4 block [5,20,29,42,114,121];5 if_statement [6,14];6 comparison_operator [7,13] !=;7 call [8,9];8 identifier [] len;9 argument_list [10];10 attribute [11,12];11 identifier [] sys;12 identifier [] argv;13 integer [] 2;14 block [15];15 raise_statement [16];16 call [17,18];17 identifier [] RuntimeError;18 argument_list [19];19 string [] Usage: python3 async_send.py <json config>;20 expression_statement [21];21 call [22,25];22 attribute [23,24];23 identifier [] sip_logging;24 identifier [] init_logger;25 argument_list [26];26 keyword_argument [27,28];27 identifier [] show_thread;28 False [];29 expression_statement [30];30 assignment [31,32];31 identifier [] spead_config;32 call [33,36];33 attribute [34,35];34 identifier [] json;35 identifier [] loads;36 argument_list [37];37 subscript [38,41];38 attribute [39,40];39 identifier [] sys;40 identifier [] argv;41 integer [] 1;42 try_statement [43,100];43 block [44,62,74,94];44 expression_statement [45];45 assignment [46,47];46 identifier [] _path;47 call [48,53];48 attribute [49,52];49 attribute [50,51];50 identifier [] os;51 identifier [] path;52 identifier [] dirname;53 argument_list [54];54 call [55,60];55 attribute [56,59];56 attribute [57,58];57 identifier [] os;58 identifier [] path;59 identifier [] abspath;60 argument_list [61];61 identifier [] __file__;62 expression_statement [63];63 assignment [64,65];64 identifier [] schema_path;65 call [66,71];66 attribute [67,70];67 attribute [68,69];68 identifier [] os;69 identifier [] path;70 identifier [] join;71 argument_list [72,73];72 identifier [] _path;73 string [] config_schema.json;74 with_statement [75,84];75 with_clause [76];76 with_item [77];77 as_pattern [78,82];78 call [79,80];79 identifier [] open;80 argument_list [81];81 identifier [] schema_path;82 as_pattern_target [83];83 identifier [] schema_file;84 block [85];85 expression_statement [86];86 assignment [87,88];87 identifier [] schema;88 call [89,92];89 attribute [90,91];90 identifier [] json;91 identifier [] load;92 argument_list [93];93 identifier [] schema_file;94 expression_statement [95];95 call [96,97];96 identifier [] validate;97 argument_list [98,99];98 identifier [] spead_config;99 identifier [] schema;100 except_clause [101,105];101 as_pattern [102,103];102 identifier [] ValidationError;103 as_pattern_target [104];104 identifier [] error;105 block [106,113];106 expression_statement [107];107 call [108,109];108 identifier [] print;109 argument_list [110];110 attribute [111,112];111 identifier [] error;112 identifier [] cause;113 raise_statement [];114 expression_statement [115];115 assignment [116,117];116 identifier [] sender;117 call [118,119];118 identifier [] SpeadSender;119 argument_list [120];120 identifier [] spead_config;121 expression_statement [122];122 call [123,126];123 attribute [124,125];124 identifier [] sender;125 identifier [] run;126 argument_list [] | Main function for SPEAD sender module. |
0 module [1];1 function_definition [2,3,5];2 function_name [] close;3 parameters [4];4 identifier [] self;5 block [6];6 if_statement [7,11];7 not_operator [8];8 attribute [9,10];9 identifier [] self;10 identifier [] _closed;11 block [12];12 with_statement [13,18];13 with_clause [14];14 with_item [15];15 attribute [16,17];16 identifier [] self;17 identifier [] _lock;18 block [19];19 if_statement [20,24];20 not_operator [21];21 attribute [22,23];22 identifier [] self;23 identifier [] _closed;24 block [25,31,39,47];25 expression_statement [26];26 assignment [27,30];27 attribute [28,29];28 identifier [] self;29 identifier [] _closed;30 True [];31 expression_statement [32];32 call [33,38];33 attribute [34,37];34 attribute [35,36];35 identifier [] self;36 identifier [] _worker;37 identifier [] stop;38 argument_list [];39 expression_statement [40];40 call [41,46];41 attribute [42,45];42 attribute [43,44];43 identifier [] self;44 identifier [] _writer;45 identifier [] flush;46 argument_list [];47 expression_statement [48];48 call [49,54];49 attribute [50,53];50 attribute [51,52];51 identifier [] self;52 identifier [] _writer;53 identifier [] close;54 argument_list [] | Closes the underlying writer, flushing any pending writes first. |
0 module [1];1 function_definition [2,3,7];2 function_name [] start;3 parameters [4,5];4 identifier [] self;5 list_splat_pattern [6];6 identifier [] msg;7 block [8,20,29];8 expression_statement [9];9 assignment [10,13];10 attribute [11,12];11 identifier [] self;12 identifier [] start_time;13 call [14,19];14 attribute [15,18];15 attribute [16,17];16 identifier [] datetime;17 identifier [] datetime;18 identifier [] now;19 argument_list [];20 expression_statement [21];21 assignment [22,23];22 identifier [] label;23 call [24,27];24 attribute [25,26];25 identifier [] colors;26 identifier [] purple;27 argument_list [28];28 string [] START;29 expression_statement [30];30 call [31,34];31 attribute [32,33];32 identifier [] self;33 identifier [] _msg;34 argument_list [35,36];35 identifier [] label;36 list_splat [37];37 identifier [] msg | Prints an start message |
0 module [1];1 function_definition [2,3,7];2 function_name [] delete_row;3 parameters [4,5,6];4 identifier [] self;5 identifier [] key;6 identifier [] value;7 block [8];8 expression_statement [9];9 assignment [10,13];10 attribute [11,12];11 identifier [] self;12 identifier [] rows;13 call [14,15];14 identifier [] filter;15 argument_list [16,27];16 lambda [17,19];17 lambda_parameters [18];18 identifier [] x;19 comparison_operator [20,26] !=;20 call [21,24];21 attribute [22,23];22 identifier [] x;23 identifier [] get;24 argument_list [25];25 identifier [] key;26 identifier [] value;27 attribute [28,29];28 identifier [] self;29 identifier [] rows | Deletes the rows where key = value. |
0 module [1];1 function_definition [2,3,5];2 function_name [] patch_clean_fields;3 parameters [4];4 identifier [] model;5 block [6,12,86];6 expression_statement [7];7 assignment [8,9];8 identifier [] old_clean_fields;9 attribute [10,11];10 identifier [] model;11 identifier [] clean_fields;12 function_definition [13,14,19];13 function_name [] new_clean_fields;14 parameters [15,16];15 identifier [] self;16 default_parameter [17,18];17 identifier [] exclude;18 None [];19 block [20,80];20 if_statement [21,26];21 call [22,23];22 identifier [] hasattr;23 argument_list [24,25];24 identifier [] self;25 string [] _mt_form_pending_clear;26 block [27,74];27 for_statement [28,31,38];28 pattern_list [29,30];29 identifier [] field_name;30 identifier [] value;31 call [32,37];32 attribute [33,36];33 attribute [34,35];34 identifier [] self;35 identifier [] _mt_form_pending_clear;36 identifier [] items;37 argument_list [];38 block [39,50,58];39 expression_statement [40];40 assignment [41,42];41 identifier [] field;42 call [43,48];43 attribute [44,47];44 attribute [45,46];45 identifier [] self;46 identifier [] _meta;47 identifier [] get_field;48 argument_list [49];49 identifier [] field_name;50 expression_statement [51];51 assignment [52,53];52 identifier [] orig_field_name;53 attribute [54,57];54 attribute [55,56];55 identifier [] field;56 identifier [] translated_field;57 identifier [] name;58 if_statement [59,62];59 comparison_operator [60,61] in;60 identifier [] orig_field_name;61 identifier [] exclude;62 block [63];63 expression_statement [64];64 call [65,68];65 attribute [66,67];66 identifier [] field;67 identifier [] save_form_data;68 argument_list [69,70,71];69 identifier [] self;70 identifier [] value;71 keyword_argument [72,73];72 identifier [] check;73 False [];74 expression_statement [75];75 call [76,77];76 identifier [] delattr;77 argument_list [78,79];78 identifier [] self;79 string [] _mt_form_pending_clear;80 expression_statement [81];81 call [82,83];82 identifier [] old_clean_fields;83 argument_list [84,85];84 identifier [] self;85 identifier [] exclude;86 expression_statement [87];87 assignment [88,91];88 attribute [89,90];89 identifier [] model;90 identifier [] clean_fields;91 identifier [] new_clean_fields | Patch clean_fields method to handle different form types submission. |
0 module [1];1 function_definition [2,3,5];2 function_name [] postOptions;3 parameters [4];4 identifier [] self;5 block [6];6 if_statement [7,10,43];7 attribute [8,9];8 identifier [] self;9 identifier [] portIdentifiers;10 block [11,23,36,38];11 expression_statement [12];12 assignment [13,14];13 identifier [] store;14 call [15,22];15 attribute [16,21];16 attribute [17,20];17 attribute [18,19];18 identifier [] self;19 identifier [] parent;20 identifier [] parent;21 identifier [] getStore;22 argument_list [];23 expression_statement [24];24 call [25,28];25 attribute [26,27];26 identifier [] store;27 identifier [] transact;28 argument_list [29,32,33];29 attribute [30,31];30 identifier [] self;31 identifier [] _delete;32 identifier [] store;33 attribute [34,35];34 identifier [] self;35 identifier [] portIdentifiers;36 print_statement [37];37 string [] Deleted.;38 raise_statement [39];39 call [40,41];40 identifier [] SystemExit;41 argument_list [42];42 integer [] 0;43 else_clause [44];44 block [45];45 expression_statement [46];46 call [47,50];47 attribute [48,49];48 identifier [] self;49 identifier [] opt_help;50 argument_list [] | Delete the ports specified with the port-identifier option. |
0 module [1];1 function_definition [2,3,11];2 function_name [] get;3 parameters [4,5,6,9];4 identifier [] self;5 identifier [] stream;6 default_parameter [7,8];7 identifier [] fmt;8 string [] txt;9 dictionary_splat_pattern [10];10 identifier [] kwargs;11 block [12,37,52,63,77,94,104];12 expression_statement [13];13 assignment [14,15];14 identifier [] sel;15 call [16,19];16 attribute [17,18];17 string [];18 identifier [] join;19 argument_list [20];20 list_comprehension [21,28];21 call [22,25];22 attribute [23,24];23 string [] &{0}={1};24 identifier [] format;25 argument_list [26,27];26 identifier [] k;27 identifier [] v;28 for_in_clause [29,32];29 tuple_pattern [30,31];30 identifier [] k;31 identifier [] v;32 call [33,36];33 attribute [34,35];34 identifier [] kwargs;35 identifier [] items;36 argument_list [];37 expression_statement [38];38 assignment [39,40];39 identifier [] url;40 call [41,44];41 attribute [42,43];42 string [] streamds/{0}.{1}?{2};43 identifier [] format;44 argument_list [45,46,47];45 identifier [] stream;46 identifier [] fmt;47 subscript [48,49];48 identifier [] sel;49 slice [50,51];50 integer [] 1;51 colon [];52 expression_statement [53];53 assignment [54,55];54 identifier [] data;55 call [56,61];56 attribute [57,60];57 attribute [58,59];58 identifier [] self;59 identifier [] _db;60 identifier [] _get_content;61 argument_list [62];62 identifier [] url;63 if_statement [64,66];64 not_operator [65];65 identifier [] data;66 block [67,76];67 expression_statement [68];68 call [69,72];69 attribute [70,71];70 identifier [] log;71 identifier [] error;72 argument_list [73];73 binary_operator [74,75] %;74 string [] No data found at URL '%s'.;75 identifier [] url;76 return_statement [];77 if_statement [78,85];78 () [79];79 call [80,83];80 attribute [81,82];81 identifier [] data;82 identifier [] startswith;83 argument_list [84];84 string [] ERROR;85 block [86,93];86 expression_statement [87];87 call [88,91];88 attribute [89,90];89 identifier [] log;90 identifier [] error;91 argument_list [92];92 identifier [] data;93 return_statement [];94 if_statement [95,98];95 comparison_operator [96,97] ==;96 identifier [] fmt;97 string [] txt;98 block [99];99 return_statement [100];100 call [101,102];101 identifier [] read_csv;102 argument_list [103];103 identifier [] data;104 return_statement [105];105 identifier [] data | Get the data for a given stream manually |
0 module [1];1 function_definition [2,3,6];2 function_name [] extractContent;3 parameters [4,5];4 identifier [] self;5 identifier [] text;6 block [7,16];7 expression_statement [8];8 assignment [9,10];9 identifier [] m;10 call [11,14];11 attribute [12,13];12 identifier [] self;13 identifier [] nextValidComment;14 argument_list [15];15 identifier [] text;16 return_statement [17];17 conditional_expression [18,19,22] if;18 string [];19 comparison_operator [20,21] is;20 identifier [] m;21 None [];22 call [23,26];23 attribute [24,25];24 identifier [] m;25 identifier [] group;26 argument_list [27];27 integer [] 1 | Extract the content of comment text. |
0 module [1];1 function_definition [2,3,5];2 function_name [] run_once;3 parameters [4];4 identifier [] func;5 block [6,34,40];6 function_definition [7,8,13];7 function_name [] wrapper;8 parameters [9,11];9 list_splat_pattern [10];10 identifier [] args;11 dictionary_splat_pattern [12];12 identifier [] kwargs;13 block [14];14 if_statement [15,19];15 not_operator [16];16 attribute [17,18];17 identifier [] wrapper;18 identifier [] has_run;19 block [20,26];20 expression_statement [21];21 assignment [22,25];22 attribute [23,24];23 identifier [] wrapper;24 identifier [] has_run;25 True [];26 return_statement [27];27 call [28,29];28 identifier [] func;29 argument_list [30,32];30 list_splat [31];31 identifier [] args;32 dictionary_splat [33];33 identifier [] kwargs;34 expression_statement [35];35 assignment [36,39];36 attribute [37,38];37 identifier [] wrapper;38 identifier [] has_run;39 False [];40 return_statement [41];41 identifier [] wrapper | Decorator for making sure a method can only be executed once |
0 module [1];1 function_definition [2,3,5];2 function_name [] hash_dir;3 parameters [4];4 identifier [] path;5 block [6,10,75];6 expression_statement [7];7 assignment [8,9];8 identifier [] dir_hash;9 dictionary [];10 for_statement [11,15,24];11 pattern_list [12,13,14];12 identifier [] root;13 identifier [] dirs;14 identifier [] files;15 call [16,19];16 attribute [17,18];17 identifier [] os;18 identifier [] walk;19 argument_list [20,21];20 identifier [] path;21 keyword_argument [22,23];22 identifier [] topdown;23 False [];24 block [25,42,58];25 expression_statement [26];26 assignment [27,28];27 identifier [] f_hash;28 generator_expression [29,39];29 tuple [30,31];30 identifier [] f;31 call [32,33];32 identifier [] hash_file;33 argument_list [34];34 call [35,36];35 identifier [] join;36 argument_list [37,38];37 identifier [] root;38 identifier [] f;39 for_in_clause [40,41];40 identifier [] f;41 identifier [] files;42 expression_statement [43];43 assignment [44,45];44 identifier [] d_hash;45 generator_expression [46,55];46 tuple [47,48];47 identifier [] d;48 subscript [49,50];49 identifier [] dir_hash;50 call [51,52];51 identifier [] join;52 argument_list [53,54];53 identifier [] root;54 identifier [] d;55 for_in_clause [56,57];56 identifier [] d;57 identifier [] dirs;58 expression_statement [59];59 assignment [60,70];60 subscript [61,62];61 identifier [] dir_hash;62 call [63,64];63 identifier [] join;64 argument_list [65];65 list_splat [66];66 call [67,68];67 identifier [] split;68 argument_list [69];69 identifier [] root;70 call [71,72];71 identifier [] _mktree;72 argument_list [73,74];73 identifier [] f_hash;74 identifier [] d_hash;75 return_statement [76];76 subscript [77,78];77 identifier [] dir_hash;78 identifier [] path | Write directory at path to Git index, return its SHA1 as a string. |
0 module [1];1 function_definition [2,3,12,14];2 function_name [] debug_query_result;3 parameters [4];4 typed_parameter [5,6];5 identifier [] rows;6 type [7];7 generic_type [8,9];8 identifier [] Sequence;9 type_parameter [10];10 type [11];11 identifier [] Any;12 type [13];13 None [];14 block [15,26];15 expression_statement [16];16 call [17,20];17 attribute [18,19];18 identifier [] log;19 identifier [] info;20 argument_list [21,22];21 string [] Retrieved {} rows;22 call [23,24];23 identifier [] len;24 argument_list [25];25 identifier [] rows;26 for_statement [27,28,35];27 identifier [] i;28 call [29,30];29 identifier [] range;30 argument_list [31];31 call [32,33];32 identifier [] len;33 argument_list [34];34 identifier [] rows;35 block [36];36 expression_statement [37];37 call [38,41];38 attribute [39,40];39 identifier [] log;40 identifier [] info;41 argument_list [42,43,44];42 string [] Row {}: {};43 identifier [] i;44 subscript [45,46];45 identifier [] rows;46 identifier [] i | Writes a query result to the log. |
0 module [1];1 function_definition [2,3,5];2 function_name [] _counts;3 parameters [4];4 identifier [] self;5 block [6,20,67];6 expression_statement [7];7 assignment [8,9];8 identifier [] rolling_dim;9 call [10,13];10 attribute [11,12];11 identifier [] utils;12 identifier [] get_temp_dimname;13 argument_list [14,19];14 attribute [15,18];15 attribute [16,17];16 identifier [] self;17 identifier [] obj;18 identifier [] dims;19 string [] _rolling_dim;20 expression_statement [21];21 assignment [22,23];22 identifier [] counts;23 () [24];24 call [25,60];25 attribute [26,59];26 call [27,54];27 attribute [28,53];28 call [29,38];29 attribute [30,37];30 call [31,36];31 attribute [32,35];32 attribute [33,34];33 identifier [] self;34 identifier [] obj;35 identifier [] notnull;36 argument_list [];37 identifier [] rolling;38 argument_list [39,44];39 keyword_argument [40,41];40 identifier [] center;41 attribute [42,43];42 identifier [] self;43 identifier [] center;44 dictionary_splat [45];45 dictionary [46];46 pair [47,50];47 attribute [48,49];48 identifier [] self;49 identifier [] dim;50 attribute [51,52];51 identifier [] self;52 identifier [] window;53 identifier [] construct;54 argument_list [55,56];55 identifier [] rolling_dim;56 keyword_argument [57,58];57 identifier [] fill_value;58 False [];59 identifier [] sum;60 argument_list [61,64];61 keyword_argument [62,63];62 identifier [] dim;63 identifier [] rolling_dim;64 keyword_argument [65,66];65 identifier [] skipna;66 False [];67 return_statement [68];68 identifier [] counts | Number of non-nan entries in each rolling window. |
0 module [1];1 function_definition [2,3,5];2 function_name [] hook;3 parameters [4];4 identifier [] module;5 block [6,28];6 if_statement [7,12];7 comparison_operator [8,9] in;8 string [] INSTANA_DEV;9 attribute [10,11];10 identifier [] os;11 identifier [] environ;12 block [13,18,23];13 expression_statement [14];14 call [15,16];15 identifier [] print;16 argument_list [17];17 string [] ==============================================================;18 expression_statement [19];19 call [20,21];20 identifier [] print;21 argument_list [22];22 string [] Instana: Running flask hook;23 expression_statement [24];24 call [25,26];25 identifier [] print;26 argument_list [27];27 string [] ==============================================================;28 expression_statement [29];29 call [30,33];30 attribute [31,32];31 identifier [] wrapt;32 identifier [] wrap_function_wrapper;33 argument_list [34,35,36];34 string [] flask;35 string [] Flask.__init__;36 identifier [] wrapper | Hook method to install the Instana middleware into Flask |
0 module [1];1 function_definition [2,3,5];2 function_name [] _element_str;3 parameters [4];4 identifier [] self;5 block [6,52,60];6 if_statement [7,14,29];7 call [8,9];8 identifier [] isinstance;9 argument_list [10,13];10 attribute [11,12];11 identifier [] self;12 identifier [] element;13 identifier [] CIMProperty;14 block [15];15 return_statement [16];16 call [17,18];17 identifier [] _format;18 argument_list [19,20,23,26];19 string [] property {0!A} in class {1!A} (in {2!A});20 attribute [21,22];21 identifier [] self;22 identifier [] propname;23 attribute [24,25];24 identifier [] self;25 identifier [] classname;26 attribute [27,28];27 identifier [] self;28 identifier [] namespace;29 elif_clause [30,37];30 call [31,32];31 identifier [] isinstance;32 argument_list [33,36];33 attribute [34,35];34 identifier [] self;35 identifier [] element;36 identifier [] CIMMethod;37 block [38];38 return_statement [39];39 call [40,41];40 identifier [] _format;41 argument_list [42,43,46,49];42 string [] method {0!A} in class {1!A} (in {2!A});43 attribute [44,45];44 identifier [] self;45 identifier [] methodname;46 attribute [47,48];47 identifier [] self;48 identifier [] classname;49 attribute [50,51];50 identifier [] self;51 identifier [] namespace;52 assert_statement [53];53 call [54,55];54 identifier [] isinstance;55 argument_list [56,59];56 attribute [57,58];57 identifier [] self;58 identifier [] element;59 identifier [] CIMParameter;60 return_statement [61];61 call [62,63];62 identifier [] _format;63 argument_list [64,67,70,73,76];64 concatenated_string [65,66];65 string [] parameter {0!A} of method {1!A} in class {2!A};66 string [] (in {3!A});67 attribute [68,69];68 identifier [] self;69 identifier [] parametername;70 attribute [71,72];71 identifier [] self;72 identifier [] methodname;73 attribute [74,75];74 identifier [] self;75 identifier [] classname;76 attribute [77,78];77 identifier [] self;78 identifier [] namespace | Return a string that identifies the value-mapped element. |
0 module [1];1 function_definition [2,3,11];2 function_name [] read_buffer;3 parameters [4,5,8];4 identifier [] io;5 default_parameter [6,7];6 identifier [] print_output;7 False [];8 default_parameter [9,10];9 identifier [] print_func;10 None [];11 block [12,53,57,100];12 function_definition [13,14,16];13 function_name [] _print;14 parameters [15];15 identifier [] line;16 block [17];17 if_statement [18,19];18 identifier [] print_output;19 block [20,36,48];20 if_statement [21,22,30];21 identifier [] print_func;22 block [23];23 expression_statement [24];24 assignment [25,26];25 identifier [] formatted_line;26 call [27,28];27 identifier [] print_func;28 argument_list [29];29 identifier [] line;30 else_clause [31];31 block [32];32 expression_statement [33];33 assignment [34,35];34 identifier [] formatted_line;35 identifier [] line;36 expression_statement [37];37 assignment [38,39];38 identifier [] encoded_line;39 call [40,46];40 attribute [41,45];41 call [42,43];42 identifier [] unicode;43 argument_list [44];44 identifier [] formatted_line;45 identifier [] encode;46 argument_list [47];47 string [] utf-8;48 expression_statement [49];49 call [50,51];50 identifier [] print;51 argument_list [52];52 identifier [] encoded_line;53 expression_statement [54];54 assignment [55,56];55 identifier [] out;56 list [] [];57 for_statement [58,59,60];58 identifier [] line;59 identifier [] io;60 block [61,80,88,95];61 if_statement [62,70];62 not_operator [63];63 call [64,65];64 identifier [] isinstance;65 argument_list [66,67];66 identifier [] line;67 attribute [68,69];68 identifier [] six;69 identifier [] text_type;70 block [71];71 expression_statement [72];72 assignment [73,74];73 identifier [] line;74 call [75,78];75 attribute [76,77];76 identifier [] line;77 identifier [] decode;78 argument_list [79];79 string [] utf-8;80 expression_statement [81];81 assignment [82,83];82 identifier [] line;83 call [84,87];84 attribute [85,86];85 identifier [] line;86 identifier [] strip;87 argument_list [];88 expression_statement [89];89 call [90,93];90 attribute [91,92];91 identifier [] out;92 identifier [] append;93 argument_list [94];94 identifier [] line;95 expression_statement [96];96 call [97,98];97 identifier [] _print;98 argument_list [99];99 identifier [] line;100 return_statement [101];101 identifier [] out | Reads a file-like buffer object into lines and optionally prints the output. |
0 module [1];1 function_definition [2,3,6];2 function_name [] needed;3 parameters [4,5];4 identifier [] name;5 identifier [] required;6 block [7];7 return_statement [8];8 list_comprehension [9,23];9 conditional_expression [10,15,22] if;10 call [11,12];11 identifier [] relative_field;12 argument_list [13,14];13 identifier [] r;14 identifier [] name;15 boolean_operator [16,17] and;16 identifier [] r;17 call [18,19];18 identifier [] startswith_field;19 argument_list [20,21];20 identifier [] r;21 identifier [] name;22 None [];23 for_in_clause [24,25];24 identifier [] r;25 identifier [] required | RETURN SUBSET IF name IN REQUIRED |
0 module [1];1 function_definition [2,3,9];2 function_name [] intersection;3 parameters [4,5,6];4 identifier [] a;5 identifier [] b;6 default_parameter [7,8];7 identifier [] scale;8 integer [] 1;9 block [10,33,56,63,70];10 try_statement [11,18];11 block [12];12 expression_statement [13];13 assignment [14,17];14 pattern_list [15,16];15 identifier [] a1;16 identifier [] a2;17 identifier [] a;18 except_clause [19,20];19 identifier [] TypeError;20 block [21,27];21 expression_statement [22];22 assignment [23,24];23 identifier [] a1;24 attribute [25,26];25 identifier [] a;26 identifier [] start;27 expression_statement [28];28 assignment [29,30];29 identifier [] a2;30 attribute [31,32];31 identifier [] a;32 identifier [] stop;33 try_statement [34,41];34 block [35];35 expression_statement [36];36 assignment [37,40];37 pattern_list [38,39];38 identifier [] b1;39 identifier [] b2;40 identifier [] b;41 except_clause [42,43];42 identifier [] TypeError;43 block [44,50];44 expression_statement [45];45 assignment [46,47];46 identifier [] b1;47 attribute [48,49];48 identifier [] b;49 identifier [] start;50 expression_statement [51];51 assignment [52,53];52 identifier [] b2;53 attribute [54,55];54 identifier [] b;55 identifier [] stop;56 if_statement [57,60];57 comparison_operator [58,59] <=;58 identifier [] a2;59 identifier [] b1;60 block [61];61 return_statement [62];62 None [];63 if_statement [64,67];64 comparison_operator [65,66] >=;65 identifier [] a1;66 identifier [] b2;67 block [68];68 return_statement [69];69 None [];70 if_statement [71,74,102];71 comparison_operator [72,73] <=;72 identifier [] a2;73 identifier [] b2;74 block [75];75 if_statement [76,79,90];76 comparison_operator [77,78] <=;77 identifier [] a1;78 identifier [] b1;79 block [80];80 return_statement [81];81 call [82,83];82 identifier [] slice;83 argument_list [84,87];84 binary_operator [85,86] *;85 identifier [] b1;86 identifier [] scale;87 binary_operator [88,89] *;88 identifier [] a2;89 identifier [] scale;90 else_clause [91];91 block [92];92 return_statement [93];93 call [94,95];94 identifier [] slice;95 argument_list [96,99];96 binary_operator [97,98] *;97 identifier [] a1;98 identifier [] scale;99 binary_operator [100,101] *;100 identifier [] a2;101 identifier [] scale;102 else_clause [103];103 block [104];104 if_statement [105,108,119];105 comparison_operator [106,107] <=;106 identifier [] a1;107 identifier [] b1;108 block [109];109 return_statement [110];110 call [111,112];111 identifier [] slice;112 argument_list [113,116];113 binary_operator [114,115] *;114 identifier [] b1;115 identifier [] scale;116 binary_operator [117,118] *;117 identifier [] b2;118 identifier [] scale;119 else_clause [120];120 block [121];121 return_statement [122];122 call [123,124];123 identifier [] slice;124 argument_list [125,128];125 binary_operator [126,127] *;126 identifier [] a1;127 identifier [] scale;128 binary_operator [129,130] *;129 identifier [] b2;130 identifier [] scale | Intersection between two segments. |
0 module [1];1 function_definition [2,3,5];2 function_name [] split_source;3 parameters [4];4 identifier [] source_code;5 block [6,13];6 expression_statement [7];7 assignment [8,9];8 identifier [] eol_chars;9 call [10,11];10 identifier [] get_eol_chars;11 argument_list [12];12 identifier [] source_code;13 if_statement [14,15,23];14 identifier [] eol_chars;15 block [16];16 return_statement [17];17 call [18,21];18 attribute [19,20];19 identifier [] source_code;20 identifier [] split;21 argument_list [22];22 identifier [] eol_chars;23 else_clause [24];24 block [25];25 return_statement [26];26 list [27] [source_code];27 identifier [] source_code | Split source code into lines |
0 module [1];1 function_definition [2,3,5];2 function_name [] __fetch_heatmap_data_from_profile;3 parameters [4];4 identifier [] self;5 block [6,44,59,67,71,127];6 with_statement [7,21];7 with_clause [8];8 with_item [9];9 as_pattern [10,19];10 call [11,12];11 identifier [] open;12 argument_list [13,18];13 attribute [14,17];14 attribute [15,16];15 identifier [] self;16 identifier [] pyfile;17 identifier [] path;18 string [] r;19 as_pattern_target [20];20 identifier [] file_to_read;21 block [22];22 for_statement [23,24,25];23 identifier [] line;24 identifier [] file_to_read;25 block [26];26 expression_statement [27];27 call [28,35];28 attribute [29,34];29 attribute [30,33];30 attribute [31,32];31 identifier [] self;32 identifier [] pyfile;33 identifier [] lines;34 identifier [] append;35 argument_list [36];36 binary_operator [37,38] +;37 string [];38 call [39,42];39 attribute [40,41];40 identifier [] line;41 identifier [] strip;42 argument_list [43];43 string [] \n;44 expression_statement [45];45 assignment [46,51];46 attribute [47,50];47 attribute [48,49];48 identifier [] self;49 identifier [] pyfile;50 identifier [] length;51 call [52,53];52 identifier [] len;53 argument_list [54];54 attribute [55,58];55 attribute [56,57];56 identifier [] self;57 identifier [] pyfile;58 identifier [] lines;59 expression_statement [60];60 assignment [61,62];61 identifier [] line_profiles;62 call [63,66];63 attribute [64,65];64 identifier [] self;65 identifier [] __get_line_profile_data;66 argument_list [];67 expression_statement [68];68 assignment [69,70];69 identifier [] arr;70 list [] [];71 for_statement [72,73,84];72 identifier [] line_num;73 call [74,75];74 identifier [] range;75 argument_list [76,77];76 integer [] 1;77 binary_operator [78,83] +;78 attribute [79,82];79 attribute [80,81];80 identifier [] self;81 identifier [] pyfile;82 identifier [] length;83 integer [] 1;84 block [85];85 if_statement [86,89,117];86 comparison_operator [87,88] in;87 identifier [] line_num;88 identifier [] line_profiles;89 block [90,106];90 expression_statement [91];91 assignment [92,93];92 identifier [] line_times;93 list_comprehension [94,95];94 identifier [] ltime;95 for_in_clause [96,99];96 pattern_list [97,98];97 identifier [] _;98 identifier [] ltime;99 call [100,105];100 attribute [101,104];101 subscript [102,103];102 identifier [] line_profiles;103 identifier [] line_num;104 identifier [] values;105 argument_list [];106 expression_statement [107];107 call [108,111];108 attribute [109,110];109 identifier [] arr;110 identifier [] append;111 argument_list [112];112 list [113] [sum(line_times)];113 call [114,115];114 identifier [] sum;115 argument_list [116];116 identifier [] line_times;117 else_clause [118];118 block [119];119 expression_statement [120];120 call [121,124];121 attribute [122,123];122 identifier [] arr;123 identifier [] append;124 argument_list [125];125 list [126] [0.0];126 float [] 0.0;127 expression_statement [128];128 assignment [129,134];129 attribute [130,133];130 attribute [131,132];131 identifier [] self;132 identifier [] pyfile;133 identifier [] data;134 call [135,138];135 attribute [136,137];136 identifier [] np;137 identifier [] array;138 argument_list [139];139 identifier [] arr | Method to create heatmap data from profile information. |
0 module [1];1 function_definition [2,3,12];2 function_name [] fixpix2;3 parameters [4,5,6,9];4 identifier [] data;5 identifier [] mask;6 default_parameter [7,8];7 identifier [] iterations;8 integer [] 3;9 default_parameter [10,11];10 identifier [] out;11 None [];12 block [13,26,32,43,53,59,158];13 expression_statement [14];14 assignment [15,16];15 identifier [] out;16 conditional_expression [17,18,21] if;17 identifier [] out;18 comparison_operator [19,20] is not;19 identifier [] out;20 None [];21 call [22,25];22 attribute [23,24];23 identifier [] data;24 identifier [] copy;25 argument_list [];26 expression_statement [27];27 assignment [28,29];28 identifier [] binry;29 comparison_operator [30,31] !=;30 identifier [] mask;31 integer [] 0;32 expression_statement [33];33 assignment [34,37];34 pattern_list [35,36];35 identifier [] lblarr;36 identifier [] labl;37 call [38,41];38 attribute [39,40];39 identifier [] ndimage;40 identifier [] label;41 argument_list [42];42 identifier [] binry;43 expression_statement [44];44 assignment [45,46];45 identifier [] stct;46 call [47,50];47 attribute [48,49];48 identifier [] ndimage;49 identifier [] generate_binary_structure;50 argument_list [51,52];51 integer [] 2;52 integer [] 2;53 expression_statement [54];54 assignment [55,56];55 identifier [] back;56 comparison_operator [57,58] ==;57 identifier [] lblarr;58 integer [] 0;59 for_statement [60,61,68];60 identifier [] idx;61 call [62,63];62 identifier [] range;63 argument_list [64,65];64 integer [] 1;65 binary_operator [66,67] +;66 identifier [] labl;67 integer [] 1;68 block [69,75,85,101,116,126,138,148];69 expression_statement [70];70 assignment [71,72];71 identifier [] segm;72 comparison_operator [73,74] ==;73 identifier [] lblarr;74 identifier [] idx;75 expression_statement [76];76 assignment [77,78];77 identifier [] dilmask;78 call [79,82];79 attribute [80,81];80 identifier [] numpy;81 identifier [] logical_or;82 argument_list [83,84];83 identifier [] back;84 identifier [] segm;85 expression_statement [86];86 assignment [87,88];87 identifier [] more;88 call [89,92];89 attribute [90,91];90 identifier [] ndimage;91 identifier [] binary_dilation;92 argument_list [93,94,95,98];93 identifier [] segm;94 identifier [] stct;95 keyword_argument [96,97];96 identifier [] iterations;97 identifier [] iterations;98 keyword_argument [99,100];99 identifier [] mask;100 identifier [] dilmask;101 expression_statement [102];102 assignment [103,104];103 identifier [] border;104 call [105,108];105 attribute [106,107];106 identifier [] numpy;107 identifier [] logical_and;108 argument_list [109,110];109 identifier [] more;110 call [111,114];111 attribute [112,113];112 identifier [] numpy;113 identifier [] logical_not;114 argument_list [115];115 identifier [] segm;116 expression_statement [117];117 assignment [118,121];118 pattern_list [119,120];119 identifier [] xi;120 identifier [] yi;121 call [122,125];122 attribute [123,124];123 identifier [] border;124 identifier [] nonzero;125 argument_list [];126 expression_statement [127];127 assignment [128,129];128 identifier [] calc;129 call [130,131];130 identifier [] FitOne;131 argument_list [132,133,134];132 identifier [] xi;133 identifier [] yi;134 subscript [135,136,137];135 identifier [] out;136 identifier [] xi;137 identifier [] yi;138 expression_statement [139];139 assignment [140,143];140 pattern_list [141,142];141 identifier [] xi;142 identifier [] yi;143 call [144,147];144 attribute [145,146];145 identifier [] segm;146 identifier [] nonzero;147 argument_list [];148 expression_statement [149];149 assignment [150,153];150 subscript [151,152];151 identifier [] out;152 identifier [] segm;153 call [154,155];154 identifier [] calc;155 argument_list [156,157];156 identifier [] xi;157 identifier [] yi;158 return_statement [159];159 identifier [] out | Substitute pixels in mask by a bilinear least square fitting. |
0 module [1];1 function_definition [2,3,9];2 function_name [] gauge;3 parameters [4,5,7];4 identifier [] self;5 list_splat_pattern [6];6 identifier [] args;7 dictionary_splat_pattern [8];8 identifier [] kwargs;9 block [10,20,38];10 expression_statement [11];11 assignment [12,13];12 identifier [] orig_gauge;13 attribute [14,19];14 call [15,16];15 identifier [] super;16 argument_list [17,18];17 identifier [] Nagios;18 identifier [] self;19 identifier [] gauge;20 if_statement [21,33];21 boolean_operator [22,25] and;22 comparison_operator [23,24] in;23 string [] timestamp;24 identifier [] kwargs;25 comparison_operator [26,27] not in;26 string [] timestamp;27 attribute [28,32];28 call [29,30];29 identifier [] getargspec;30 argument_list [31];31 identifier [] orig_gauge;32 identifier [] args;33 block [34];34 delete_statement [35];35 subscript [36,37];36 identifier [] kwargs;37 string [] timestamp;38 expression_statement [39];39 call [40,41];40 identifier [] orig_gauge;41 argument_list [42,44];42 list_splat [43];43 identifier [] args;44 dictionary_splat [45];45 identifier [] kwargs | Compatability wrapper for Agents that do not submit gauge metrics with custom timestamps |
0 module [1];1 function_definition [2,3,7];2 function_name [] _get_token_encoder;3 parameters [4,5,6];4 identifier [] vocab_dir;5 identifier [] vocab_name;6 identifier [] filename;7 block [8,20,38];8 expression_statement [9];9 assignment [10,11];10 identifier [] vocab_path;11 call [12,17];12 attribute [13,16];13 attribute [14,15];14 identifier [] os;15 identifier [] path;16 identifier [] join;17 argument_list [18,19];18 identifier [] vocab_dir;19 identifier [] vocab_name;20 if_statement [21,30];21 not_operator [22];22 call [23,28];23 attribute [24,27];24 attribute [25,26];25 identifier [] tf;26 identifier [] gfile;27 identifier [] Exists;28 argument_list [29];29 identifier [] vocab_path;30 block [31];31 expression_statement [32];32 call [33,34];33 identifier [] _build_vocab;34 argument_list [35,36,37];35 identifier [] filename;36 identifier [] vocab_path;37 integer [] 10000;38 return_statement [39];39 call [40,43];40 attribute [41,42];41 identifier [] text_encoder;42 identifier [] TokenTextEncoder;43 argument_list [44];44 identifier [] vocab_path | Reads from file and returns a `TokenTextEncoder` for the vocabulary. |
0 module [1];1 function_definition [2,3,9];2 function_name [] _parse;3 parameters [4,5,6];4 identifier [] self;5 identifier [] date_str;6 default_parameter [7,8];7 identifier [] format;8 string [] %Y-%m-%d;9 block [10,22,37];10 expression_statement [11];11 assignment [12,13];12 identifier [] rv;13 call [14,17];14 attribute [15,16];15 identifier [] pd;16 identifier [] to_datetime;17 argument_list [18,19];18 identifier [] date_str;19 keyword_argument [20,21];20 identifier [] format;21 identifier [] format;22 if_statement [23,28];23 call [24,25];24 identifier [] hasattr;25 argument_list [26,27];26 identifier [] rv;27 string [] to_pydatetime;28 block [29];29 expression_statement [30];30 assignment [31,32];31 identifier [] rv;32 call [33,36];33 attribute [34,35];34 identifier [] rv;35 identifier [] to_pydatetime;36 argument_list [];37 return_statement [38];38 identifier [] rv | helper function for parsing FRED date string into datetime |
0 module [1];1 function_definition [2,3,9];2 function_name [] find_archive_program;3 parameters [4,5,6];4 identifier [] format;5 identifier [] command;6 default_parameter [7,8];7 identifier [] program;8 None [];9 block [10,16,20,32,52,67,112];10 expression_statement [11];11 assignment [12,13];12 identifier [] commands;13 subscript [14,15];14 identifier [] ArchivePrograms;15 identifier [] format;16 expression_statement [17];17 assignment [18,19];18 identifier [] programs;19 list [] [];20 if_statement [21,24];21 comparison_operator [22,23] is not;22 identifier [] program;23 None [];24 block [25];25 expression_statement [26];26 call [27,30];27 attribute [28,29];28 identifier [] programs;29 identifier [] append;30 argument_list [31];31 identifier [] program;32 for_statement [33,34,37];33 identifier [] key;34 tuple [35,36];35 None [];36 identifier [] command;37 block [38];38 if_statement [39,42];39 comparison_operator [40,41] in;40 identifier [] key;41 identifier [] commands;42 block [43];43 expression_statement [44];44 call [45,48];45 attribute [46,47];46 identifier [] programs;47 identifier [] extend;48 argument_list [49];49 subscript [50,51];50 identifier [] commands;51 identifier [] key;52 if_statement [53,55];53 not_operator [54];54 identifier [] programs;55 block [56];56 raise_statement [57];57 call [58,61];58 attribute [59,60];59 identifier [] util;60 identifier [] PatoolError;61 argument_list [62];62 binary_operator [63,64] %;63 string [] %s archive format `%s' is not supported;64 tuple [65,66];65 identifier [] command;66 identifier [] format;67 for_statement [68,69,70];68 identifier [] program;69 identifier [] programs;70 block [71,81,90];71 if_statement [72,78];72 call [73,76];73 attribute [74,75];74 identifier [] program;75 identifier [] startswith;76 argument_list [77];77 string [] py_;78 block [79];79 return_statement [80];80 identifier [] program;81 expression_statement [82];82 assignment [83,84];83 identifier [] exe;84 call [85,88];85 attribute [86,87];86 identifier [] util;87 identifier [] find_program;88 argument_list [89];89 identifier [] program;90 if_statement [91,92];91 identifier [] exe;92 block [93,110];93 if_statement [94,108];94 boolean_operator [95,102] and;95 boolean_operator [96,99] and;96 comparison_operator [97,98] ==;97 identifier [] program;98 string [] 7z;99 comparison_operator [100,101] ==;100 identifier [] format;101 string [] rar;102 not_operator [103];103 call [104,107];104 attribute [105,106];105 identifier [] util;106 identifier [] p7zip_supports_rar;107 argument_list [];108 block [109];109 continue_statement [];110 return_statement [111];111 identifier [] exe;112 raise_statement [113];113 call [114,117];114 attribute [115,116];115 identifier [] util;116 identifier [] PatoolError;117 argument_list [118];118 binary_operator [119,120] %;119 string [] could not find an executable program to %s format %s; candidates are (%s),;120 tuple [121,122,123];121 identifier [] command;122 identifier [] format;123 call [124,127];124 attribute [125,126];125 string [] ,;126 identifier [] join;127 argument_list [128];128 identifier [] programs | Find suitable archive program for given format and mode. |
0 module [1];1 function_definition [2,3,5];2 function_name [] validate;3 parameters [4];4 identifier [] self;5 block [6,34];6 if_statement [7,15];7 not_operator [8];8 call [9,10];9 identifier [] isinstance;10 argument_list [11,14];11 attribute [12,13];12 identifier [] self;13 identifier [] fold_scope_location;14 identifier [] FoldScopeLocation;15 block [16];16 raise_statement [17];17 call [18,19];18 identifier [] TypeError;19 argument_list [20];20 call [21,24];21 attribute [22,23];22 string [] u'Expected FoldScopeLocation fold_scope_location, got: {} {}';23 identifier [] format;24 argument_list [25,31];25 call [26,27];26 identifier [] type;27 argument_list [28];28 attribute [29,30];29 identifier [] self;30 identifier [] fold_scope_location;31 attribute [32,33];32 identifier [] self;33 identifier [] fold_scope_location;34 if_statement [35,42];35 comparison_operator [36,41] !=;36 attribute [37,40];37 attribute [38,39];38 identifier [] self;39 identifier [] fold_scope_location;40 identifier [] field;41 identifier [] COUNT_META_FIELD_NAME;42 block [43];43 raise_statement [44];44 call [45,46];45 identifier [] AssertionError;46 argument_list [47];47 call [48,53];48 attribute [49,52];49 concatenated_string [50,51];50 string [] u'Unexpected field in the FoldScopeLocation of this ';51 string [] u'FoldCountContextField object: {} {}';52 identifier [] format;53 argument_list [54,57];54 attribute [55,56];55 identifier [] self;56 identifier [] fold_scope_location;57 identifier [] self | Validate that the FoldCountContextField is correctly representable. |
0 module [1];1 function_definition [2,3,6];2 function_name [] loadJson;3 parameters [4,5];4 identifier [] self;5 identifier [] data;6 block [7,24,33,39];7 if_statement [8,14];8 not_operator [9];9 call [10,11];10 identifier [] isinstance;11 argument_list [12,13];12 identifier [] data;13 identifier [] dict;14 block [15];15 expression_statement [16];16 assignment [17,18];17 identifier [] data;18 call [19,22];19 attribute [20,21];20 identifier [] json;21 identifier [] loads;22 argument_list [23];23 identifier [] data;24 expression_statement [25];25 call [26,31];26 attribute [27,30];27 attribute [28,29];28 identifier [] self;29 identifier [] __dict__;30 identifier [] update;31 argument_list [32];32 identifier [] data;33 expression_statement [34];34 call [35,38];35 attribute [36,37];36 identifier [] self;37 identifier [] inflate;38 argument_list [];39 return_statement [40];40 identifier [] self | convert the json data into updating this obj's attrs |
0 module [1];1 function_definition [2,3,5];2 function_name [] check_credentials;3 parameters [4];4 identifier [] client;5 block [6,16,24,33,49,62];6 expression_statement [7];7 assignment [8,12];8 pattern_list [9,10,11];9 identifier [] pid;10 identifier [] uid;11 identifier [] gid;12 call [13,14];13 identifier [] get_peercred;14 argument_list [15];15 identifier [] client;16 expression_statement [17];17 assignment [18,19];18 identifier [] euid;19 call [20,23];20 attribute [21,22];21 identifier [] os;22 identifier [] geteuid;23 argument_list [];24 expression_statement [25];25 assignment [26,27];26 identifier [] client_name;27 binary_operator [28,29] %;28 string [] PID:%s UID:%s GID:%s;29 tuple [30,31,32];30 identifier [] pid;31 identifier [] uid;32 identifier [] gid;33 if_statement [34,39];34 comparison_operator [35,36] not in;35 identifier [] uid;36 tuple [37,38];37 integer [] 0;38 identifier [] euid;39 block [40];40 raise_statement [41];41 call [42,43];42 identifier [] SuspiciousClient;43 argument_list [44];44 binary_operator [45,46] %;45 string [] Can't accept client with %s. It doesn't match the current EUID:%s or ROOT.;46 tuple [47,48];47 identifier [] client_name;48 identifier [] euid;49 expression_statement [50];50 call [51,52];51 identifier [] _LOG;52 argument_list [53];53 binary_operator [54,55] %;54 string [] Accepted connection on fd:%s from %s;55 tuple [56,61];56 call [57,60];57 attribute [58,59];58 identifier [] client;59 identifier [] fileno;60 argument_list [];61 identifier [] client_name;62 return_statement [63];63 expression_list [64,65,66];64 identifier [] pid;65 identifier [] uid;66 identifier [] gid | Checks credentials for given socket. |
0 module [1];1 function_definition [2,3,5];2 function_name [] _check_users;3 parameters [4];4 identifier [] users;5 block [6,10,14,80];6 expression_statement [7];7 assignment [8,9];8 identifier [] messg;9 string [];10 expression_statement [11];11 assignment [12,13];12 identifier [] valid;13 True [];14 for_statement [15,18,24];15 pattern_list [16,17];16 identifier [] user;17 identifier [] user_details;18 call [19,22];19 attribute [20,21];20 identifier [] six;21 identifier [] iteritems;22 argument_list [23];23 identifier [] users;24 block [25,45];25 if_statement [26,28];26 not_operator [27];27 identifier [] user_details;28 block [29,33,44];29 expression_statement [30];30 assignment [31,32];31 identifier [] valid;32 False [];33 expression_statement [34];34 augmented_assignment [35,36] +=;35 identifier [] messg;36 call [37,40];37 attribute [38,39];38 string [] Please provide details for username {user}.\n;39 identifier [] format;40 argument_list [41];41 keyword_argument [42,43];42 identifier [] user;43 identifier [] user;44 continue_statement [];45 if_statement [46,68];46 not_operator [47];47 () [48];48 boolean_operator [49,59] or;49 call [50,51];50 identifier [] isinstance;51 argument_list [52,58];52 call [53,56];53 attribute [54,55];54 identifier [] user_details;55 identifier [] get;56 argument_list [57];57 string [] level;58 identifier [] int;59 comparison_operator [60,61,67] <=;60 integer [] 0;61 call [62,65];62 attribute [63,64];63 identifier [] user_details;64 identifier [] get;65 argument_list [66];66 string [] level;67 integer [] 15;68 block [69];69 expression_statement [70];70 augmented_assignment [71,72] +=;71 identifier [] messg;72 call [73,76];73 attribute [74,75];74 string [] Level must be a integer between 0 and 15 for username {user}. Will assume 0.\n;75 identifier [] format;76 argument_list [77];77 keyword_argument [78,79];78 identifier [] user;79 identifier [] user;80 return_statement [81];81 expression_list [82,83];82 identifier [] valid;83 identifier [] messg | Checks if the input dictionary of users is valid. |
0 module [1];1 function_definition [2,3,9];2 function_name [] build_trainer;3 parameters [4,5,6];4 identifier [] nn;5 identifier [] ds;6 default_parameter [7,8];7 identifier [] verbosity;8 integer [] 1;9 block [10];10 return_statement [11];11 call [12,21];12 attribute [13,20];13 attribute [14,19];14 attribute [15,18];15 attribute [16,17];16 identifier [] pb;17 identifier [] supervised;18 identifier [] trainers;19 identifier [] rprop;20 identifier [] RPropMinusTrainer;21 argument_list [22,23,26,29];22 identifier [] nn;23 keyword_argument [24,25];24 identifier [] dataset;25 identifier [] ds;26 keyword_argument [27,28];27 identifier [] batchlearning;28 True [];29 keyword_argument [30,31];30 identifier [] verbose;31 call [32,33];32 identifier [] bool;33 argument_list [34];34 identifier [] verbosity | Configure neural net trainer from a pybrain dataset |
0 module [1];1 function_definition [2,3,5];2 function_name [] login;3 parameters [4];4 identifier [] self;5 block [6,31,48,55,66,98];6 if_statement [7,12,19];7 attribute [8,11];8 attribute [9,10];9 identifier [] self;10 identifier [] args;11 identifier [] snmp_force;12 block [13];13 expression_statement [14];14 assignment [15,18];15 attribute [16,17];16 identifier [] self;17 identifier [] client_mode;18 string [] snmp;19 else_clause [20];20 block [21];21 if_statement [22,28];22 not_operator [23];23 call [24,27];24 attribute [25,26];25 identifier [] self;26 identifier [] _login_glances;27 argument_list [];28 block [29];29 return_statement [30];30 False [];31 if_statement [32,37];32 comparison_operator [33,36] ==;33 attribute [34,35];34 identifier [] self;35 identifier [] client_mode;36 string [] snmp;37 block [38];38 if_statement [39,45];39 not_operator [40];40 call [41,44];41 attribute [42,43];42 identifier [] self;43 identifier [] _login_snmp;44 argument_list [];45 block [46];46 return_statement [47];47 False [];48 expression_statement [49];49 call [50,53];50 attribute [51,52];51 identifier [] logger;52 identifier [] debug;53 argument_list [54];54 string [] Load limits from the client configuration file;55 expression_statement [56];56 call [57,62];57 attribute [58,61];58 attribute [59,60];59 identifier [] self;60 identifier [] stats;61 identifier [] load_limits;62 argument_list [63];63 attribute [64,65];64 identifier [] self;65 identifier [] config;66 if_statement [67,70,78];67 attribute [68,69];68 identifier [] self;69 identifier [] quiet;70 block [71];71 expression_statement [72];72 call [73,76];73 attribute [74,75];74 identifier [] logger;75 identifier [] info;76 argument_list [77];77 string [] Quiet mode is ON: Nothing will be displayed;78 else_clause [79];79 block [80];80 expression_statement [81];81 assignment [82,85];82 attribute [83,84];83 identifier [] self;84 identifier [] screen;85 call [86,87];86 identifier [] GlancesCursesClient;87 argument_list [88,93];88 keyword_argument [89,90];89 identifier [] config;90 attribute [91,92];91 identifier [] self;92 identifier [] config;93 keyword_argument [94,95];94 identifier [] args;95 attribute [96,97];96 identifier [] self;97 identifier [] args;98 return_statement [99];99 True [] | Logon to the server. |
0 module [1];1 function_definition [2,3,7];2 function_name [] find_object;3 parameters [4,5,6];4 identifier [] self;5 identifier [] key;6 identifier [] layers;7 block [8,14,33,54];8 expression_statement [9];9 assignment [10,11];10 identifier [] state;11 attribute [12,13];12 identifier [] self;13 identifier [] state;14 if_statement [15,22];15 boolean_operator [16,19] or;16 comparison_operator [17,18] is;17 identifier [] layers;18 None [];19 comparison_operator [20,21] ==;20 identifier [] layers;21 string [];22 block [23];23 expression_statement [24];24 assignment [25,26];25 identifier [] layers;26 call [27,32];27 attribute [28,31];28 attribute [29,30];29 identifier [] state;30 identifier [] layers;31 identifier [] keys;32 argument_list [];33 for_statement [34,35,36];34 identifier [] layer;35 identifier [] layers;36 block [37];37 if_statement [38,45];38 comparison_operator [39,40] in;39 identifier [] key;40 subscript [41,44];41 attribute [42,43];42 identifier [] state;43 identifier [] layers;44 identifier [] layer;45 block [46];46 return_statement [47];47 subscript [48,53];48 subscript [49,52];49 attribute [50,51];50 identifier [] state;51 identifier [] layers;52 identifier [] layer;53 identifier [] key;54 return_statement [55];55 None [] | find an object to be modified |
0 module [1];1 function_definition [2,3,5];2 function_name [] clean;3 parameters [4];4 identifier [] self;5 block [6,12,36,51,57];6 expression_statement [7];7 call [8,11];8 attribute [9,10];9 identifier [] self;10 identifier [] feed;11 argument_list [];12 if_statement [13,20];13 comparison_operator [14,19] !=;14 subscript [15,18];15 attribute [16,17];16 identifier [] self;17 identifier [] current_parent_element;18 string [] tag;19 string [];20 block [21];21 expression_statement [22];22 augmented_assignment [23,26] +=;23 attribute [24,25];24 identifier [] self;25 identifier [] cleaned_html;26 call [27,30];27 attribute [28,29];28 string [] </{}>;29 identifier [] format;30 argument_list [31];31 subscript [32,35];32 attribute [33,34];33 identifier [] self;34 identifier [] current_parent_element;35 string [] tag;36 expression_statement [37];37 assignment [38,41];38 attribute [39,40];39 identifier [] self;40 identifier [] cleaned_html;41 call [42,45];42 attribute [43,44];43 identifier [] re;44 identifier [] sub;45 argument_list [46,47,48];46 string [] r'(</[u|o]l>)<p></p>';47 string [] r'\g<1>';48 attribute [49,50];49 identifier [] self;50 identifier [] cleaned_html;51 expression_statement [52];52 call [53,56];53 attribute [54,55];54 identifier [] self;55 identifier [] _remove_pre_formatting;56 argument_list [];57 return_statement [58];58 attribute [59,60];59 identifier [] self;60 identifier [] cleaned_html | Goes through the txt input and cleans up any problematic HTML. |
0 module [1];1 function_definition [2,3,5];2 function_name [] dump;3 parameters [4];4 identifier [] self;5 block [6,25];6 expression_statement [7];7 assignment [8,9];8 identifier [] subtoken_strings;9 list_comprehension [10,13];10 tuple [11,12];11 identifier [] i;12 identifier [] s;13 for_in_clause [14,17];14 pattern_list [15,16];15 identifier [] s;16 identifier [] i;17 call [18,21];18 attribute [19,20];19 identifier [] six;20 identifier [] iteritems;21 argument_list [22];22 attribute [23,24];23 identifier [] self;24 identifier [] _subtoken_string_to_id;25 expression_statement [26];26 call [27,28];27 identifier [] print;28 argument_list [29];29 call [30,33];30 attribute [31,32];31 string [] u", ";32 identifier [] join;33 generator_expression [34,41];34 call [35,38];35 attribute [36,37];36 string [] u"{0} : '{1}'";37 identifier [] format;38 argument_list [39,40];39 identifier [] i;40 identifier [] s;41 for_in_clause [42,45];42 pattern_list [43,44];43 identifier [] i;44 identifier [] s;45 call [46,47];46 identifier [] sorted;47 argument_list [48];48 identifier [] subtoken_strings | Debugging dump of the current subtoken vocabulary. |
0 module [1];1 function_definition [2,3,5];2 function_name [] _environment_sanity_check;3 parameters [4];4 identifier [] environment;5 block [6,17,33,43];6 assert_statement [7,14];7 call [8,9];8 identifier [] issubclass;9 argument_list [10,13];10 attribute [11,12];11 identifier [] environment;12 identifier [] undefined;13 identifier [] Undefined;14 concatenated_string [15,16];15 string [] undefined must;16 string [] be a subclass of undefined because filters depend on it.;17 assert_statement [18,30];18 comparison_operator [19,22,23,26,27] !=;19 attribute [20,21];20 identifier [] environment;21 identifier [] block_start_string;22 line_continuation [] \;23 attribute [24,25];24 identifier [] environment;25 identifier [] variable_start_string;26 line_continuation [] \;27 attribute [28,29];28 identifier [] environment;29 identifier [] comment_start_string;30 concatenated_string [31,32];31 string [] block, variable and comment;32 string [] start strings must be different;33 assert_statement [34,42];34 comparison_operator [35,38] in;35 attribute [36,37];36 identifier [] environment;37 identifier [] newline_sequence;38 tuple [39,40,41];39 string [] \r;40 string [] \r\n;41 string [] \n;42 string [] newline_sequence set to unknown line ending string.;43 return_statement [44];44 identifier [] environment | Perform a sanity check on the environment. |
0 module [1];1 function_definition [2,3,5];2 function_name [] _loadcache;3 parameters [4];4 identifier [] cachefile;5 block [6,10,72];6 expression_statement [7];7 assignment [8,9];8 identifier [] cache;9 dictionary [];10 if_statement [11,19];11 call [12,17];12 attribute [13,16];13 attribute [14,15];14 identifier [] os;15 identifier [] path;16 identifier [] exists;17 argument_list [18];18 identifier [] cachefile;19 block [20];20 with_statement [21,30];21 with_clause [22];22 with_item [23];23 as_pattern [24,28];24 call [25,26];25 identifier [] open;26 argument_list [27];27 identifier [] cachefile;28 as_pattern_target [29];29 identifier [] f;30 block [31];31 for_statement [32,33,34];32 identifier [] line;33 identifier [] f;34 block [35,43];35 expression_statement [36];36 assignment [37,38];37 identifier [] line;38 call [39,42];39 attribute [40,41];40 identifier [] line;41 identifier [] split;42 argument_list [];43 if_statement [44,50];44 comparison_operator [45,49] ==;45 call [46,47];46 identifier [] len;47 argument_list [48];48 identifier [] line;49 integer [] 2;50 block [51];51 try_statement [52,69];52 block [53];53 expression_statement [54];54 assignment [55,63];55 subscript [56,57];56 identifier [] cache;57 call [58,59];58 identifier [] int;59 argument_list [60];60 subscript [61,62];61 identifier [] line;62 integer [] 0;63 call [64,65];64 identifier [] float;65 argument_list [66];66 subscript [67,68];67 identifier [] line;68 integer [] 1;69 except_clause [70];70 block [71];71 pass_statement [];72 return_statement [73];73 identifier [] cache | Returns a dictionary resulting from reading a likelihood cachefile |
0 module [1];1 function_definition [2,3,8];2 function_name [] check_program_compression;3 parameters [4,5,6,7];4 identifier [] archive;5 identifier [] command;6 identifier [] program;7 identifier [] compression;8 block [9,20];9 expression_statement [10];10 assignment [11,12];11 identifier [] program;12 call [13,18];13 attribute [14,17];14 attribute [15,16];15 identifier [] os;16 identifier [] path;17 identifier [] basename;18 argument_list [19];19 identifier [] program;20 if_statement [21,22];21 identifier [] compression;22 block [23];23 if_statement [24,30];24 not_operator [25];25 call [26,27];26 identifier [] program_supports_compression;27 argument_list [28,29];28 identifier [] program;29 identifier [] compression;30 block [31,46,54];31 if_statement [32,35,40];32 comparison_operator [33,34] ==;33 identifier [] command;34 string [] create;35 block [36];36 expression_statement [37];37 assignment [38,39];38 identifier [] comp_command;39 identifier [] command;40 else_clause [41];41 block [42];42 expression_statement [43];43 assignment [44,45];44 identifier [] comp_command;45 string [] extract;46 expression_statement [47];47 assignment [48,49];48 identifier [] comp_prog;49 call [50,51];50 identifier [] find_archive_program;51 argument_list [52,53];52 identifier [] compression;53 identifier [] comp_command;54 if_statement [55,57];55 not_operator [56];56 identifier [] comp_prog;57 block [58,62];58 expression_statement [59];59 assignment [60,61];60 identifier [] msg;61 string [] cannot %s archive `%s': compression `%s' not supported;62 raise_statement [63];63 call [64,67];64 attribute [65,66];65 identifier [] util;66 identifier [] PatoolError;67 argument_list [68];68 binary_operator [69,70] %;69 identifier [] msg;70 tuple [71,72,73];71 identifier [] command;72 identifier [] archive;73 identifier [] compression | Check if a program supports the given compression. |
0 module [1];1 function_definition [2,3,20];2 function_name [] stream_data;3 parameters [4,5,8,11,14,17];4 identifier [] self;5 default_parameter [6,7];6 identifier [] host;7 identifier [] HOST;8 default_parameter [9,10];9 identifier [] port;10 identifier [] GPSD_PORT;11 default_parameter [12,13];12 identifier [] enable;13 True [];14 default_parameter [15,16];15 identifier [] gpsd_protocol;16 identifier [] PROTOCOL;17 default_parameter [18,19];18 identifier [] devicepath;19 None [];20 block [21,31];21 expression_statement [22];22 call [23,28];23 attribute [24,27];24 attribute [25,26];25 identifier [] self;26 identifier [] socket;27 identifier [] connect;28 argument_list [29,30];29 identifier [] host;30 identifier [] port;31 expression_statement [32];32 call [33,38];33 attribute [34,37];34 attribute [35,36];35 identifier [] self;36 identifier [] socket;37 identifier [] watch;38 argument_list [39,40,41];39 identifier [] enable;40 identifier [] gpsd_protocol;41 identifier [] devicepath | Connect and command, point and shoot, flail and bail |
0 module [1];1 function_definition [2,3,6];2 function_name [] find_in_path;3 parameters [4,5];4 identifier [] name;5 identifier [] path;6 block [7,9,51];7 expression_statement [8];8 string [] Find a file in a search path;9 for_statement [10,11,19];10 identifier [] dir;11 call [12,15];12 attribute [13,14];13 identifier [] path;14 identifier [] split;15 argument_list [16];16 attribute [17,18];17 identifier [] os;18 identifier [] pathsep;19 block [20,32];20 expression_statement [21];21 assignment [22,23];22 identifier [] binpath;23 call [24,29];24 attribute [25,28];25 attribute [26,27];26 identifier [] os;27 identifier [] path;28 identifier [] join;29 argument_list [30,31];30 identifier [] dir;31 identifier [] name;32 if_statement [33,41];33 call [34,39];34 attribute [35,38];35 attribute [36,37];36 identifier [] os;37 identifier [] path;38 identifier [] exists;39 argument_list [40];40 identifier [] binpath;41 block [42];42 return_statement [43];43 call [44,49];44 attribute [45,48];45 attribute [46,47];46 identifier [] os;47 identifier [] path;48 identifier [] abspath;49 argument_list [50];50 identifier [] binpath;51 return_statement [52];52 None [] | Find a file in a search path |
0 module [1];1 function_definition [2,3,5];2 function_name [] convert_unicode;3 parameters [4];4 identifier [] text;5 block [6,49];6 if_statement [7,8,24];7 identifier [] isPython2;8 block [9,15];9 expression_statement [10];10 assignment [11,12];11 identifier [] h;12 call [13,14];13 identifier [] HTMLParser;14 argument_list [];15 expression_statement [16];16 assignment [17,18];17 identifier [] s;18 call [19,22];19 attribute [20,21];20 identifier [] h;21 identifier [] unescape;22 argument_list [23];23 identifier [] text;24 else_clause [25];25 block [26];26 try_statement [27,35];27 block [28];28 expression_statement [29];29 assignment [30,31];30 identifier [] s;31 call [32,33];32 identifier [] unescape;33 argument_list [34];34 identifier [] text;35 except_clause [36,37];36 identifier [] Exception;37 block [38];38 expression_statement [39];39 assignment [40,41];40 identifier [] s;41 call [42,47];42 attribute [43,46];43 call [44,45];44 identifier [] HTMLParser;45 argument_list [];46 identifier [] unescape;47 argument_list [48];48 identifier [] text;49 return_statement [50];50 identifier [] s | converts unicode HTML to real Unicode |
0 module [1];1 function_definition [2,3,5];2 function_name [] _is_physical_entity;3 parameters [4];4 identifier [] pe;5 block [6,27];6 expression_statement [7];7 assignment [8,9];8 identifier [] val;9 boolean_operator [10,18,19] or;10 call [11,12];11 identifier [] isinstance;12 argument_list [13,14];13 identifier [] pe;14 call [15,16];15 identifier [] _bp;16 argument_list [17];17 string [] PhysicalEntity;18 line_continuation [] \;19 call [20,21];20 identifier [] isinstance;21 argument_list [22,23];22 identifier [] pe;23 call [24,25];24 identifier [] _bpimpl;25 argument_list [26];26 string [] PhysicalEntity;27 return_statement [28];28 identifier [] val | Return True if the element is a physical entity |
0 module [1];1 function_definition [2,3,6];2 function_name [] rotate_in_plane;3 parameters [4,5];4 identifier [] chi;5 identifier [] phase;6 block [7,13,22,31,37,53,69];7 expression_statement [8];8 assignment [9,10];9 identifier [] v;10 attribute [11,12];11 identifier [] chi;12 identifier [] T;13 expression_statement [14];14 assignment [15,16];15 identifier [] sp;16 call [17,20];17 attribute [18,19];18 identifier [] np;19 identifier [] sin;20 argument_list [21];21 identifier [] phase;22 expression_statement [23];23 assignment [24,25];24 identifier [] cp;25 call [26,29];26 attribute [27,28];27 identifier [] np;28 identifier [] cos;29 argument_list [30];30 identifier [] phase;31 expression_statement [32];32 assignment [33,34];33 identifier [] res;34 binary_operator [35,36] *;35 float [] 1.;36 identifier [] v;37 expression_statement [38];38 assignment [39,42];39 subscript [40,41];40 identifier [] res;41 integer [] 0;42 binary_operator [43,48] +;43 binary_operator [44,47] *;44 subscript [45,46];45 identifier [] v;46 integer [] 0;47 identifier [] cp;48 binary_operator [49,52] *;49 subscript [50,51];50 identifier [] v;51 integer [] 1;52 identifier [] sp;53 expression_statement [54];54 assignment [55,58];55 subscript [56,57];56 identifier [] res;57 integer [] 1;58 binary_operator [59,64] -;59 binary_operator [60,63] *;60 subscript [61,62];61 identifier [] v;62 integer [] 1;63 identifier [] cp;64 binary_operator [65,68] *;65 subscript [66,67];66 identifier [] v;67 integer [] 0;68 identifier [] sp;69 return_statement [70];70 attribute [71,72];71 identifier [] res;72 identifier [] T | For transforming spins between the coprecessing and coorbital frames |
0 module [1];1 function_definition [2,3,9];2 function_name [] _process_cell;3 parameters [4,5,6];4 identifier [] i;5 identifier [] state;6 default_parameter [7,8];7 identifier [] finite;8 False [];9 block [10,18,24,59,63,84];10 expression_statement [11];11 assignment [12,13];12 identifier [] op_1;13 subscript [14,15];14 identifier [] state;15 binary_operator [16,17] -;16 identifier [] i;17 integer [] 1;18 expression_statement [19];19 assignment [20,21];20 identifier [] op_2;21 subscript [22,23];22 identifier [] state;23 identifier [] i;24 if_statement [25,33,49];25 comparison_operator [26,27] ==;26 identifier [] i;27 binary_operator [28,32] -;28 call [29,30];29 identifier [] len;30 argument_list [31];31 identifier [] state;32 integer [] 1;33 block [34];34 if_statement [35,36,43];35 identifier [] finite;36 block [37];37 expression_statement [38];38 assignment [39,40];39 identifier [] op_3;40 subscript [41,42];41 identifier [] state;42 integer [] 0;43 else_clause [44];44 block [45];45 expression_statement [46];46 assignment [47,48];47 identifier [] op_3;48 integer [] 0;49 else_clause [50];50 block [51];51 expression_statement [52];52 assignment [53,54];53 identifier [] op_3;54 subscript [55,56];55 identifier [] state;56 binary_operator [57,58] +;57 identifier [] i;58 integer [] 1;59 expression_statement [60];60 assignment [61,62];61 identifier [] result;62 integer [] 0;63 for_statement [64,67,74];64 pattern_list [65,66];65 identifier [] i;66 identifier [] val;67 call [68,69];68 identifier [] enumerate;69 argument_list [70];70 list [71,72,73] [op_3, op_2, op_1];71 identifier [] op_3;72 identifier [] op_2;73 identifier [] op_1;74 block [75];75 if_statement [76,77];76 identifier [] val;77 block [78];78 expression_statement [79];79 augmented_assignment [80,81] +=;80 identifier [] result;81 binary_operator [82,83] **;82 integer [] 2;83 identifier [] i;84 return_statement [85];85 identifier [] result | Process 3 cells and return a value from 0 to 7. |
0 module [1];1 function_definition [2,3,5];2 function_name [] transform_streams_for_comparison;3 parameters [4];4 identifier [] outputs;5 block [6,10,48];6 expression_statement [7];7 assignment [8,9];8 identifier [] new_outputs;9 list [] [];10 for_statement [11,12,13];11 identifier [] output;12 identifier [] outputs;13 block [14];14 if_statement [15,21,39];15 () [16];16 comparison_operator [17,20] ==;17 attribute [18,19];18 identifier [] output;19 identifier [] output_type;20 string [] stream;21 block [22];22 expression_statement [23];23 call [24,27];24 attribute [25,26];25 identifier [] new_outputs;26 identifier [] append;27 argument_list [28];28 dictionary [29,32];29 pair [30,31];30 string [] output_type;31 string [] stream;32 pair [33,36];33 attribute [34,35];34 identifier [] output;35 identifier [] name;36 attribute [37,38];37 identifier [] output;38 identifier [] text;39 else_clause [40];40 block [41];41 expression_statement [42];42 call [43,46];43 attribute [44,45];44 identifier [] new_outputs;45 identifier [] append;46 argument_list [47];47 identifier [] output;48 return_statement [49];49 identifier [] new_outputs | Makes failure output for streams better by having key be the stream name |
0 module [1];1 function_definition [2,3,9];2 function_name [] sinterstore;3 parameters [4,5,6,7];4 identifier [] self;5 identifier [] destkey;6 identifier [] key;7 list_splat_pattern [8];8 identifier [] keys;9 block [10];10 return_statement [11];11 call [12,15];12 attribute [13,14];13 identifier [] self;14 identifier [] execute;15 argument_list [16,17,18,19];16 string [] b'SINTERSTORE';17 identifier [] destkey;18 identifier [] key;19 list_splat [20];20 identifier [] keys | Intersect multiple sets and store the resulting set in a key. |
0 module [1];1 function_definition [2,3,5];2 function_name [] parse_arglist;3 parameters [4];4 identifier [] args;5 block [6,15,24,34,49,70,91,110,129];6 expression_statement [7];7 assignment [8,9];8 identifier [] args;9 call [10,13];10 attribute [11,12];11 string [] f({});12 identifier [] format;13 argument_list [14];14 identifier [] args;15 expression_statement [16];16 assignment [17,18];17 identifier [] tree;18 call [19,22];19 attribute [20,21];20 identifier [] ast;21 identifier [] parse;22 argument_list [23];23 identifier [] args;24 expression_statement [25];25 assignment [26,27];26 identifier [] funccall;27 attribute [28,33];28 subscript [29,32];29 attribute [30,31];30 identifier [] tree;31 identifier [] body;32 integer [] 0;33 identifier [] value;34 expression_statement [35];35 assignment [36,37];36 identifier [] args;37 list_comprehension [38,44];38 call [39,42];39 attribute [40,41];40 identifier [] ast;41 identifier [] literal_eval;42 argument_list [43];43 identifier [] arg;44 for_in_clause [45,46];45 identifier [] arg;46 attribute [47,48];47 identifier [] funccall;48 identifier [] args;49 expression_statement [50];50 assignment [51,52];51 identifier [] kwargs;52 dictionary_comprehension [53,65];53 pair [54,57];54 attribute [55,56];55 identifier [] arg;56 identifier [] arg;57 call [58,61];58 attribute [59,60];59 identifier [] ast;60 identifier [] literal_eval;61 argument_list [62];62 attribute [63,64];63 identifier [] arg;64 identifier [] value;65 for_in_clause [66,67];66 identifier [] arg;67 attribute [68,69];68 identifier [] funccall;69 identifier [] keywords;70 if_statement [71,77];71 comparison_operator [72,76] >;72 call [73,74];73 identifier [] len;74 argument_list [75];75 identifier [] args;76 integer [] 2;77 block [78];78 raise_statement [79];79 call [80,81];80 identifier [] TypeError;81 argument_list [82];82 call [83,86];83 attribute [84,85];84 string [] Expected at most 2 positional args but {} were given;85 identifier [] format;86 argument_list [87];87 call [88,89];88 identifier [] len;89 argument_list [90];90 identifier [] args;91 if_statement [92,98];92 comparison_operator [93,97] >=;93 call [94,95];94 identifier [] len;95 argument_list [96];96 identifier [] args;97 integer [] 1;98 block [99];99 expression_statement [100];100 assignment [101,104];101 subscript [102,103];102 identifier [] kwargs;103 string [] width;104 call [105,106];105 identifier [] int;106 argument_list [107];107 subscript [108,109];108 identifier [] args;109 integer [] 0;110 if_statement [111,117];111 comparison_operator [112,116] >=;112 call [113,114];113 identifier [] len;114 argument_list [115];115 identifier [] args;116 integer [] 2;117 block [118];118 expression_statement [119];119 assignment [120,123];120 subscript [121,122];121 identifier [] kwargs;122 string [] height;123 call [124,125];124 identifier [] int;125 argument_list [126];126 subscript [127,128];127 identifier [] args;128 integer [] 1;129 return_statement [130];130 identifier [] kwargs | Parses an arglist into arguments for Image, as a kwargs dict |
0 module [1];1 function_definition [2,3,6];2 function_name [] to_string;3 parameters [4,5];4 identifier [] self;5 identifier [] value;6 block [7,13,38];7 expression_statement [8];8 call [9,12];9 attribute [10,11];10 identifier [] self;11 identifier [] _warn_deprecated_outside_JSONField;12 argument_list [];13 expression_statement [14];14 assignment [15,16];15 identifier [] value;16 call [17,20];17 attribute [18,19];18 identifier [] json;19 identifier [] dumps;20 argument_list [21,27,30,33];21 call [22,25];22 attribute [23,24];23 identifier [] self;24 identifier [] to_json;25 argument_list [26];26 identifier [] value;27 keyword_argument [28,29];28 identifier [] indent;29 integer [] 2;30 keyword_argument [31,32];31 identifier [] sort_keys;32 True [];33 keyword_argument [34,35];34 identifier [] separators;35 tuple [36,37];36 string [] ,;37 string [] :;38 return_statement [39];39 identifier [] value | Return a JSON serialized string representation of the value. |
0 module [1];1 function_definition [2,3,5];2 function_name [] query_all;3 parameters [4];4 identifier [] self;5 block [6];6 return_statement [7];7 call [8,11];8 attribute [9,10];9 identifier [] self;10 identifier [] query_model;11 argument_list [12,15,18,23,28];12 attribute [13,14];13 identifier [] self;14 identifier [] model;15 attribute [16,17];16 identifier [] self;17 identifier [] condition;18 keyword_argument [19,20];19 identifier [] order_by;20 attribute [21,22];21 identifier [] self;22 identifier [] order_by;23 keyword_argument [24,25];24 identifier [] group_by;25 attribute [26,27];26 identifier [] self;27 identifier [] group_by;28 keyword_argument [29,30];29 identifier [] having;30 attribute [31,32];31 identifier [] self;32 identifier [] having | Query all records without limit and offset. |
0 module [1];1 function_definition [2,3,11];2 function_name [] sub;3 parameters [4,5,6,7,9];4 identifier [] pattern;5 identifier [] repl;6 identifier [] string;7 list_splat_pattern [8];8 identifier [] args;9 dictionary_splat_pattern [10];10 identifier [] kwargs;11 block [12,32,39,49,61,69];12 expression_statement [13];13 assignment [14,15];14 identifier [] flags;15 conditional_expression [16,19,25] if;16 subscript [17,18];17 identifier [] args;18 integer [] 4;19 comparison_operator [20,24] >;20 call [21,22];21 identifier [] len;22 argument_list [23];23 identifier [] args;24 integer [] 4;25 call [26,29];26 attribute [27,28];27 identifier [] kwargs;28 identifier [] get;29 argument_list [30,31];30 string [] flags;31 integer [] 0;32 expression_statement [33];33 assignment [34,35];34 identifier [] is_replace;35 call [36,37];36 identifier [] _is_replace;37 argument_list [38];38 identifier [] repl;39 expression_statement [40];40 assignment [41,42];41 identifier [] is_string;42 call [43,44];43 identifier [] isinstance;44 argument_list [45,46];45 identifier [] repl;46 tuple [47,48];47 identifier [] str;48 identifier [] bytes;49 if_statement [50,55];50 boolean_operator [51,52] and;51 identifier [] is_replace;52 attribute [53,54];53 identifier [] repl;54 identifier [] use_format;55 block [56];56 raise_statement [57];57 call [58,59];58 identifier [] ValueError;59 argument_list [60];60 string [] Compiled replace cannot be a format object!;61 expression_statement [62];62 assignment [63,64];63 identifier [] pattern;64 call [65,66];65 identifier [] compile_search;66 argument_list [67,68];67 identifier [] pattern;68 identifier [] flags;69 return_statement [70];70 call [71,74];71 attribute [72,73];72 identifier [] _re;73 identifier [] sub;74 argument_list [75,76,87,88,90];75 identifier [] pattern;76 () [77];77 conditional_expression [78,83,86] if;78 call [79,80];79 identifier [] compile_replace;80 argument_list [81,82];81 identifier [] pattern;82 identifier [] repl;83 boolean_operator [84,85] or;84 identifier [] is_replace;85 identifier [] is_string;86 identifier [] repl;87 identifier [] string;88 list_splat [89];89 identifier [] args;90 dictionary_splat [91];91 identifier [] kwargs | Apply `sub` after applying backrefs. |
0 module [1];1 function_definition [2,3,4];2 function_name [] standardize;3 parameters [];4 block [5,22];5 function_definition [6,7,10];6 function_name [] f;7 parameters [8,9];8 identifier [] G;9 identifier [] bim;10 block [11,18];11 expression_statement [12];12 assignment [13,14];13 identifier [] G_out;14 call [15,16];15 identifier [] standardize_snps;16 argument_list [17];17 identifier [] G;18 return_statement [19];19 expression_list [20,21];20 identifier [] G_out;21 identifier [] bim;22 return_statement [23];23 identifier [] f | return variant standarize function |
0 module [1];1 function_definition [2,3,5];2 function_name [] computeRange;3 parameters [4];4 identifier [] corners;5 block [6,14,22,42,62];6 expression_statement [7];7 assignment [8,9];8 identifier [] x;9 subscript [10,11,13];10 identifier [] corners;11 slice [12];12 colon [];13 integer [] 0;14 expression_statement [15];15 assignment [16,17];16 identifier [] y;17 subscript [18,19,21];18 identifier [] corners;19 slice [20];20 colon [];21 integer [] 1;22 expression_statement [23];23 assignment [24,25];24 identifier [] _xrange;25 tuple [26,34];26 call [27,32];27 attribute [28,31];28 attribute [29,30];29 identifier [] np;30 identifier [] minimum;31 identifier [] reduce;32 argument_list [33];33 identifier [] x;34 call [35,40];35 attribute [36,39];36 attribute [37,38];37 identifier [] np;38 identifier [] maximum;39 identifier [] reduce;40 argument_list [41];41 identifier [] x;42 expression_statement [43];43 assignment [44,45];44 identifier [] _yrange;45 tuple [46,54];46 call [47,52];47 attribute [48,51];48 attribute [49,50];49 identifier [] np;50 identifier [] minimum;51 identifier [] reduce;52 argument_list [53];53 identifier [] y;54 call [55,60];55 attribute [56,59];56 attribute [57,58];57 identifier [] np;58 identifier [] maximum;59 identifier [] reduce;60 argument_list [61];61 identifier [] y;62 return_statement [63];63 expression_list [64,65];64 identifier [] _xrange;65 identifier [] _yrange | Determine the range spanned by an array of pixel positions. |
0 module [1];1 function_definition [2,3,6];2 function_name [] image_get;3 parameters [4,5];4 identifier [] request;5 identifier [] image_id;6 block [7,21];7 expression_statement [8];8 assignment [9,10];9 identifier [] image;10 call [11,19];11 attribute [12,18];12 attribute [13,17];13 call [14,15];14 identifier [] glanceclient;15 argument_list [16];16 identifier [] request;17 identifier [] images;18 identifier [] get;19 argument_list [20];20 identifier [] image_id;21 return_statement [22];22 call [23,24];23 identifier [] Image;24 argument_list [25];25 identifier [] image | Returns an Image object populated with metadata for a given image. |
0 module [1];1 function_definition [2,3,9];2 function_name [] _process_score;3 parameters [4,5,6];4 identifier [] self;5 identifier [] model_name;6 default_parameter [7,8];7 identifier [] dependency_cache;8 None [];9 block [10,18,26,36,63,71,82,109];10 expression_statement [11];11 assignment [12,13];12 identifier [] version;13 attribute [14,17];14 subscript [15,16];15 identifier [] self;16 identifier [] model_name;17 identifier [] version;18 expression_statement [19];19 assignment [20,21];20 identifier [] start;21 call [22,25];22 attribute [23,24];23 identifier [] time;24 identifier [] time;25 argument_list [];26 expression_statement [27];27 assignment [28,29];28 identifier [] feature_values;29 call [30,33];30 attribute [31,32];31 identifier [] self;32 identifier [] _solve_features;33 argument_list [34,35];34 identifier [] model_name;35 identifier [] dependency_cache;36 expression_statement [37];37 call [38,41];38 attribute [39,40];39 identifier [] logger;40 identifier [] debug;41 argument_list [42];42 call [43,46];43 attribute [44,45];44 string [] Extracted features for {0}:{1}:{2} in {3} secs;45 identifier [] format;46 argument_list [47,50,51,52];47 attribute [48,49];48 identifier [] self;49 identifier [] name;50 identifier [] model_name;51 identifier [] version;52 call [53,54];53 identifier [] round;54 argument_list [55,62];55 binary_operator [56,61] -;56 call [57,60];57 attribute [58,59];58 identifier [] time;59 identifier [] time;60 argument_list [];61 identifier [] start;62 integer [] 3;63 expression_statement [64];64 assignment [65,66];65 identifier [] start;66 call [67,70];67 attribute [68,69];68 identifier [] time;69 identifier [] time;70 argument_list [];71 expression_statement [72];72 assignment [73,74];73 identifier [] score;74 call [75,80];75 attribute [76,79];76 subscript [77,78];77 identifier [] self;78 identifier [] model_name;79 identifier [] score;80 argument_list [81];81 identifier [] feature_values;82 expression_statement [83];83 call [84,87];84 attribute [85,86];85 identifier [] logger;86 identifier [] debug;87 argument_list [88];88 call [89,92];89 attribute [90,91];90 string [] Scored features for {0}:{1}:{2} in {3} secs;91 identifier [] format;92 argument_list [93,96,97,98];93 attribute [94,95];94 identifier [] self;95 identifier [] name;96 identifier [] model_name;97 identifier [] version;98 call [99,100];99 identifier [] round;100 argument_list [101,108];101 binary_operator [102,107] -;102 call [103,106];103 attribute [104,105];104 identifier [] time;105 identifier [] time;106 argument_list [];107 identifier [] start;108 integer [] 3;109 return_statement [110];110 identifier [] score | Generates a score for a given model using the `dependency_cache`. |
0 module [1];1 function_definition [2,3,6];2 function_name [] from_json_file;3 parameters [4,5];4 identifier [] cls;5 identifier [] json_file;6 block [7,30];7 with_statement [8,21];8 with_clause [9];9 with_item [10];10 as_pattern [11,19];11 call [12,13];12 identifier [] open;13 argument_list [14,15,16];14 identifier [] json_file;15 string [] r;16 keyword_argument [17,18];17 identifier [] encoding;18 string [] utf-8;19 as_pattern_target [20];20 identifier [] reader;21 block [22];22 expression_statement [23];23 assignment [24,25];24 identifier [] text;25 call [26,29];26 attribute [27,28];27 identifier [] reader;28 identifier [] read;29 argument_list [];30 return_statement [31];31 call [32,35];32 attribute [33,34];33 identifier [] cls;34 identifier [] from_dict;35 argument_list [36];36 call [37,40];37 attribute [38,39];38 identifier [] json;39 identifier [] loads;40 argument_list [41];41 identifier [] text | Constructs a `GPT2Config` from a json file of parameters. |
0 module [1];1 function_definition [2,3,6];2 function_name [] addSquigglyAnnot;3 parameters [4,5];4 identifier [] self;5 identifier [] rect;6 block [7,12,22,27,33,44,55];7 expression_statement [8];8 call [9,10];9 identifier [] CheckParent;10 argument_list [11];11 identifier [] self;12 expression_statement [13];13 assignment [14,15];14 identifier [] val;15 call [16,19];16 attribute [17,18];17 identifier [] _fitz;18 identifier [] Page_addSquigglyAnnot;19 argument_list [20,21];20 identifier [] self;21 identifier [] rect;22 if_statement [23,25];23 not_operator [24];24 identifier [] val;25 block [26];26 return_statement [];27 expression_statement [28];28 assignment [29,32];29 attribute [30,31];30 identifier [] val;31 identifier [] thisown;32 True [];33 expression_statement [34];34 assignment [35,38];35 attribute [36,37];36 identifier [] val;37 identifier [] parent;38 call [39,42];39 attribute [40,41];40 identifier [] weakref;41 identifier [] proxy;42 argument_list [43];43 identifier [] self;44 expression_statement [45];45 assignment [46,54];46 subscript [47,50];47 attribute [48,49];48 identifier [] self;49 identifier [] _annot_refs;50 call [51,52];51 identifier [] id;52 argument_list [53];53 identifier [] val;54 identifier [] val;55 return_statement [56];56 identifier [] val | Wavy underline content in a rectangle or quadrilateral. |
0 module [1];1 function_definition [2,3,4];2 function_name [] img2img_transformer2d_base;3 parameters [];4 block [5,11,17,23,29,35,41,47,53,59,69,79,85];5 expression_statement [6];6 assignment [7,8];7 identifier [] hparams;8 call [9,10];9 identifier [] image_transformer2d_base;10 argument_list [];11 expression_statement [12];12 assignment [13,16];13 attribute [14,15];14 identifier [] hparams;15 identifier [] layer_preprocess_sequence;16 string [] n;17 expression_statement [18];18 assignment [19,22];19 attribute [20,21];20 identifier [] hparams;21 identifier [] layer_postprocess_sequence;22 string [] da;23 expression_statement [24];24 assignment [25,28];25 attribute [26,27];26 identifier [] hparams;27 identifier [] learning_rate;28 float [] 0.2;29 expression_statement [30];30 assignment [31,34];31 attribute [32,33];32 identifier [] hparams;33 identifier [] layer_prepostprocess_dropout;34 float [] 0.1;35 expression_statement [36];36 assignment [37,40];37 attribute [38,39];38 identifier [] hparams;39 identifier [] learning_rate_warmup_steps;40 integer [] 12000;41 expression_statement [42];42 assignment [43,46];43 attribute [44,45];44 identifier [] hparams;45 identifier [] filter_size;46 integer [] 2048;47 expression_statement [48];48 assignment [49,52];49 attribute [50,51];50 identifier [] hparams;51 identifier [] num_encoder_layers;52 integer [] 4;53 expression_statement [54];54 assignment [55,58];55 attribute [56,57];56 identifier [] hparams;57 identifier [] num_decoder_layers;58 integer [] 8;59 expression_statement [60];60 assignment [61,66];61 subscript [62,65];62 attribute [63,64];63 identifier [] hparams;64 identifier [] bottom;65 string [] inputs;66 attribute [67,68];67 identifier [] modalities;68 identifier [] image_channel_embeddings_bottom;69 expression_statement [70];70 assignment [71,74];71 attribute [72,73];72 identifier [] hparams;73 identifier [] dec_attention_type;74 attribute [75,78];75 attribute [76,77];76 identifier [] cia;77 identifier [] AttentionType;78 identifier [] LOCAL_2D;79 expression_statement [80];80 assignment [81,84];81 attribute [82,83];82 identifier [] hparams;83 identifier [] block_raster_scan;84 True [];85 return_statement [86];86 identifier [] hparams | Base params for img2img 2d attention. |
0 module [1];1 function_definition [2,3,6];2 function_name [] interp;3 parameters [4,5];4 identifier [] net;5 identifier [] layers;6 block [7];7 for_statement [8,9,10];8 identifier [] l;9 identifier [] layers;10 block [11,29,41,49,56];11 expression_statement [12];12 assignment [13,18];13 pattern_list [14,15,16,17];14 identifier [] m;15 identifier [] k;16 identifier [] h;17 identifier [] w;18 attribute [19,28];19 attribute [20,27];20 subscript [21,26];21 subscript [22,25];22 attribute [23,24];23 identifier [] net;24 identifier [] params;25 identifier [] l;26 integer [] 0;27 identifier [] data;28 identifier [] shape;29 if_statement [30,37];30 boolean_operator [31,34] and;31 comparison_operator [32,33] !=;32 identifier [] m;33 identifier [] k;34 comparison_operator [35,36] !=;35 identifier [] k;36 integer [] 1;37 block [38,40];38 print_statement [39];39 string [] input + output channels need to be the same or |output| == 1;40 raise_statement [];41 if_statement [42,45];42 comparison_operator [43,44] !=;43 identifier [] h;44 identifier [] w;45 block [46,48];46 print_statement [47];47 string [] filters need to be square;48 raise_statement [];49 expression_statement [50];50 assignment [51,52];51 identifier [] filt;52 call [53,54];53 identifier [] upsample_filt;54 argument_list [55];55 identifier [] h;56 expression_statement [57];57 assignment [58,80];58 subscript [59,68,72,76,78];59 attribute [60,67];60 subscript [61,66];61 subscript [62,65];62 attribute [63,64];63 identifier [] net;64 identifier [] params;65 identifier [] l;66 integer [] 0;67 identifier [] data;68 call [69,70];69 identifier [] range;70 argument_list [71];71 identifier [] m;72 call [73,74];73 identifier [] range;74 argument_list [75];75 identifier [] k;76 slice [77];77 colon [];78 slice [79];79 colon [];80 identifier [] filt | Set weights of each layer in layers to bilinear kernels for interpolation. |
0 module [1];1 function_definition [2,3,8];2 function_name [] create;3 parameters [4,5];4 identifier [] self;5 default_parameter [6,7];6 identifier [] ignore;7 None [];8 block [9,15,125];9 expression_statement [10];10 assignment [11,12];11 identifier [] ignore;12 boolean_operator [13,14] or;13 identifier [] ignore;14 list [] [];15 function_definition [16,17,22];16 function_name [] _create;17 parameters [18,19];18 identifier [] tree_or_filename;19 default_parameter [20,21];20 identifier [] alias;21 None [];22 block [23,94];23 for_statement [24,27,32];24 pattern_list [25,26];25 identifier [] name;26 identifier [] value;27 call [28,31];28 attribute [29,30];29 identifier [] tree_or_filename;30 identifier [] items;31 argument_list [];32 block [33];33 if_statement [34,39,53];34 call [35,36];35 identifier [] isinstance;36 argument_list [37,38];37 identifier [] value;38 identifier [] dict;39 block [40];40 for_statement [41,42,49];41 identifier [] result;42 call [43,44];43 identifier [] _create;44 argument_list [45,46];45 identifier [] value;46 keyword_argument [47,48];47 identifier [] alias;48 identifier [] name;49 block [50];50 expression_statement [51];51 yield [52];52 identifier [] result;53 else_clause [54];54 block [55];55 with_statement [56,66];56 with_clause [57];57 with_item [58];58 as_pattern [59,64];59 call [60,61];60 identifier [] open;61 argument_list [62,63];62 identifier [] value;63 string [] r;64 as_pattern_target [65];65 identifier [] body;66 block [67];67 expression_statement [68];68 yield [69];69 expression_list [70,71];70 identifier [] name;71 call [72,79];72 attribute [73,78];73 attribute [74,77];74 attribute [75,76];75 identifier [] self;76 identifier [] client;77 identifier [] indices;78 identifier [] create;79 argument_list [80,83,91];80 keyword_argument [81,82];81 identifier [] index;82 identifier [] name;83 keyword_argument [84,85];84 identifier [] body;85 call [86,89];86 attribute [87,88];87 identifier [] json;88 identifier [] load;89 argument_list [90];90 identifier [] body;91 keyword_argument [92,93];92 identifier [] ignore;93 identifier [] ignore;94 if_statement [95,96];95 identifier [] alias;96 block [97];97 expression_statement [98];98 yield [99];99 expression_list [100,101];100 identifier [] alias;101 call [102,109];102 attribute [103,108];103 attribute [104,107];104 attribute [105,106];105 identifier [] self;106 identifier [] client;107 identifier [] indices;108 identifier [] put_alias;109 argument_list [110,119,122];110 keyword_argument [111,112];111 identifier [] index;112 call [113,114];113 identifier [] list;114 argument_list [115];115 call [116,117];116 identifier [] _get_indices;117 argument_list [118];118 identifier [] tree_or_filename;119 keyword_argument [120,121];120 identifier [] name;121 identifier [] alias;122 keyword_argument [123,124];123 identifier [] ignore;124 identifier [] ignore;125 for_statement [126,127,133];126 identifier [] result;127 call [128,129];128 identifier [] _create;129 argument_list [130];130 attribute [131,132];131 identifier [] self;132 identifier [] active_aliases;133 block [134];134 expression_statement [135];135 yield [136];136 identifier [] result | Yield tuple with created index name and responses from a client. |
0 module [1];1 function_definition [2,3,27];2 function_name [] patch;3 parameters [4,7,10,15,18,21,24];4 default_parameter [5,6];5 identifier [] callback;6 None [];7 default_parameter [8,9];8 identifier [] path;9 None [];10 default_parameter [11,12];11 identifier [] method;12 attribute [13,14];13 identifier [] Method;14 identifier [] PATCH;15 default_parameter [16,17];16 identifier [] resource;17 None [];18 default_parameter [19,20];19 identifier [] tags;20 None [];21 default_parameter [22,23];22 identifier [] summary;23 string [] Patch specified resource.;24 default_parameter [25,26];25 identifier [] middleware;26 None [];27 block [28,106];28 function_definition [29,30,32];29 function_name [] inner;30 parameters [31];31 identifier [] c;32 block [33,57,72,88,104];33 expression_statement [34];34 assignment [35,36];35 identifier [] op;36 call [37,38];37 identifier [] ResourceOperation;38 argument_list [39,40,46,47,48,49,50,51,54];39 identifier [] c;40 boolean_operator [41,42] or;41 identifier [] path;42 call [43,44];43 identifier [] PathParam;44 argument_list [45];45 string [] {key_field};46 identifier [] method;47 identifier [] resource;48 identifier [] tags;49 identifier [] summary;50 identifier [] middleware;51 keyword_argument [52,53];52 identifier [] full_clean;53 False [];54 keyword_argument [55,56];55 identifier [] default_to_not_supplied;56 True [];57 expression_statement [58];58 call [59,64];59 attribute [60,63];60 attribute [61,62];61 identifier [] op;62 identifier [] responses;63 identifier [] add;64 argument_list [65];65 call [66,67];66 identifier [] Response;67 argument_list [68,71];68 attribute [69,70];69 identifier [] HTTPStatus;70 identifier [] OK;71 string [] {name} has been patched.;72 expression_statement [73];73 call [74,79];74 attribute [75,78];75 attribute [76,77];76 identifier [] op;77 identifier [] responses;78 identifier [] add;79 argument_list [80];80 call [81,82];81 identifier [] Response;82 argument_list [83,86,87];83 attribute [84,85];84 identifier [] HTTPStatus;85 identifier [] BAD_REQUEST;86 string [] Validation failed.;87 identifier [] Error;88 expression_statement [89];89 call [90,95];90 attribute [91,94];91 attribute [92,93];92 identifier [] op;93 identifier [] responses;94 identifier [] add;95 argument_list [96];96 call [97,98];97 identifier [] Response;98 argument_list [99,102,103];99 attribute [100,101];100 identifier [] HTTPStatus;101 identifier [] NOT_FOUND;102 string [] Not found;103 identifier [] Error;104 return_statement [105];105 identifier [] op;106 return_statement [107];107 conditional_expression [108,112,113] if;108 call [109,110];109 identifier [] inner;110 argument_list [111];111 identifier [] callback;112 identifier [] callback;113 identifier [] inner | Decorator to configure an operation that patches a resource. |
0 module [1];1 function_definition [2,3,5];2 function_name [] data;3 parameters [4];4 identifier [] self;5 block [6,10,20,32,120];6 expression_statement [7];7 assignment [8,9];8 identifier [] means;9 list [] [];10 expression_statement [11];11 assignment [12,13];12 identifier [] table;13 call [14,19];14 attribute [15,18];15 attribute [16,17];16 identifier [] self;17 identifier [] _slice;18 identifier [] as_array;19 argument_list [];20 expression_statement [21];21 assignment [22,23];22 identifier [] products;23 call [24,27];24 attribute [25,26];25 identifier [] self;26 identifier [] _inner_prods;27 argument_list [28,29];28 identifier [] table;29 attribute [30,31];30 identifier [] self;31 identifier [] values;32 for_statement [33,36,40];33 pattern_list [34,35];34 identifier [] axis;35 identifier [] product;36 call [37,38];37 identifier [] enumerate;38 argument_list [39];39 identifier [] products;40 block [41,54,63,75,87,93,113];41 if_statement [42,45];42 comparison_operator [43,44] is;43 identifier [] product;44 None [];45 block [46,53];46 expression_statement [47];47 call [48,51];48 attribute [49,50];49 identifier [] means;50 identifier [] append;51 argument_list [52];52 identifier [] product;53 continue_statement [];54 expression_statement [55];55 assignment [56,57];56 identifier [] valid_indices;57 call [58,61];58 attribute [59,60];59 identifier [] self;60 identifier [] _valid_indices;61 argument_list [62];62 identifier [] axis;63 expression_statement [64];64 assignment [65,66];65 identifier [] num;66 call [67,70];67 attribute [68,69];68 identifier [] np;69 identifier [] sum;70 argument_list [71,74];71 subscript [72,73];72 identifier [] product;73 identifier [] valid_indices;74 identifier [] axis;75 expression_statement [76];76 assignment [77,78];77 identifier [] den;78 call [79,82];79 attribute [80,81];80 identifier [] np;81 identifier [] sum;82 argument_list [83,86];83 subscript [84,85];84 identifier [] table;85 identifier [] valid_indices;86 identifier [] axis;87 expression_statement [88];88 assignment [89,90];89 identifier [] mean;90 binary_operator [91,92] /;91 identifier [] num;92 identifier [] den;93 if_statement [94,102];94 not_operator [95];95 call [96,97];96 identifier [] isinstance;97 argument_list [98,99];98 identifier [] mean;99 attribute [100,101];100 identifier [] np;101 identifier [] ndarray;102 block [103];103 expression_statement [104];104 assignment [105,106];105 identifier [] mean;106 call [107,110];107 attribute [108,109];108 identifier [] np;109 identifier [] array;110 argument_list [111];111 list [112] [mean];112 identifier [] mean;113 expression_statement [114];114 call [115,118];115 attribute [116,117];116 identifier [] means;117 identifier [] append;118 argument_list [119];119 identifier [] mean;120 return_statement [121];121 identifier [] means | list of mean numeric values of categorical responses. |
0 module [1];1 function_definition [2,3,5,7];2 function_name [] compute_edge_reduction;3 parameters [4];4 identifier [] self;5 type [6];6 identifier [] float;7 block [8,16,24];8 expression_statement [9];9 assignment [10,11];10 identifier [] nb_init_edge;11 call [12,15];12 attribute [13,14];13 identifier [] self;14 identifier [] init_edge_number;15 argument_list [];16 expression_statement [17];17 assignment [18,19];18 identifier [] nb_poweredge;19 call [20,23];20 attribute [21,22];21 identifier [] self;22 identifier [] edge_number;23 argument_list [];24 return_statement [25];25 binary_operator [26,30] /;26 () [27];27 binary_operator [28,29] -;28 identifier [] nb_init_edge;29 identifier [] nb_poweredge;30 () [31];31 identifier [] nb_init_edge | Compute the edge reduction. Costly computation |
0 module [1];1 function_definition [2,3,4];2 function_name [] disable_notebook;3 parameters [];4 block [5,22,28,38];5 try_statement [6,14];6 block [7];7 import_from_statement [8,12];8 dotted_name [9,10,11];9 identifier [] IPython;10 identifier [] core;11 identifier [] getipython;12 dotted_name [13];13 identifier [] get_ipython;14 except_clause [15,16];15 identifier [] ImportError;16 block [17];17 raise_statement [18];18 call [19,20];19 identifier [] ImportError;20 argument_list [21];21 string [] This feature requires IPython 1.0+;22 expression_statement [23];23 assignment [24,25];24 identifier [] ip;25 call [26,27];26 identifier [] get_ipython;27 argument_list [];28 expression_statement [29];29 assignment [30,31];30 identifier [] f;31 subscript [32,37];32 attribute [33,36];33 attribute [34,35];34 identifier [] ip;35 identifier [] display_formatter;36 identifier [] formatters;37 string [] text/html;38 expression_statement [39];39 call [40,45];40 attribute [41,44];41 attribute [42,43];42 identifier [] f;43 identifier [] type_printers;44 identifier [] pop;45 argument_list [46,49];46 attribute [47,48];47 identifier [] np;48 identifier [] ndarray;49 None [] | Disable automatic visualization of NumPy arrays in the IPython Notebook. |
0 module [1];1 function_definition [2,3,5];2 function_name [] gen_lazy_function;3 parameters [4];4 identifier [] self;5 block [6,49,53,62,68,75,107,115,121];6 if_statement [7,12];7 comparison_operator [8,11] is;8 attribute [9,10];9 identifier [] self;10 identifier [] _value;11 None [];12 block [13];13 if_statement [14,19,36];14 comparison_operator [15,18] is not;15 attribute [16,17];16 identifier [] self;17 identifier [] _random;18 None [];19 block [20];20 expression_statement [21];21 assignment [22,25];22 attribute [23,24];23 identifier [] self;24 identifier [] value;25 call [26,29];26 attribute [27,28];27 identifier [] self;28 identifier [] _random;29 argument_list [30];30 dictionary_splat [31];31 attribute [32,35];32 attribute [33,34];33 identifier [] self;34 identifier [] _parents;35 identifier [] value;36 else_clause [37];37 block [38];38 raise_statement [39];39 call [40,41];40 identifier [] ValueError;41 argument_list [42];42 binary_operator [43,48] +;43 binary_operator [44,45] +;44 string [] Stochastic;45 attribute [46,47];46 identifier [] self;47 identifier [] __name__;48 string [] 's value initialized to None; no initial value or random method provided.;49 expression_statement [50];50 assignment [51,52];51 identifier [] arguments;52 dictionary [];53 expression_statement [54];54 call [55,58];55 attribute [56,57];56 identifier [] arguments;57 identifier [] update;58 argument_list [59];59 attribute [60,61];60 identifier [] self;61 identifier [] parents;62 expression_statement [63];63 assignment [64,67];64 subscript [65,66];65 identifier [] arguments;66 string [] value;67 identifier [] self;68 expression_statement [69];69 assignment [70,71];70 identifier [] arguments;71 call [72,73];72 identifier [] DictContainer;73 argument_list [74];74 identifier [] arguments;75 expression_statement [76];76 assignment [77,80];77 attribute [78,79];78 identifier [] self;79 identifier [] _logp;80 call [81,82];81 identifier [] LazyFunction;82 argument_list [83,88,91,102];83 keyword_argument [84,85];84 identifier [] fun;85 attribute [86,87];86 identifier [] self;87 identifier [] _logp_fun;88 keyword_argument [89,90];89 identifier [] arguments;90 identifier [] arguments;91 keyword_argument [92,93];92 identifier [] ultimate_args;93 binary_operator [94,97] |;94 attribute [95,96];95 identifier [] self;96 identifier [] extended_parents;97 call [98,99];98 identifier [] set;99 argument_list [100];100 list [101] [self];101 identifier [] self;102 keyword_argument [103,104];103 identifier [] cache_depth;104 attribute [105,106];105 identifier [] self;106 identifier [] _cache_depth;107 expression_statement [108];108 call [109,114];109 attribute [110,113];110 attribute [111,112];111 identifier [] self;112 identifier [] _logp;113 identifier [] force_compute;114 argument_list [];115 expression_statement [116];116 assignment [117,120];117 attribute [118,119];118 identifier [] self;119 identifier [] _logp_partial_gradients;120 dictionary [];121 for_statement [122,125,133];122 pattern_list [123,124];123 identifier [] parameter;124 identifier [] function;125 call [126,129];126 attribute [127,128];127 identifier [] six;128 identifier [] iteritems;129 argument_list [130];130 attribute [131,132];131 identifier [] self;132 identifier [] _logp_partial_gradient_functions;133 block [134,162];134 expression_statement [135];135 assignment [136,137];136 identifier [] lazy_logp_partial_gradient;137 call [138,139];138 identifier [] LazyFunction;139 argument_list [140,143,146,157];140 keyword_argument [141,142];141 identifier [] fun;142 identifier [] function;143 keyword_argument [144,145];144 identifier [] arguments;145 identifier [] arguments;146 keyword_argument [147,148];147 identifier [] ultimate_args;148 binary_operator [149,152] |;149 attribute [150,151];150 identifier [] self;151 identifier [] extended_parents;152 call [153,154];153 identifier [] set;154 argument_list [155];155 list [156] [self];156 identifier [] self;157 keyword_argument [158,159];158 identifier [] cache_depth;159 attribute [160,161];160 identifier [] self;161 identifier [] _cache_depth;162 expression_statement [163];163 assignment [164,169];164 subscript [165,168];165 attribute [166,167];166 identifier [] self;167 identifier [] _logp_partial_gradients;168 identifier [] parameter;169 identifier [] lazy_logp_partial_gradient | Will be called by Node at instantiation. |
0 module [1];1 function_definition [2,3,10];2 function_name [] time_signature_event;3 parameters [4,5];4 identifier [] self;5 default_parameter [6,7];6 identifier [] meter;7 tuple [8,9];8 integer [] 4;9 integer [] 4;10 block [11,22,40];11 expression_statement [12];12 assignment [13,14];13 identifier [] numer;14 call [15,16];15 identifier [] a2b_hex;16 argument_list [17];17 binary_operator [18,19] %;18 string [] %02x;19 subscript [20,21];20 identifier [] meter;21 integer [] 0;22 expression_statement [23];23 assignment [24,25];24 identifier [] denom;25 call [26,27];26 identifier [] a2b_hex;27 argument_list [28];28 binary_operator [29,30] %;29 string [] %02x;30 call [31,32];31 identifier [] int;32 argument_list [33];33 call [34,35];34 identifier [] log;35 argument_list [36,39];36 subscript [37,38];37 identifier [] meter;38 integer [] 1;39 integer [] 2;40 return_statement [41];41 binary_operator [42,56] +;42 binary_operator [43,54,55] +;43 binary_operator [44,53] +;44 binary_operator [45,52] +;45 binary_operator [46,51] +;46 binary_operator [47,50] +;47 attribute [48,49];48 identifier [] self;49 identifier [] delta_time;50 identifier [] META_EVENT;51 identifier [] TIME_SIGNATURE;52 string [] \x04;53 identifier [] numer;54 line_continuation [] \;55 identifier [] denom;56 string [] \x18\x08 | Return a time signature event for meter. |
0 module [1];1 function_definition [2,3,6];2 function_name [] initialize;3 parameters [4,5];4 identifier [] self;5 identifier [] io_loop;6 block [7,13,31,39,53,82,96];7 expression_statement [8];8 assignment [9,12];9 attribute [10,11];10 identifier [] self;11 identifier [] _loop;12 identifier [] io_loop;13 for_statement [14,15,22];14 identifier [] app_context;15 call [16,21];16 attribute [17,20];17 attribute [18,19];18 identifier [] self;19 identifier [] _applications;20 identifier [] values;21 argument_list [];22 block [23];23 expression_statement [24];24 assignment [25,28];25 attribute [26,27];26 identifier [] app_context;27 identifier [] _loop;28 attribute [29,30];29 identifier [] self;30 identifier [] _loop;31 expression_statement [32];32 assignment [33,36];33 attribute [34,35];34 identifier [] self;35 identifier [] _clients;36 call [37,38];37 identifier [] set;38 argument_list [];39 expression_statement [40];40 assignment [41,44];41 attribute [42,43];42 identifier [] self;43 identifier [] _stats_job;44 call [45,46];45 identifier [] PeriodicCallback;46 argument_list [47,50];47 attribute [48,49];48 identifier [] self;49 identifier [] _log_stats;50 attribute [51,52];51 identifier [] self;52 identifier [] _stats_log_frequency_milliseconds;53 if_statement [54,59,74];54 comparison_operator [55,58] >;55 attribute [56,57];56 identifier [] self;57 identifier [] _mem_log_frequency_milliseconds;58 integer [] 0;59 block [60];60 expression_statement [61];61 assignment [62,65];62 attribute [63,64];63 identifier [] self;64 identifier [] _mem_job;65 call [66,67];66 identifier [] PeriodicCallback;67 argument_list [68,71];68 attribute [69,70];69 identifier [] self;70 identifier [] _log_mem;71 attribute [72,73];72 identifier [] self;73 identifier [] _mem_log_frequency_milliseconds;74 else_clause [75];75 block [76];76 expression_statement [77];77 assignment [78,81];78 attribute [79,80];79 identifier [] self;80 identifier [] _mem_job;81 None [];82 expression_statement [83];83 assignment [84,87];84 attribute [85,86];85 identifier [] self;86 identifier [] _cleanup_job;87 call [88,89];88 identifier [] PeriodicCallback;89 argument_list [90,93];90 attribute [91,92];91 identifier [] self;92 identifier [] _cleanup_sessions;93 attribute [94,95];94 identifier [] self;95 identifier [] _check_unused_sessions_milliseconds;96 if_statement [97,102,117];97 comparison_operator [98,101] >;98 attribute [99,100];99 identifier [] self;100 identifier [] _keep_alive_milliseconds;101 integer [] 0;102 block [103];103 expression_statement [104];104 assignment [105,108];105 attribute [106,107];106 identifier [] self;107 identifier [] _ping_job;108 call [109,110];109 identifier [] PeriodicCallback;110 argument_list [111,114];111 attribute [112,113];112 identifier [] self;113 identifier [] _keep_alive;114 attribute [115,116];115 identifier [] self;116 identifier [] _keep_alive_milliseconds;117 else_clause [118];118 block [119];119 expression_statement [120];120 assignment [121,124];121 attribute [122,123];122 identifier [] self;123 identifier [] _ping_job;124 None [] | Start a Bokeh Server Tornado Application on a given Tornado IOLoop. |
0 module [1];1 function_definition [2,3,5];2 function_name [] parse_eggs_list;3 parameters [4];4 identifier [] path;5 block [6,87];6 with_statement [7,17];7 with_clause [8];8 with_item [9];9 as_pattern [10,15];10 call [11,12];11 identifier [] open;12 argument_list [13,14];13 identifier [] path;14 string [] r;15 as_pattern_target [16];16 identifier [] script;17 block [18,26,30,34,75];18 expression_statement [19];19 assignment [20,21];20 identifier [] data;21 call [22,25];22 attribute [23,24];23 identifier [] script;24 identifier [] readlines;25 argument_list [];26 expression_statement [27];27 assignment [28,29];28 identifier [] start;29 integer [] 0;30 expression_statement [31];31 assignment [32,33];32 identifier [] end;33 integer [] 0;34 for_statement [35,38,42];35 pattern_list [36,37];36 identifier [] counter;37 identifier [] line;38 call [39,40];39 identifier [] enumerate;40 argument_list [41];41 identifier [] data;42 block [43,58];43 if_statement [44,46];44 not_operator [45];45 identifier [] start;46 block [47];47 if_statement [48,51];48 comparison_operator [49,50] in;49 string [] sys.path[0:0];50 identifier [] line;51 block [52];52 expression_statement [53];53 assignment [54,55];54 identifier [] start;55 binary_operator [56,57] +;56 identifier [] counter;57 integer [] 1;58 if_statement [59,65];59 boolean_operator [60,63] and;60 comparison_operator [61,62] >=;61 identifier [] counter;62 identifier [] start;63 not_operator [64];64 identifier [] end;65 block [66];66 if_statement [67,70];67 comparison_operator [68,69] in;68 string [] ];69 identifier [] line;70 block [71];71 expression_statement [72];72 assignment [73,74];73 identifier [] end;74 identifier [] counter;75 expression_statement [76];76 assignment [77,78];77 identifier [] script_eggs;78 call [79,80];79 identifier [] tidy_eggs_list;80 argument_list [81];81 subscript [82,83];82 identifier [] data;83 slice [84,85,86];84 identifier [] start;85 colon [];86 identifier [] end;87 return_statement [88];88 identifier [] script_eggs | Parse eggs list from the script at the given path |
0 module [1];1 function_definition [2,3,7];2 function_name [] modified_lines;3 parameters [4,5,6];4 identifier [] self;5 identifier [] r;6 identifier [] file_name;7 block [8,18,30];8 expression_statement [9];9 assignment [10,11];10 identifier [] cmd;11 call [12,15];12 attribute [13,14];13 identifier [] self;14 identifier [] file_diff_cmd;15 argument_list [16,17];16 identifier [] r;17 identifier [] file_name;18 expression_statement [19];19 assignment [20,21];20 identifier [] diff;21 call [22,23];22 identifier [] shell_out_ignore_exitcode;23 argument_list [24,25];24 identifier [] cmd;25 keyword_argument [26,27];26 identifier [] cwd;27 attribute [28,29];28 identifier [] self;29 identifier [] root;30 return_statement [31];31 call [32,33];32 identifier [] list;33 argument_list [34];34 call [35,38];35 attribute [36,37];36 identifier [] self;37 identifier [] modified_lines_from_diff;38 argument_list [39];39 identifier [] diff | Returns the line numbers of a file which have been changed. |
0 module [1];1 function_definition [2,3,7];2 function_name [] strip_command;3 parameters [4,5,6];4 identifier [] self;5 identifier [] command_string;6 identifier [] output;7 block [8,17];8 expression_statement [9];9 assignment [10,11];10 identifier [] output_list;11 call [12,15];12 attribute [13,14];13 identifier [] output;14 identifier [] split;15 argument_list [16];16 identifier [] command_string;17 return_statement [18];18 call [19,24];19 attribute [20,23];20 attribute [21,22];21 identifier [] self;22 identifier [] RESPONSE_RETURN;23 identifier [] join;24 argument_list [25];25 identifier [] output_list | Strip command_string from output string. |
0 module [1];1 function_definition [2,3,5];2 function_name [] valid_level;3 parameters [4];4 identifier [] value;5 block [6,14,33];6 expression_statement [7];7 assignment [8,9];8 identifier [] value;9 call [10,13];10 attribute [11,12];11 identifier [] value;12 identifier [] upper;13 argument_list [];14 if_statement [15,23];15 comparison_operator [16,22] is;16 call [17,18];17 identifier [] getattr;18 argument_list [19,20,21];19 identifier [] logging;20 identifier [] value;21 None [];22 None [];23 block [24];24 raise_statement [25];25 call [26,29];26 attribute [27,28];27 identifier [] argparse;28 identifier [] ArgumentTypeError;29 argument_list [30];30 binary_operator [31,32] %;31 string [] %s is not a valid level;32 identifier [] value;33 return_statement [34];34 identifier [] value | Validation function for parser, logging level argument. |
0 module [1];1 function_definition [2,3,6];2 function_name [] _ordered;3 parameters [4,5];4 identifier [] self;5 identifier [] odict;6 block [7,13,38,55,161];7 expression_statement [8];8 assignment [9,10];9 identifier [] ndict;10 call [11,12];11 identifier [] OrderedDict;12 argument_list [];13 if_statement [14,25,32];14 boolean_operator [15,20] or;15 call [16,17];16 identifier [] isinstance;17 argument_list [18,19];18 identifier [] odict;19 identifier [] CatDict;20 call [21,22];21 identifier [] isinstance;22 argument_list [23,24];23 identifier [] odict;24 identifier [] Entry;25 block [26];26 expression_statement [27];27 assignment [28,29];28 identifier [] key;29 attribute [30,31];30 identifier [] odict;31 identifier [] sort_func;32 else_clause [33];33 block [34];34 expression_statement [35];35 assignment [36,37];36 identifier [] key;37 None [];38 expression_statement [39];39 assignment [40,41];40 identifier [] nkeys;41 call [42,43];42 identifier [] list;43 argument_list [44];44 call [45,46];45 identifier [] sorted;46 argument_list [47,52];47 call [48,51];48 attribute [49,50];49 identifier [] odict;50 identifier [] keys;51 argument_list [];52 keyword_argument [53,54];53 identifier [] key;54 identifier [] key;55 for_statement [56,57,58];56 identifier [] key;57 identifier [] nkeys;58 block [59,81,153];59 if_statement [60,67];60 call [61,62];61 identifier [] isinstance;62 argument_list [63,66];63 subscript [64,65];64 identifier [] odict;65 identifier [] key;66 identifier [] OrderedDict;67 block [68];68 expression_statement [69];69 assignment [70,73];70 subscript [71,72];71 identifier [] odict;72 identifier [] key;73 call [74,77];74 attribute [75,76];75 identifier [] self;76 identifier [] _ordered;77 argument_list [78];78 subscript [79,80];79 identifier [] odict;80 identifier [] key;81 if_statement [82,89];82 call [83,84];83 identifier [] isinstance;84 argument_list [85,88];85 subscript [86,87];86 identifier [] odict;87 identifier [] key;88 identifier [] list;89 block [90];90 if_statement [91,108];91 () [92];92 not_operator [93];93 () [94];94 boolean_operator [95,98] and;95 subscript [96,97];96 identifier [] odict;97 identifier [] key;98 not_operator [99];99 call [100,101];100 identifier [] isinstance;101 argument_list [102,107];102 subscript [103,106];103 subscript [104,105];104 identifier [] odict;105 identifier [] key;106 integer [] 0;107 identifier [] OrderedDict;108 block [109,113,147];109 expression_statement [110];110 assignment [111,112];111 identifier [] nlist;112 list [] [];113 for_statement [114,115,118];114 identifier [] item;115 subscript [116,117];116 identifier [] odict;117 identifier [] key;118 block [119];119 if_statement [120,125,138];120 call [121,122];121 identifier [] isinstance;122 argument_list [123,124];123 identifier [] item;124 identifier [] OrderedDict;125 block [126];126 expression_statement [127];127 call [128,131];128 attribute [129,130];129 identifier [] nlist;130 identifier [] append;131 argument_list [132];132 call [133,136];133 attribute [134,135];134 identifier [] self;135 identifier [] _ordered;136 argument_list [137];137 identifier [] item;138 else_clause [139];139 block [140];140 expression_statement [141];141 call [142,145];142 attribute [143,144];143 identifier [] nlist;144 identifier [] append;145 argument_list [146];146 identifier [] item;147 expression_statement [148];148 assignment [149,152];149 subscript [150,151];150 identifier [] odict;151 identifier [] key;152 identifier [] nlist;153 expression_statement [154];154 assignment [155,158];155 subscript [156,157];156 identifier [] ndict;157 identifier [] key;158 subscript [159,160];159 identifier [] odict;160 identifier [] key;161 return_statement [162];162 identifier [] ndict | Convert the object into a plain OrderedDict. |
0 module [1];1 function_definition [2,3,5];2 function_name [] quit;3 parameters [4];4 identifier [] self;5 block [6,14,22,30,37,45,52];6 expression_statement [7];7 assignment [8,13];8 attribute [9,12];9 attribute [10,11];10 identifier [] self;11 identifier [] receive_thread;12 identifier [] stopped;13 True [];14 expression_statement [15];15 assignment [16,21];16 attribute [17,20];17 attribute [18,19];18 identifier [] self;19 identifier [] message_thread;20 identifier [] stopped;21 True [];22 expression_statement [23];23 call [24,29];24 attribute [25,28];25 attribute [26,27];26 identifier [] self;27 identifier [] receive_thread;28 identifier [] join;29 argument_list [];30 expression_statement [31];31 call [32,35];32 attribute [33,34];33 identifier [] _LOGGER;34 identifier [] info;35 argument_list [36];36 string [] receive_thread exited;37 expression_statement [38];38 call [39,44];39 attribute [40,43];40 attribute [41,42];41 identifier [] self;42 identifier [] message_thread;43 identifier [] join;44 argument_list [];45 expression_statement [46];46 call [47,50];47 attribute [48,49];48 identifier [] _LOGGER;49 identifier [] info;50 argument_list [51];51 string [] message_thread exited;52 expression_statement [53];53 call [54,59];54 attribute [55,58];55 attribute [56,57];56 identifier [] self;57 identifier [] socket;58 identifier [] close;59 argument_list [] | Close threads and socket. |
0 module [1];1 function_definition [2,3,6];2 function_name [] delete;3 parameters [4,5];4 identifier [] self;5 identifier [] name;6 block [7,16];7 expression_statement [8];8 assignment [9,10];9 identifier [] obj;10 call [11,14];11 attribute [12,13];12 identifier [] self;13 identifier [] _get_object;14 argument_list [15];15 identifier [] name;16 if_statement [17,18];17 identifier [] obj;18 block [19];19 return_statement [20];20 call [21,26];21 attribute [22,25];22 attribute [23,24];23 identifier [] self;24 identifier [] driver;25 identifier [] delete_object;26 argument_list [27];27 identifier [] obj | Delete object on remote |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.