sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 30; 2, function_name:send_array; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 4, identifier:socket; 5, default_parameter; 5, 6; 5, 7; 6, identifier:A; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:metadata; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:flags; 13, integer:0; 14, default_parameter; 14, 15; 14, 16; 15, identifier:copy; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:track; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:compress; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:chunksize; 25, binary_operator:*; 25, 26; 25, 29; 26, binary_operator:*; 26, 27; 26, 28; 27, integer:50; 28, integer:1000; 29, integer:1000; 30, block; 30, 31; 30, 35; 30, 51; 30, 61; 30, 81; 30, 103; 30, 114; 30, 122; 30, 142; 30, 169; 30, 181; 30, 278; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:md; 34, dictionary; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:md; 39, string:'timestamp'; 40, call; 40, 41; 40, 50; 41, attribute; 41, 42; 41, 49; 42, call; 42, 43; 42, 48; 43, attribute; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:datetime; 46, identifier:datetime; 47, identifier:now; 48, argument_list; 49, identifier:isoformat; 50, argument_list; 51, if_statement; 51, 52; 51, 53; 52, identifier:metadata; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:md; 58, identifier:update; 59, argument_list; 59, 60; 60, identifier:metadata; 61, if_statement; 61, 62; 61, 65; 62, comparison_operator:is; 62, 63; 62, 64; 63, identifier:A; 64, None; 65, block; 65, 66; 65, 72; 65, 80; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:md; 70, string:'parts'; 71, integer:0; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:socket; 76, identifier:send_json; 77, argument_list; 77, 78; 77, 79; 78, identifier:md; 79, identifier:flags; 80, return_statement; 81, if_statement; 81, 82; 81, 93; 82, boolean_operator:or; 82, 83; 82, 88; 83, call; 83, 84; 83, 85; 84, identifier:isinstance; 85, argument_list; 85, 86; 85, 87; 86, identifier:A; 87, identifier:float; 88, call; 88, 89; 88, 90; 89, identifier:isinstance; 90, argument_list; 90, 91; 90, 92; 91, identifier:A; 92, identifier:int; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:A; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:np; 100, identifier:asarray; 101, argument_list; 101, 102; 102, identifier:A; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, subscript; 105, 106; 105, 107; 106, identifier:md; 107, string:'dtype'; 108, call; 108, 109; 108, 110; 109, identifier:str; 110, argument_list; 110, 111; 111, attribute; 111, 112; 111, 113; 112, identifier:A; 113, identifier:dtype; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 119; 116, subscript; 116, 117; 116, 118; 117, identifier:md; 118, string:'shape'; 119, attribute; 119, 120; 119, 121; 120, identifier:A; 121, identifier:shape; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 127; 124, subscript; 124, 125; 124, 126; 125, identifier:md; 126, string:'parts'; 127, call; 127, 128; 127, 129; 128, identifier:int; 129, argument_list; 129, 130; 130, binary_operator:+; 130, 131; 130, 141; 131, binary_operator://; 131, 132; 131, 140; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:np; 135, identifier:prod; 136, argument_list; 136, 137; 137, attribute; 137, 138; 137, 139; 138, identifier:A; 139, identifier:shape; 140, identifier:chunksize; 141, integer:1; 142, try_statement; 142, 143; 142, 165; 143, block; 143, 144; 143, 157; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 149; 146, subscript; 146, 147; 146, 148; 147, identifier:md; 148, string:'fill_value'; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:np; 152, identifier:asscalar; 153, argument_list; 153, 154; 154, attribute; 154, 155; 154, 156; 155, identifier:A; 156, identifier:fill_value; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:A; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:A; 163, identifier:filled; 164, argument_list; 165, except_clause; 165, 166; 165, 167; 166, identifier:AttributeError; 167, block; 167, 168; 168, pass_statement; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:socket; 173, identifier:send_json; 174, argument_list; 174, 175; 174, 176; 175, identifier:md; 176, binary_operator:|; 176, 177; 176, 178; 177, identifier:flags; 178, attribute; 178, 179; 178, 180; 179, identifier:zmq; 180, identifier:SNDMORE; 181, if_statement; 181, 182; 181, 187; 181, 214; 182, comparison_operator:==; 182, 183; 182, 186; 183, subscript; 183, 184; 183, 185; 184, identifier:md; 185, string:'parts'; 186, integer:1; 187, block; 187, 188; 187, 200; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:msg; 191, call; 191, 192; 191, 193; 192, identifier:memoryview; 193, argument_list; 193, 194; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:np; 197, identifier:ascontiguousarray; 198, argument_list; 198, 199; 199, identifier:A; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:socket; 204, identifier:send; 205, argument_list; 205, 206; 205, 207; 205, 208; 205, 211; 206, identifier:msg; 207, identifier:flags; 208, keyword_argument; 208, 209; 208, 210; 209, identifier:copy; 210, identifier:copy; 211, keyword_argument; 211, 212; 211, 213; 212, identifier:track; 213, identifier:track; 214, else_clause; 214, 215; 215, block; 215, 216; 216, for_statement; 216, 217; 216, 220; 216, 232; 217, pattern_list; 217, 218; 217, 219; 218, identifier:i; 219, identifier:a; 220, call; 220, 221; 220, 222; 221, identifier:enumerate; 222, argument_list; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:np; 226, identifier:array_split; 227, argument_list; 227, 228; 227, 229; 228, identifier:A; 229, subscript; 229, 230; 229, 231; 230, identifier:md; 231, string:'parts'; 232, block; 232, 233; 232, 245; 232, 249; 232, 264; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:msg; 236, call; 236, 237; 236, 238; 237, identifier:memoryview; 238, argument_list; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:np; 242, identifier:ascontiguousarray; 243, argument_list; 243, 244; 244, identifier:a; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:flags_; 248, identifier:flags; 249, if_statement; 249, 250; 249, 257; 250, comparison_operator:!=; 250, 251; 250, 252; 251, identifier:i; 252, binary_operator:-; 252, 253; 252, 256; 253, subscript; 253, 254; 253, 255; 254, identifier:md; 255, string:'parts'; 256, integer:1; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, augmented_assignment:|=; 259, 260; 259, 261; 260, identifier:flags_; 261, attribute; 261, 262; 261, 263; 262, identifier:zmq; 263, identifier:SNDMORE; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:socket; 268, identifier:send; 269, argument_list; 269, 270; 269, 271; 269, 272; 269, 275; 270, identifier:msg; 271, identifier:flags_; 272, keyword_argument; 272, 273; 272, 274; 273, identifier:copy; 274, identifier:copy; 275, keyword_argument; 275, 276; 275, 277; 276, identifier:track; 277, identifier:track; 278, return_statement | def send_array(
socket, A=None, metadata=None, flags=0,
copy=False, track=False, compress=None,
chunksize=50 * 1000 * 1000
):
md = {}
md['timestamp'] = datetime.datetime.now().isoformat()
if metadata:
md.update(metadata)
if A is None:
md['parts'] = 0
socket.send_json(md, flags)
return
if isinstance(A, float) or isinstance(A, int):
A = np.asarray(A)
md['dtype'] = str(A.dtype)
md['shape'] = A.shape
md['parts'] = int(np.prod(A.shape) // chunksize + 1)
try:
md['fill_value'] = np.asscalar(A.fill_value)
A = A.filled()
except AttributeError:
pass
socket.send_json(md, flags | zmq.SNDMORE)
if md['parts'] == 1:
msg = memoryview(np.ascontiguousarray(A))
socket.send(msg, flags, copy=copy, track=track)
else:
for i, a in enumerate(np.array_split(A, md['parts'])):
msg = memoryview(np.ascontiguousarray(a))
flags_ = flags
if i != md['parts'] - 1:
flags_ |= zmq.SNDMORE
socket.send(msg, flags_, copy=copy, track=track)
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:recv_array; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:socket; 5, default_parameter; 5, 6; 5, 7; 6, identifier:flags; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:copy; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:track; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:poll; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:poll_timeout; 19, integer:10000; 20, block; 20, 21; 20, 85; 20, 428; 21, if_statement; 21, 22; 21, 25; 21, 37; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:poll; 24, None; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:md; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:socket; 32, identifier:recv_json; 33, argument_list; 33, 34; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:flags; 36, identifier:flags; 37, else_clause; 37, 38; 38, block; 38, 39; 38, 51; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:socks; 42, call; 42, 43; 42, 44; 43, identifier:dict; 44, argument_list; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:poll; 48, identifier:poll; 49, argument_list; 49, 50; 50, identifier:poll_timeout; 51, if_statement; 51, 52; 51, 62; 51, 78; 52, comparison_operator:==; 52, 53; 52, 59; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:socks; 56, identifier:get; 57, argument_list; 57, 58; 58, identifier:socket; 59, attribute; 59, 60; 59, 61; 60, identifier:zmq; 61, identifier:POLLIN; 62, block; 62, 63; 62, 74; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:reply; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:socket; 69, identifier:recv_json; 70, argument_list; 70, 71; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:flags; 73, identifier:flags; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:md; 77, identifier:reply; 78, else_clause; 78, 79; 79, block; 79, 80; 80, raise_statement; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:NoResponseException; 83, argument_list; 83, 84; 84, string:"Recv_array got no response within timeout (1)"; 85, if_statement; 85, 86; 85, 91; 85, 96; 85, 230; 86, comparison_operator:==; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:md; 89, string:'parts'; 90, integer:0; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:A; 95, None; 96, elif_clause; 96, 97; 96, 102; 97, comparison_operator:==; 97, 98; 97, 101; 98, subscript; 98, 99; 98, 100; 99, identifier:md; 100, string:'parts'; 101, integer:1; 102, block; 102, 103; 102, 179; 102, 186; 102, 200; 102, 211; 103, if_statement; 103, 104; 103, 107; 103, 125; 104, comparison_operator:is; 104, 105; 104, 106; 105, identifier:poll; 106, None; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:msg; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:socket; 114, identifier:recv; 115, argument_list; 115, 116; 115, 119; 115, 122; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:flags; 118, identifier:flags; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:copy; 121, identifier:copy; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:track; 124, identifier:track; 125, else_clause; 125, 126; 126, block; 126, 127; 126, 139; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:socks; 130, call; 130, 131; 130, 132; 131, identifier:dict; 132, argument_list; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:poll; 136, identifier:poll; 137, argument_list; 137, 138; 138, identifier:poll_timeout; 139, if_statement; 139, 140; 139, 150; 139, 172; 140, comparison_operator:==; 140, 141; 140, 147; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:socks; 144, identifier:get; 145, argument_list; 145, 146; 146, identifier:socket; 147, attribute; 147, 148; 147, 149; 148, identifier:zmq; 149, identifier:POLLIN; 150, block; 150, 151; 150, 168; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:reply; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:socket; 157, identifier:recv; 158, argument_list; 158, 159; 158, 162; 158, 165; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:flags; 161, identifier:flags; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:copy; 164, identifier:copy; 165, keyword_argument; 165, 166; 165, 167; 166, identifier:track; 167, identifier:track; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:msg; 171, identifier:reply; 172, else_clause; 172, 173; 173, block; 173, 174; 174, raise_statement; 174, 175; 175, call; 175, 176; 175, 177; 176, identifier:NoResponseException; 177, argument_list; 177, 178; 178, string:"Recv_array got no response within timeout (2)"; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:buf; 182, call; 182, 183; 182, 184; 183, identifier:buffer; 184, argument_list; 184, 185; 185, identifier:msg; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:A; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:np; 192, identifier:frombuffer; 193, argument_list; 193, 194; 193, 195; 194, identifier:buf; 195, keyword_argument; 195, 196; 195, 197; 196, identifier:dtype; 197, subscript; 197, 198; 197, 199; 198, identifier:md; 199, string:'dtype'; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:A; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:A; 206, identifier:reshape; 207, argument_list; 207, 208; 208, subscript; 208, 209; 208, 210; 209, identifier:md; 210, string:'shape'; 211, if_statement; 211, 212; 211, 215; 212, comparison_operator:in; 212, 213; 212, 214; 213, string:'fill_value'; 214, identifier:md; 215, block; 215, 216; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:A; 219, call; 219, 220; 219, 225; 220, attribute; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:np; 223, identifier:ma; 224, identifier:masked_equal; 225, argument_list; 225, 226; 225, 227; 226, identifier:A; 227, subscript; 227, 228; 227, 229; 228, identifier:md; 229, string:'fill_value'; 230, else_clause; 230, 231; 231, block; 231, 232; 231, 253; 231, 257; 231, 398; 231, 409; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:A; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:np; 238, identifier:zeros; 239, argument_list; 239, 240; 239, 248; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:np; 243, identifier:prod; 244, argument_list; 244, 245; 245, subscript; 245, 246; 245, 247; 246, identifier:md; 247, string:'shape'; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:dtype; 250, subscript; 250, 251; 250, 252; 251, identifier:md; 252, string:'dtype'; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:arr_position; 256, integer:0; 257, for_statement; 257, 258; 257, 259; 257, 265; 258, identifier:i; 259, call; 259, 260; 259, 261; 260, identifier:range; 261, argument_list; 261, 262; 262, subscript; 262, 263; 262, 264; 263, identifier:md; 264, string:'parts'; 265, block; 265, 266; 265, 351; 265, 358; 265, 372; 265, 390; 266, if_statement; 266, 267; 266, 270; 266, 288; 267, comparison_operator:is; 267, 268; 267, 269; 268, identifier:poll; 269, None; 270, block; 270, 271; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:msg; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:socket; 277, identifier:recv; 278, argument_list; 278, 279; 278, 282; 278, 285; 279, keyword_argument; 279, 280; 279, 281; 280, identifier:flags; 281, identifier:flags; 282, keyword_argument; 282, 283; 282, 284; 283, identifier:copy; 284, identifier:copy; 285, keyword_argument; 285, 286; 285, 287; 286, identifier:track; 287, identifier:track; 288, else_clause; 288, 289; 289, block; 289, 290; 289, 302; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:socks; 293, call; 293, 294; 293, 295; 294, identifier:dict; 295, argument_list; 295, 296; 296, call; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:poll; 299, identifier:poll; 300, argument_list; 300, 301; 301, identifier:poll_timeout; 302, if_statement; 302, 303; 302, 313; 302, 344; 303, comparison_operator:==; 303, 304; 303, 310; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:socks; 307, identifier:get; 308, argument_list; 308, 309; 309, identifier:socket; 310, attribute; 310, 311; 310, 312; 311, identifier:zmq; 312, identifier:POLLIN; 313, block; 313, 314; 313, 331; 313, 340; 314, expression_statement; 314, 315; 315, assignment; 315, 316; 315, 317; 316, identifier:reply; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:socket; 320, identifier:recv; 321, argument_list; 321, 322; 321, 325; 321, 328; 322, keyword_argument; 322, 323; 322, 324; 323, identifier:flags; 324, identifier:flags; 325, keyword_argument; 325, 326; 325, 327; 326, identifier:copy; 327, identifier:copy; 328, keyword_argument; 328, 329; 328, 330; 329, identifier:track; 330, identifier:track; 331, if_statement; 331, 332; 331, 334; 332, not_operator; 332, 333; 333, identifier:reply; 334, block; 334, 335; 335, raise_statement; 335, 336; 336, call; 336, 337; 336, 338; 337, identifier:EmptyResponseException; 338, argument_list; 338, 339; 339, string:"Recv_array got an empty response (2)"; 340, expression_statement; 340, 341; 341, assignment; 341, 342; 341, 343; 342, identifier:msg; 343, identifier:reply; 344, else_clause; 344, 345; 345, block; 345, 346; 346, raise_statement; 346, 347; 347, call; 347, 348; 347, 349; 348, identifier:NoResponseException; 349, argument_list; 349, 350; 350, string:"Recv_array got no response within timeout (2)"; 351, expression_statement; 351, 352; 352, assignment; 352, 353; 352, 354; 353, identifier:buf; 354, call; 354, 355; 354, 356; 355, identifier:buffer; 356, argument_list; 356, 357; 357, identifier:msg; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 361; 360, identifier:a; 361, call; 361, 362; 361, 365; 362, attribute; 362, 363; 362, 364; 363, identifier:np; 364, identifier:frombuffer; 365, argument_list; 365, 366; 365, 367; 366, identifier:buf; 367, keyword_argument; 367, 368; 367, 369; 368, identifier:dtype; 369, subscript; 369, 370; 369, 371; 370, identifier:md; 371, string:'dtype'; 372, expression_statement; 372, 373; 373, assignment; 373, 374; 373, 386; 374, subscript; 374, 375; 374, 376; 375, identifier:A; 376, slice; 376, 377; 376, 378; 376, 379; 377, identifier:arr_position; 378, colon; 379, binary_operator:+; 379, 380; 379, 381; 380, identifier:arr_position; 381, subscript; 381, 382; 381, 385; 382, attribute; 382, 383; 382, 384; 383, identifier:a; 384, identifier:shape; 385, integer:0; 386, subscript; 386, 387; 386, 388; 387, identifier:a; 388, slice; 388, 389; 389, colon; 390, expression_statement; 390, 391; 391, augmented_assignment:+=; 391, 392; 391, 393; 392, identifier:arr_position; 393, subscript; 393, 394; 393, 397; 394, attribute; 394, 395; 394, 396; 395, identifier:a; 396, identifier:shape; 397, integer:0; 398, expression_statement; 398, 399; 399, assignment; 399, 400; 399, 401; 400, identifier:A; 401, call; 401, 402; 401, 405; 402, attribute; 402, 403; 402, 404; 403, identifier:A; 404, identifier:reshape; 405, argument_list; 405, 406; 406, subscript; 406, 407; 406, 408; 407, identifier:md; 408, string:'shape'; 409, if_statement; 409, 410; 409, 413; 410, comparison_operator:in; 410, 411; 410, 412; 411, string:'fill_value'; 412, identifier:md; 413, block; 413, 414; 414, expression_statement; 414, 415; 415, assignment; 415, 416; 415, 417; 416, identifier:A; 417, call; 417, 418; 417, 423; 418, attribute; 418, 419; 418, 422; 419, attribute; 419, 420; 419, 421; 420, identifier:np; 421, identifier:ma; 422, identifier:masked_equal; 423, argument_list; 423, 424; 423, 425; 424, identifier:A; 425, subscript; 425, 426; 425, 427; 426, identifier:md; 427, string:'fill_value'; 428, return_statement; 428, 429; 429, expression_list; 429, 430; 429, 431; 430, identifier:A; 431, identifier:md | def recv_array(
socket,
flags=0,
copy=False,
track=False,
poll=None,
poll_timeout=10000
):
if poll is None:
md = socket.recv_json(flags=flags)
else:
socks = dict(poll.poll(poll_timeout))
if socks.get(socket) == zmq.POLLIN:
reply = socket.recv_json(flags=flags)
md = reply
else:
raise NoResponseException(
"Recv_array got no response within timeout (1)")
if md['parts'] == 0:
A = None
elif md['parts'] == 1:
if poll is None:
msg = socket.recv(flags=flags, copy=copy, track=track)
else:
socks = dict(poll.poll(poll_timeout))
if socks.get(socket) == zmq.POLLIN:
reply = socket.recv(flags=flags, copy=copy, track=track)
msg = reply
else:
raise NoResponseException(
"Recv_array got no response within timeout (2)")
buf = buffer(msg)
A = np.frombuffer(buf, dtype=md['dtype'])
A = A.reshape(md['shape'])
if 'fill_value' in md:
A = np.ma.masked_equal(A, md['fill_value'])
else:
A = np.zeros(np.prod(md['shape']), dtype=md['dtype'])
arr_position = 0
for i in range(md['parts']):
if poll is None:
msg = socket.recv(flags=flags, copy=copy, track=track)
else:
socks = dict(poll.poll(poll_timeout))
if socks.get(socket) == zmq.POLLIN:
reply = socket.recv(flags=flags, copy=copy, track=track)
if not reply:
raise EmptyResponseException(
"Recv_array got an empty response (2)")
msg = reply
else:
raise NoResponseException(
"Recv_array got no response within timeout (2)")
buf = buffer(msg)
a = np.frombuffer(buf, dtype=md['dtype'])
A[arr_position:arr_position + a.shape[0]] = a[:]
arr_position += a.shape[0]
A = A.reshape(md['shape'])
if 'fill_value' in md:
A = np.ma.masked_equal(A, md['fill_value'])
return A, md |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:reduce_fit; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:interface; 5, identifier:state; 6, identifier:label; 7, identifier:inp; 8, block; 8, 9; 8, 15; 8, 20; 8, 29; 8, 44; 8, 48; 8, 56; 8, 60; 8, 301; 8, 395; 8, 414; 8, 432; 8, 445; 8, 458; 9, import_from_statement; 9, 10; 9, 13; 10, dotted_name; 10, 11; 10, 12; 11, identifier:disco; 12, identifier:util; 13, dotted_name; 13, 14; 14, identifier:kvgroup; 15, import_statement; 15, 16; 16, aliased_import; 16, 17; 16, 19; 17, dotted_name; 17, 18; 18, identifier:numpy; 19, identifier:np; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:out; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:interface; 26, identifier:output; 27, argument_list; 27, 28; 28, integer:0; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:fit_model; 32, dictionary; 32, 33; 32, 36; 32, 39; 33, pair; 33, 34; 33, 35; 34, string:"y_labels"; 35, list:[]; 36, pair; 36, 37; 36, 38; 37, string:"y_sum"; 38, integer:0; 39, pair; 39, 40; 39, 41; 40, string:"iv"; 41, call; 41, 42; 41, 43; 42, identifier:set; 43, argument_list; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:combiner; 47, dictionary; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 53; 50, pattern_list; 50, 51; 50, 52; 51, identifier:means; 52, identifier:variances; 53, expression_list; 53, 54; 53, 55; 54, list:[]; 55, list:[]; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:k_prev; 59, string:""; 60, for_statement; 60, 61; 60, 64; 60, 68; 61, pattern_list; 61, 62; 61, 63; 62, identifier:key; 63, identifier:value; 64, call; 64, 65; 64, 66; 65, identifier:kvgroup; 66, argument_list; 66, 67; 67, identifier:inp; 68, block; 68, 69; 68, 80; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:k_split; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:key; 75, identifier:split; 76, argument_list; 76, 77; 77, subscript; 77, 78; 77, 79; 78, identifier:state; 79, string:"delimiter"; 80, if_statement; 80, 81; 80, 87; 80, 118; 80, 271; 81, comparison_operator:==; 81, 82; 81, 86; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, identifier:k_split; 86, integer:3; 87, block; 87, 88; 87, 104; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 95; 90, attribute; 90, 91; 90, 94; 91, subscript; 91, 92; 91, 93; 92, identifier:fit_model; 93, string:"iv"; 94, identifier:add; 95, argument_list; 95, 96; 96, call; 96, 97; 96, 98; 97, identifier:tuple; 98, argument_list; 98, 99; 99, subscript; 99, 100; 99, 101; 100, identifier:k_split; 101, slice; 101, 102; 101, 103; 102, integer:1; 103, colon; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:out; 108, identifier:add; 109, argument_list; 109, 110; 109, 114; 110, call; 110, 111; 110, 112; 111, identifier:tuple; 112, argument_list; 112, 113; 113, identifier:k_split; 114, call; 114, 115; 114, 116; 115, identifier:sum; 116, argument_list; 116, 117; 117, identifier:value; 118, elif_clause; 118, 119; 118, 125; 119, comparison_operator:==; 119, 120; 119, 124; 120, call; 120, 121; 120, 122; 121, identifier:len; 122, argument_list; 122, 123; 123, identifier:k_split; 124, integer:2; 125, block; 125, 126; 125, 174; 125, 182; 125, 250; 125, 265; 126, if_statement; 126, 127; 126, 136; 127, boolean_operator:and; 127, 128; 127, 133; 128, comparison_operator:!=; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:k_split; 131, integer:0; 132, identifier:k_prev; 133, comparison_operator:!=; 133, 134; 133, 135; 134, identifier:k_prev; 135, string:""; 136, block; 136, 137; 136, 160; 136, 167; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 142; 139, pattern_list; 139, 140; 139, 141; 140, identifier:mean; 141, identifier:var; 142, call; 142, 143; 142, 144; 143, identifier:zip; 144, argument_list; 144, 145; 145, list_splat; 145, 146; 146, list_comprehension; 146, 147; 146, 150; 147, subscript; 147, 148; 147, 149; 148, identifier:combiner; 149, identifier:key; 150, for_in_clause; 150, 151; 150, 152; 151, identifier:key; 152, call; 152, 153; 152, 154; 153, identifier:sorted; 154, argument_list; 154, 155; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:combiner; 158, identifier:keys; 159, argument_list; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:means; 164, identifier:append; 165, argument_list; 165, 166; 166, identifier:mean; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:variances; 171, identifier:append; 172, argument_list; 172, 173; 173, identifier:var; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:n_a; 177, assignment; 177, 178; 177, 179; 178, identifier:mean_a; 179, assignment; 179, 180; 179, 181; 180, identifier:var_a; 181, integer:0; 182, for_statement; 182, 183; 182, 187; 182, 188; 183, pattern_list; 183, 184; 183, 185; 183, 186; 184, identifier:n_b; 185, identifier:mean_b; 186, identifier:var_b; 187, identifier:value; 188, block; 188, 189; 188, 195; 188, 230; 188, 246; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:n_ab; 192, binary_operator:+; 192, 193; 192, 194; 193, identifier:n_a; 194, identifier:n_b; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:var_a; 198, binary_operator:+; 198, 199; 198, 213; 199, parenthesized_expression; 199, 200; 200, binary_operator:/; 200, 201; 200, 209; 201, parenthesized_expression; 201, 202; 202, binary_operator:+; 202, 203; 202, 206; 203, binary_operator:*; 203, 204; 203, 205; 204, identifier:n_a; 205, identifier:var_a; 206, binary_operator:*; 206, 207; 206, 208; 207, identifier:n_b; 208, identifier:var_b; 209, call; 209, 210; 209, 211; 210, identifier:float; 211, argument_list; 211, 212; 212, identifier:n_ab; 213, parenthesized_expression; 213, 214; 214, binary_operator:*; 214, 215; 214, 218; 215, binary_operator:*; 215, 216; 215, 217; 216, identifier:n_a; 217, identifier:n_b; 218, binary_operator:**; 218, 219; 218, 229; 219, parenthesized_expression; 219, 220; 220, binary_operator:/; 220, 221; 220, 225; 221, parenthesized_expression; 221, 222; 222, binary_operator:-; 222, 223; 222, 224; 223, identifier:mean_b; 224, identifier:mean_a; 225, call; 225, 226; 225, 227; 226, identifier:float; 227, argument_list; 227, 228; 228, identifier:n_ab; 229, integer:2; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:mean_a; 233, binary_operator:/; 233, 234; 233, 242; 234, parenthesized_expression; 234, 235; 235, binary_operator:+; 235, 236; 235, 239; 236, binary_operator:*; 236, 237; 236, 238; 237, identifier:n_a; 238, identifier:mean_a; 239, binary_operator:*; 239, 240; 239, 241; 240, identifier:n_b; 241, identifier:mean_b; 242, call; 242, 243; 242, 244; 243, identifier:float; 244, argument_list; 244, 245; 245, identifier:n_ab; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:n_a; 249, identifier:n_ab; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 260; 252, subscript; 252, 253; 252, 254; 253, identifier:combiner; 254, call; 254, 255; 254, 256; 255, identifier:int; 256, argument_list; 256, 257; 257, subscript; 257, 258; 257, 259; 258, identifier:k_split; 259, integer:1; 260, tuple; 260, 261; 260, 262; 261, identifier:mean_a; 262, binary_operator:+; 262, 263; 262, 264; 263, identifier:var_a; 264, float:1e-9; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:k_prev; 268, subscript; 268, 269; 268, 270; 269, identifier:k_split; 270, integer:0; 271, else_clause; 271, 272; 272, block; 272, 273; 272, 284; 272, 292; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 278; 275, subscript; 275, 276; 275, 277; 276, identifier:fit_model; 277, identifier:key; 278, call; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:np; 281, identifier:sum; 282, argument_list; 282, 283; 283, identifier:value; 284, expression_statement; 284, 285; 285, augmented_assignment:+=; 285, 286; 285, 289; 286, subscript; 286, 287; 286, 288; 287, identifier:fit_model; 288, string:"y_sum"; 289, subscript; 289, 290; 289, 291; 290, identifier:fit_model; 291, identifier:key; 292, expression_statement; 292, 293; 293, call; 293, 294; 293, 299; 294, attribute; 294, 295; 294, 298; 295, subscript; 295, 296; 295, 297; 296, identifier:fit_model; 297, string:"y_labels"; 298, identifier:append; 299, argument_list; 299, 300; 300, identifier:key; 301, if_statement; 301, 302; 301, 308; 302, comparison_operator:>; 302, 303; 302, 307; 303, call; 303, 304; 303, 305; 304, identifier:len; 305, argument_list; 305, 306; 306, identifier:means; 307, integer:0; 308, block; 308, 309; 308, 332; 308, 353; 308, 370; 308, 378; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 314; 311, pattern_list; 311, 312; 311, 313; 312, identifier:mean; 313, identifier:var; 314, call; 314, 315; 314, 316; 315, identifier:zip; 316, argument_list; 316, 317; 317, list_splat; 317, 318; 318, list_comprehension; 318, 319; 318, 322; 319, subscript; 319, 320; 319, 321; 320, identifier:combiner; 321, identifier:key; 322, for_in_clause; 322, 323; 322, 324; 323, identifier:key; 324, call; 324, 325; 324, 326; 325, identifier:sorted; 326, argument_list; 326, 327; 327, call; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:combiner; 330, identifier:keys; 331, argument_list; 332, expression_statement; 332, 333; 333, call; 333, 334; 333, 337; 334, attribute; 334, 335; 334, 336; 335, identifier:out; 336, identifier:add; 337, argument_list; 337, 338; 337, 339; 338, string:"mean"; 339, call; 339, 340; 339, 343; 340, attribute; 340, 341; 340, 342; 341, identifier:np; 342, identifier:array; 343, argument_list; 343, 344; 343, 348; 344, binary_operator:+; 344, 345; 344, 346; 345, identifier:means; 346, list:[mean]; 346, 347; 347, identifier:mean; 348, keyword_argument; 348, 349; 348, 350; 349, identifier:dtype; 350, attribute; 350, 351; 350, 352; 351, identifier:np; 352, identifier:float32; 353, expression_statement; 353, 354; 354, assignment; 354, 355; 354, 356; 355, identifier:variances; 356, call; 356, 357; 356, 360; 357, attribute; 357, 358; 357, 359; 358, identifier:np; 359, identifier:array; 360, argument_list; 360, 361; 360, 365; 361, binary_operator:+; 361, 362; 361, 363; 362, identifier:variances; 363, list:[var]; 363, 364; 364, identifier:var; 365, keyword_argument; 365, 366; 365, 367; 366, identifier:dtype; 367, attribute; 367, 368; 367, 369; 368, identifier:np; 369, identifier:float32; 370, expression_statement; 370, 371; 371, call; 371, 372; 371, 375; 372, attribute; 372, 373; 372, 374; 373, identifier:out; 374, identifier:add; 375, argument_list; 375, 376; 375, 377; 376, string:"var"; 377, identifier:variances; 378, expression_statement; 378, 379; 379, call; 379, 380; 379, 383; 380, attribute; 380, 381; 380, 382; 381, identifier:out; 382, identifier:add; 383, argument_list; 383, 384; 383, 385; 384, string:"var_log"; 385, call; 385, 386; 385, 389; 386, attribute; 386, 387; 386, 388; 387, identifier:np; 388, identifier:log; 389, argument_list; 389, 390; 390, binary_operator:*; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, identifier:np; 393, identifier:pi; 394, identifier:variances; 395, expression_statement; 395, 396; 396, assignment; 396, 397; 396, 398; 397, identifier:prior; 398, list_comprehension; 398, 399; 398, 409; 399, binary_operator:/; 399, 400; 399, 403; 400, subscript; 400, 401; 400, 402; 401, identifier:fit_model; 402, identifier:y_label; 403, call; 403, 404; 403, 405; 404, identifier:float; 405, argument_list; 405, 406; 406, subscript; 406, 407; 406, 408; 407, identifier:fit_model; 408, string:"y_sum"; 409, for_in_clause; 409, 410; 409, 411; 410, identifier:y_label; 411, subscript; 411, 412; 411, 413; 412, identifier:fit_model; 413, string:"y_labels"; 414, expression_statement; 414, 415; 415, call; 415, 416; 415, 419; 416, attribute; 416, 417; 416, 418; 417, identifier:out; 418, identifier:add; 419, argument_list; 419, 420; 419, 421; 420, string:"prior"; 421, call; 421, 422; 421, 425; 422, attribute; 422, 423; 422, 424; 423, identifier:np; 424, identifier:array; 425, argument_list; 425, 426; 425, 427; 426, identifier:prior; 427, keyword_argument; 427, 428; 427, 429; 428, identifier:dtype; 429, attribute; 429, 430; 429, 431; 430, identifier:np; 431, identifier:float32; 432, expression_statement; 432, 433; 433, call; 433, 434; 433, 437; 434, attribute; 434, 435; 434, 436; 435, identifier:out; 436, identifier:add; 437, argument_list; 437, 438; 437, 439; 438, string:"prior_log"; 439, call; 439, 440; 439, 443; 440, attribute; 440, 441; 440, 442; 441, identifier:np; 442, identifier:log; 443, argument_list; 443, 444; 444, identifier:prior; 445, expression_statement; 445, 446; 446, call; 446, 447; 446, 450; 447, attribute; 447, 448; 447, 449; 448, identifier:out; 449, identifier:add; 450, argument_list; 450, 451; 450, 452; 451, string:"iv"; 452, call; 452, 453; 452, 454; 453, identifier:list; 454, argument_list; 454, 455; 455, subscript; 455, 456; 455, 457; 456, identifier:fit_model; 457, string:"iv"; 458, expression_statement; 458, 459; 459, call; 459, 460; 459, 463; 460, attribute; 460, 461; 460, 462; 461, identifier:out; 462, identifier:add; 463, argument_list; 463, 464; 463, 465; 464, string:"y_labels"; 465, subscript; 465, 466; 465, 467; 466, identifier:fit_model; 467, string:"y_labels" | def reduce_fit(interface, state, label, inp):
from disco.util import kvgroup
import numpy as np
out = interface.output(0)
fit_model = {"y_labels": [], "y_sum": 0, "iv": set()}
combiner = {}
means, variances = [], []
k_prev = ""
for key, value in kvgroup(inp):
k_split = key.split(state["delimiter"])
if len(k_split) == 3:
fit_model["iv"].add(tuple(k_split[1:]))
out.add(tuple(k_split), sum(value))
elif len(k_split) == 2:
if k_split[0] != k_prev and k_prev != "":
mean, var = zip(*[combiner[key] for key in sorted(combiner.keys())])
means.append(mean)
variances.append(var)
n_a = mean_a = var_a = 0
for n_b, mean_b, var_b in value:
n_ab = n_a + n_b
var_a = ((n_a * var_a + n_b * var_b) / float(n_ab)) + (
n_a * n_b * ((mean_b - mean_a) / float(n_ab)) ** 2)
mean_a = (n_a * mean_a + n_b * mean_b) / float(n_ab)
n_a = n_ab
combiner[int(k_split[1])] = (mean_a, var_a + 1e-9)
k_prev = k_split[0]
else:
fit_model[key] = np.sum(value)
fit_model["y_sum"] += fit_model[key]
fit_model["y_labels"].append(key)
if len(means) > 0:
mean, var = zip(*[combiner[key] for key in sorted(combiner.keys())])
out.add("mean", np.array(means + [mean], dtype=np.float32))
variances = np.array(variances + [var], dtype=np.float32)
out.add("var", variances)
out.add("var_log", np.log(np.pi * variances))
prior = [fit_model[y_label] / float(fit_model["y_sum"]) for y_label in fit_model["y_labels"]]
out.add("prior", np.array(prior, dtype=np.float32))
out.add("prior_log", np.log(prior))
out.add("iv", list(fit_model["iv"]))
out.add("y_labels", fit_model["y_labels"]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:map_predict; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:interface; 5, identifier:state; 6, identifier:label; 7, identifier:inp; 8, block; 8, 9; 8, 14; 8, 23; 8, 46; 8, 69; 8, 81; 8, 93; 9, import_statement; 9, 10; 10, aliased_import; 10, 11; 10, 13; 11, dotted_name; 11, 12; 12, identifier:numpy; 13, identifier:np; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:out; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:interface; 20, identifier:output; 21, argument_list; 21, 22; 22, integer:0; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:continuous; 26, list_comprehension; 26, 27; 26, 28; 26, 38; 27, identifier:j; 28, for_in_clause; 28, 29; 28, 32; 29, pattern_list; 29, 30; 29, 31; 30, identifier:i; 31, identifier:j; 32, call; 32, 33; 32, 34; 33, identifier:enumerate; 34, argument_list; 34, 35; 35, subscript; 35, 36; 35, 37; 36, identifier:state; 37, string:"X_indices"; 38, if_clause; 38, 39; 39, comparison_operator:==; 39, 40; 39, 45; 40, subscript; 40, 41; 40, 44; 41, subscript; 41, 42; 41, 43; 42, identifier:state; 43, string:"X_meta"; 44, identifier:i; 45, string:"c"; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:discrete; 49, list_comprehension; 49, 50; 49, 51; 49, 61; 50, identifier:j; 51, for_in_clause; 51, 52; 51, 55; 52, pattern_list; 52, 53; 52, 54; 53, identifier:i; 54, identifier:j; 55, call; 55, 56; 55, 57; 56, identifier:enumerate; 57, argument_list; 57, 58; 58, subscript; 58, 59; 58, 60; 59, identifier:state; 60, string:"X_indices"; 61, if_clause; 61, 62; 62, comparison_operator:==; 62, 63; 62, 68; 63, subscript; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:state; 66, string:"X_meta"; 67, identifier:i; 68, string:"d"; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:cont; 72, conditional_expression:if; 72, 73; 72, 74; 72, 80; 73, True; 74, comparison_operator:>; 74, 75; 74, 79; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, identifier:continuous; 79, integer:0; 80, False; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:disc; 84, conditional_expression:if; 84, 85; 84, 86; 84, 92; 85, True; 86, comparison_operator:>; 86, 87; 86, 91; 87, call; 87, 88; 87, 89; 88, identifier:len; 89, argument_list; 89, 90; 90, identifier:discrete; 91, integer:0; 92, False; 93, for_statement; 93, 94; 93, 95; 93, 96; 94, identifier:row; 95, identifier:inp; 96, block; 96, 97; 96, 112; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:row; 100, call; 100, 101; 100, 108; 101, attribute; 101, 102; 101, 107; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:row; 105, identifier:strip; 106, argument_list; 107, identifier:split; 108, argument_list; 108, 109; 109, subscript; 109, 110; 109, 111; 110, identifier:state; 111, string:"delimiter"; 112, if_statement; 112, 113; 112, 119; 113, comparison_operator:>; 113, 114; 113, 118; 114, call; 114, 115; 114, 116; 115, identifier:len; 116, argument_list; 116, 117; 117, identifier:row; 118, integer:1; 119, block; 119, 120; 119, 136; 119, 144; 119, 216; 119, 267; 119, 286; 119, 302; 119, 319; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:x_id; 123, conditional_expression:if; 123, 124; 123, 125; 123, 131; 124, string:""; 125, comparison_operator:==; 125, 126; 125, 129; 126, subscript; 126, 127; 126, 128; 127, identifier:state; 128, string:"id_index"; 129, unary_operator:-; 129, 130; 130, integer:1; 131, subscript; 131, 132; 131, 133; 132, identifier:row; 133, subscript; 133, 134; 133, 135; 134, identifier:state; 135, string:"id_index"; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:probs; 139, subscript; 139, 140; 139, 143; 140, subscript; 140, 141; 140, 142; 141, identifier:state; 142, string:"fit_model"; 143, string:"prior_log"; 144, if_statement; 144, 145; 144, 146; 145, identifier:cont; 146, block; 146, 147; 146, 175; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:x; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:np; 153, identifier:array; 154, argument_list; 154, 155; 155, list_comprehension; 155, 156; 155, 172; 156, parenthesized_expression; 156, 157; 157, conditional_expression:if; 157, 158; 157, 159; 157, 166; 158, integer:0; 159, comparison_operator:in; 159, 160; 159, 163; 160, subscript; 160, 161; 160, 162; 161, identifier:row; 162, identifier:j; 163, subscript; 163, 164; 163, 165; 164, identifier:state; 165, string:"missing_vals"; 166, call; 166, 167; 166, 168; 167, identifier:float; 168, argument_list; 168, 169; 169, subscript; 169, 170; 169, 171; 170, identifier:row; 171, identifier:j; 172, for_in_clause; 172, 173; 172, 174; 173, identifier:j; 174, identifier:continuous; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:probs; 178, binary_operator:-; 178, 179; 178, 180; 179, identifier:probs; 180, binary_operator:*; 180, 181; 180, 182; 181, float:0.5; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:np; 185, identifier:sum; 186, argument_list; 186, 187; 186, 213; 187, binary_operator:+; 187, 188; 187, 208; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:np; 191, identifier:true_divide; 192, argument_list; 192, 193; 192, 203; 193, binary_operator:**; 193, 194; 193, 202; 194, parenthesized_expression; 194, 195; 195, binary_operator:-; 195, 196; 195, 197; 196, identifier:x; 197, subscript; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:state; 200, string:"fit_model"; 201, string:"mean"; 202, integer:2; 203, subscript; 203, 204; 203, 207; 204, subscript; 204, 205; 204, 206; 205, identifier:state; 206, string:"fit_model"; 207, string:"var"; 208, subscript; 208, 209; 208, 212; 209, subscript; 209, 210; 209, 211; 210, identifier:state; 211, string:"fit_model"; 212, string:"var_log"; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:axis; 215, integer:1; 216, if_statement; 216, 217; 216, 218; 217, identifier:disc; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:probs; 222, binary_operator:+; 222, 223; 222, 224; 223, identifier:probs; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:np; 227, identifier:sum; 228, argument_list; 228, 229; 228, 264; 229, list_comprehension; 229, 230; 229, 261; 230, parenthesized_expression; 230, 231; 231, conditional_expression:if; 231, 232; 231, 233; 231, 240; 232, integer:0; 233, comparison_operator:in; 233, 234; 233, 237; 234, subscript; 234, 235; 234, 236; 235, identifier:row; 236, identifier:i; 237, subscript; 237, 238; 237, 239; 238, identifier:state; 239, string:"missing_vals"; 240, call; 240, 241; 240, 246; 241, attribute; 241, 242; 241, 245; 242, subscript; 242, 243; 242, 244; 243, identifier:state; 244, string:"fit_model"; 245, identifier:get; 246, argument_list; 246, 247; 246, 255; 247, tuple; 247, 248; 247, 252; 248, call; 248, 249; 248, 250; 249, identifier:str; 250, argument_list; 250, 251; 251, identifier:i; 252, subscript; 252, 253; 252, 254; 253, identifier:row; 254, identifier:i; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:np; 258, identifier:zeros; 259, argument_list; 259, 260; 260, integer:1; 261, for_in_clause; 261, 262; 261, 263; 262, identifier:i; 263, identifier:discrete; 264, keyword_argument; 264, 265; 264, 266; 265, identifier:axis; 266, integer:0; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:log_prob_x; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:np; 273, identifier:log; 274, argument_list; 274, 275; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:np; 278, identifier:sum; 279, argument_list; 279, 280; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:np; 283, identifier:exp; 284, argument_list; 284, 285; 285, identifier:probs; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:probs; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:np; 292, identifier:exp; 293, argument_list; 293, 294; 294, binary_operator:-; 294, 295; 294, 301; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:np; 298, identifier:array; 299, argument_list; 299, 300; 300, identifier:probs; 301, identifier:log_prob_x; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 305; 304, identifier:y_predicted; 305, subscript; 305, 306; 305, 318; 306, call; 306, 307; 306, 308; 307, identifier:max; 308, argument_list; 308, 309; 309, call; 309, 310; 309, 311; 310, identifier:zip; 311, argument_list; 311, 312; 311, 313; 312, identifier:probs; 313, subscript; 313, 314; 313, 317; 314, subscript; 314, 315; 314, 316; 315, identifier:state; 316, string:"fit_model"; 317, string:"y_labels"; 318, integer:1; 319, expression_statement; 319, 320; 320, call; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:out; 323, identifier:add; 324, argument_list; 324, 325; 324, 326; 325, identifier:x_id; 326, tuple; 326, 327; 326, 328; 327, identifier:y_predicted; 328, call; 328, 329; 328, 332; 329, attribute; 329, 330; 329, 331; 330, identifier:probs; 331, identifier:tolist; 332, argument_list | def map_predict(interface, state, label, inp):
import numpy as np
out = interface.output(0)
continuous = [j for i, j in enumerate(state["X_indices"]) if
state["X_meta"][i] == "c"]
discrete = [j for i, j in enumerate(state["X_indices"]) if
state["X_meta"][i] == "d"]
cont = True if len(continuous) > 0 else False
disc = True if len(discrete) > 0 else False
for row in inp:
row = row.strip().split(state["delimiter"])
if len(row) > 1:
x_id = "" if state["id_index"] == -1 else row[state["id_index"]]
probs = state["fit_model"]["prior_log"]
if cont:
x = np.array([(0 if row[j] in state["missing_vals"] else float(row[j])) for j in
continuous])
probs = probs - 0.5 * np.sum(
np.true_divide((x - state["fit_model"]["mean"]) ** 2, state["fit_model"]["var"]) +
state["fit_model"]["var_log"], axis=1)
if disc:
probs = probs + np.sum(
[(0 if row[i] in state["missing_vals"] else state["fit_model"].get((str(i), row[i]), np.zeros(1)))
for i in discrete], axis=0)
log_prob_x = np.log(np.sum(np.exp(probs)))
probs = np.exp(np.array(probs) - log_prob_x)
y_predicted = max(zip(probs, state["fit_model"]["y_labels"]))[1]
out.add(x_id, (y_predicted, probs.tolist())) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:json_dumps; 3, parameters; 3, 4; 4, identifier:obj; 5, block; 5, 6; 5, 28; 5, 46; 5, 55; 5, 164; 6, try_statement; 6, 7; 6, 24; 7, block; 7, 8; 8, return_statement; 8, 9; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:json; 12, identifier:dumps; 13, argument_list; 13, 14; 13, 15; 13, 18; 13, 21; 14, identifier:obj; 15, keyword_argument; 15, 16; 15, 17; 16, identifier:indent; 17, integer:2; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:sort_keys; 20, True; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:allow_nan; 23, False; 24, except_clause; 24, 25; 24, 26; 25, identifier:ValueError; 26, block; 26, 27; 27, pass_statement; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:json_str; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:json; 34, identifier:dumps; 35, argument_list; 35, 36; 35, 37; 35, 40; 35, 43; 36, identifier:obj; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:indent; 39, integer:2; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:sort_keys; 42, True; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:allow_nan; 45, True; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:json_obj; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:json; 52, identifier:loads; 53, argument_list; 53, 54; 54, identifier:json_str; 55, function_definition; 55, 56; 55, 57; 55, 59; 56, function_name:do_map; 57, parameters; 57, 58; 58, identifier:obj; 59, block; 59, 60; 59, 67; 59, 76; 59, 108; 59, 137; 59, 147; 59, 162; 60, if_statement; 60, 61; 60, 64; 61, comparison_operator:is; 61, 62; 61, 63; 62, identifier:obj; 63, None; 64, block; 64, 65; 65, return_statement; 65, 66; 66, None; 67, if_statement; 67, 68; 67, 73; 68, call; 68, 69; 68, 70; 69, identifier:isinstance; 70, argument_list; 70, 71; 70, 72; 71, identifier:obj; 72, identifier:basestring; 73, block; 73, 74; 74, return_statement; 74, 75; 75, identifier:obj; 76, if_statement; 76, 77; 76, 82; 77, call; 77, 78; 77, 79; 78, identifier:isinstance; 79, argument_list; 79, 80; 79, 81; 80, identifier:obj; 81, identifier:dict; 82, block; 82, 83; 82, 87; 82, 106; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:res; 86, dictionary; 87, for_statement; 87, 88; 87, 91; 87, 96; 88, tuple_pattern; 88, 89; 88, 90; 89, identifier:key; 90, identifier:value; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:obj; 94, identifier:items; 95, argument_list; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:res; 101, identifier:key; 102, call; 102, 103; 102, 104; 103, identifier:do_map; 104, argument_list; 104, 105; 105, identifier:value; 106, return_statement; 106, 107; 107, identifier:res; 108, if_statement; 108, 109; 108, 116; 109, call; 109, 110; 109, 111; 110, identifier:isinstance; 111, argument_list; 111, 112; 111, 113; 112, identifier:obj; 113, attribute; 113, 114; 113, 115; 114, identifier:collections; 115, identifier:Iterable; 116, block; 116, 117; 116, 121; 116, 135; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:res; 120, list:[]; 121, for_statement; 121, 122; 121, 123; 121, 124; 122, identifier:el; 123, identifier:obj; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:res; 129, identifier:append; 130, argument_list; 130, 131; 131, call; 131, 132; 131, 133; 132, identifier:do_map; 133, argument_list; 133, 134; 134, identifier:el; 135, return_statement; 135, 136; 136, identifier:res; 137, if_statement; 137, 138; 137, 144; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:math; 141, identifier:isnan; 142, argument_list; 142, 143; 143, identifier:obj; 144, block; 144, 145; 145, return_statement; 145, 146; 146, string:"NaN"; 147, if_statement; 147, 148; 147, 154; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:math; 151, identifier:isinf; 152, argument_list; 152, 153; 153, identifier:obj; 154, block; 154, 155; 155, return_statement; 155, 156; 156, conditional_expression:if; 156, 157; 156, 158; 156, 161; 157, string:"Infinity"; 158, comparison_operator:>; 158, 159; 158, 160; 159, identifier:obj; 160, integer:0; 161, string:"-Infinity"; 162, return_statement; 162, 163; 163, identifier:obj; 164, return_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:json; 168, identifier:dumps; 169, argument_list; 169, 170; 169, 174; 169, 177; 169, 180; 170, call; 170, 171; 170, 172; 171, identifier:do_map; 172, argument_list; 172, 173; 173, identifier:json_obj; 174, keyword_argument; 174, 175; 174, 176; 175, identifier:indent; 176, integer:2; 177, keyword_argument; 177, 178; 177, 179; 178, identifier:sort_keys; 179, True; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:allow_nan; 182, False | def json_dumps(obj):
try:
return json.dumps(obj, indent=2, sort_keys=True, allow_nan=False)
except ValueError:
pass
json_str = json.dumps(obj, indent=2, sort_keys=True, allow_nan=True)
json_obj = json.loads(json_str)
def do_map(obj):
if obj is None:
return None
if isinstance(obj, basestring):
return obj
if isinstance(obj, dict):
res = {}
for (key, value) in obj.items():
res[key] = do_map(value)
return res
if isinstance(obj, collections.Iterable):
res = []
for el in obj:
res.append(do_map(el))
return res
if math.isnan(obj):
return "NaN"
if math.isinf(obj):
return "Infinity" if obj > 0 else "-Infinity"
return obj
return json.dumps(
do_map(json_obj), indent=2, sort_keys=True, allow_nan=False) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:add_json_mask; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:start; 6, identifier:method_str; 7, identifier:json_producer; 8, block; 8, 9; 8, 274; 9, function_definition; 9, 10; 9, 11; 9, 14; 10, function_name:send_json; 11, parameters; 11, 12; 11, 13; 12, identifier:drh; 13, identifier:rem_path; 14, block; 14, 15; 14, 23; 14, 38; 14, 47; 14, 53; 14, 59; 14, 74; 14, 80; 14, 87; 14, 120; 14, 127; 14, 133; 14, 141; 14, 148; 14, 243; 14, 250; 14, 258; 14, 266; 14, 272; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:obj; 18, call; 18, 19; 18, 20; 19, identifier:json_producer; 20, argument_list; 20, 21; 20, 22; 21, identifier:drh; 22, identifier:rem_path; 23, if_statement; 23, 24; 23, 30; 24, not_operator; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 29; 28, identifier:obj; 29, identifier:Response; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:obj; 34, call; 34, 35; 34, 36; 35, identifier:Response; 36, argument_list; 36, 37; 37, identifier:obj; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:ctype; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:obj; 44, identifier:get_ctype; 45, argument_list; 45, 46; 46, string:"application/json"; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:code; 50, attribute; 50, 51; 50, 52; 51, identifier:obj; 52, identifier:code; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:obj; 56, attribute; 56, 57; 56, 58; 57, identifier:obj; 58, identifier:response; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:is; 60, 61; 60, 62; 61, identifier:obj; 62, None; 63, block; 63, 64; 63, 72; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:drh; 68, identifier:send_error; 69, argument_list; 69, 70; 69, 71; 70, integer:404; 71, string:"File not found"; 72, return_statement; 72, 73; 73, None; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:f; 77, call; 77, 78; 77, 79; 78, identifier:BytesIO; 79, argument_list; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:json_str; 83, call; 83, 84; 83, 85; 84, identifier:json_dumps; 85, argument_list; 85, 86; 86, identifier:obj; 87, if_statement; 87, 88; 87, 95; 88, call; 88, 89; 88, 90; 89, identifier:isinstance; 90, argument_list; 90, 91; 90, 92; 91, identifier:json_str; 92, tuple; 92, 93; 92, 94; 93, identifier:str; 94, identifier:unicode; 95, block; 95, 96; 95, 111; 96, try_statement; 96, 97; 96, 107; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:json_str; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:json_str; 104, identifier:decode; 105, argument_list; 105, 106; 106, string:'utf8'; 107, except_clause; 107, 108; 107, 109; 108, identifier:AttributeError; 109, block; 109, 110; 110, pass_statement; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:json_str; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:json_str; 117, identifier:encode; 118, argument_list; 118, 119; 119, string:'utf8'; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:f; 124, identifier:write; 125, argument_list; 125, 126; 126, identifier:json_str; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:f; 131, identifier:flush; 132, argument_list; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:size; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:f; 139, identifier:tell; 140, argument_list; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:f; 145, identifier:seek; 146, argument_list; 146, 147; 147, integer:0; 148, if_statement; 148, 149; 148, 154; 149, comparison_operator:>=; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:drh; 152, identifier:request_version; 153, string:"HTTP/1.1"; 154, block; 154, 155; 154, 175; 154, 182; 154, 192; 154, 214; 154, 225; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:e_tag; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, string:"{0:x}"; 161, identifier:format; 162, argument_list; 162, 163; 163, binary_operator:&; 163, 164; 163, 174; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:zlib; 167, identifier:crc32; 168, argument_list; 168, 169; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:f; 172, identifier:read; 173, argument_list; 174, integer:0xFFFFFFFF; 175, expression_statement; 175, 176; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:f; 179, identifier:seek; 180, argument_list; 180, 181; 181, integer:0; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:match; 185, call; 185, 186; 185, 187; 186, identifier:_getheader; 187, argument_list; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:drh; 190, identifier:headers; 191, string:'if-none-match'; 192, if_statement; 192, 193; 192, 196; 193, comparison_operator:is; 193, 194; 193, 195; 194, identifier:match; 195, None; 196, block; 196, 197; 197, if_statement; 197, 198; 197, 205; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:drh; 201, identifier:check_cache; 202, argument_list; 202, 203; 202, 204; 203, identifier:e_tag; 204, identifier:match; 205, block; 205, 206; 205, 212; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:f; 210, identifier:close; 211, argument_list; 212, return_statement; 212, 213; 213, None; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:drh; 218, identifier:send_header; 219, argument_list; 219, 220; 219, 221; 219, 222; 220, string:"ETag"; 221, identifier:e_tag; 222, keyword_argument; 222, 223; 222, 224; 223, identifier:end_header; 224, True; 225, expression_statement; 225, 226; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:drh; 229, identifier:send_header; 230, argument_list; 230, 231; 230, 232; 230, 240; 231, string:"Cache-Control"; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, string:"max-age={0}"; 235, identifier:format; 236, argument_list; 236, 237; 237, attribute; 237, 238; 237, 239; 238, identifier:self; 239, identifier:max_age; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:end_header; 242, True; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:drh; 247, identifier:send_response; 248, argument_list; 248, 249; 249, identifier:code; 250, expression_statement; 250, 251; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:drh; 254, identifier:send_header; 255, argument_list; 255, 256; 255, 257; 256, string:"Content-Type"; 257, identifier:ctype; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:drh; 262, identifier:send_header; 263, argument_list; 263, 264; 263, 265; 264, string:"Content-Length"; 265, identifier:size; 266, expression_statement; 266, 267; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:drh; 270, identifier:end_headers; 271, argument_list; 272, return_statement; 272, 273; 273, identifier:f; 274, expression_statement; 274, 275; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:self; 278, identifier:_add_file_mask; 279, argument_list; 279, 280; 279, 281; 279, 282; 280, identifier:start; 281, identifier:method_str; 282, identifier:send_json | def add_json_mask(self, start, method_str, json_producer):
def send_json(drh, rem_path):
obj = json_producer(drh, rem_path)
if not isinstance(obj, Response):
obj = Response(obj)
ctype = obj.get_ctype("application/json")
code = obj.code
obj = obj.response
if obj is None:
drh.send_error(404, "File not found")
return None
f = BytesIO()
json_str = json_dumps(obj)
if isinstance(json_str, (str, unicode)):
try:
json_str = json_str.decode('utf8')
except AttributeError:
pass
json_str = json_str.encode('utf8')
f.write(json_str)
f.flush()
size = f.tell()
f.seek(0)
if drh.request_version >= "HTTP/1.1":
e_tag = "{0:x}".format(zlib.crc32(f.read()) & 0xFFFFFFFF)
f.seek(0)
match = _getheader(drh.headers, 'if-none-match')
if match is not None:
if drh.check_cache(e_tag, match):
f.close()
return None
drh.send_header("ETag", e_tag, end_header=True)
drh.send_header("Cache-Control",
"max-age={0}".format(self.max_age),
end_header=True)
drh.send_response(code)
drh.send_header("Content-Type", ctype)
drh.send_header("Content-Length", size)
drh.end_headers()
return f
self._add_file_mask(start, method_str, send_json) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:add_text_mask; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:start; 6, identifier:method_str; 7, identifier:text_producer; 8, block; 8, 9; 8, 267; 9, function_definition; 9, 10; 9, 11; 9, 14; 10, function_name:send_text; 11, parameters; 11, 12; 11, 13; 12, identifier:drh; 13, identifier:rem_path; 14, block; 14, 15; 14, 23; 14, 38; 14, 47; 14, 53; 14, 59; 14, 74; 14, 80; 14, 113; 14, 120; 14, 126; 14, 134; 14, 141; 14, 236; 14, 243; 14, 251; 14, 259; 14, 265; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:text; 18, call; 18, 19; 18, 20; 19, identifier:text_producer; 20, argument_list; 20, 21; 20, 22; 21, identifier:drh; 22, identifier:rem_path; 23, if_statement; 23, 24; 23, 30; 24, not_operator; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 29; 28, identifier:text; 29, identifier:Response; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:text; 34, call; 34, 35; 34, 36; 35, identifier:Response; 36, argument_list; 36, 37; 37, identifier:text; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:ctype; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:text; 44, identifier:get_ctype; 45, argument_list; 45, 46; 46, string:"text/plain"; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:code; 50, attribute; 50, 51; 50, 52; 51, identifier:text; 52, identifier:code; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:text; 56, attribute; 56, 57; 56, 58; 57, identifier:text; 58, identifier:response; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:is; 60, 61; 60, 62; 61, identifier:text; 62, None; 63, block; 63, 64; 63, 72; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:drh; 68, identifier:send_error; 69, argument_list; 69, 70; 69, 71; 70, integer:404; 71, string:"File not found"; 72, return_statement; 72, 73; 73, None; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:f; 77, call; 77, 78; 77, 79; 78, identifier:BytesIO; 79, argument_list; 80, if_statement; 80, 81; 80, 88; 81, call; 81, 82; 81, 83; 82, identifier:isinstance; 83, argument_list; 83, 84; 83, 85; 84, identifier:text; 85, tuple; 85, 86; 85, 87; 86, identifier:str; 87, identifier:unicode; 88, block; 88, 89; 88, 104; 89, try_statement; 89, 90; 89, 100; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:text; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:text; 97, identifier:decode; 98, argument_list; 98, 99; 99, string:'utf8'; 100, except_clause; 100, 101; 100, 102; 101, identifier:AttributeError; 102, block; 102, 103; 103, pass_statement; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:text; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:text; 110, identifier:encode; 111, argument_list; 111, 112; 112, string:'utf8'; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:f; 117, identifier:write; 118, argument_list; 118, 119; 119, identifier:text; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:f; 124, identifier:flush; 125, argument_list; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:size; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:f; 132, identifier:tell; 133, argument_list; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:f; 138, identifier:seek; 139, argument_list; 139, 140; 140, integer:0; 141, if_statement; 141, 142; 141, 147; 142, comparison_operator:>=; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:drh; 145, identifier:request_version; 146, string:"HTTP/1.1"; 147, block; 147, 148; 147, 168; 147, 175; 147, 185; 147, 207; 147, 218; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:e_tag; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, string:"{0:x}"; 154, identifier:format; 155, argument_list; 155, 156; 156, binary_operator:&; 156, 157; 156, 167; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:zlib; 160, identifier:crc32; 161, argument_list; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:f; 165, identifier:read; 166, argument_list; 167, integer:0xFFFFFFFF; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:f; 172, identifier:seek; 173, argument_list; 173, 174; 174, integer:0; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:match; 178, call; 178, 179; 178, 180; 179, identifier:_getheader; 180, argument_list; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:drh; 183, identifier:headers; 184, string:'if-none-match'; 185, if_statement; 185, 186; 185, 189; 186, comparison_operator:is; 186, 187; 186, 188; 187, identifier:match; 188, None; 189, block; 189, 190; 190, if_statement; 190, 191; 190, 198; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:drh; 194, identifier:check_cache; 195, argument_list; 195, 196; 195, 197; 196, identifier:e_tag; 197, identifier:match; 198, block; 198, 199; 198, 205; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:f; 203, identifier:close; 204, argument_list; 205, return_statement; 205, 206; 206, None; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:drh; 211, identifier:send_header; 212, argument_list; 212, 213; 212, 214; 212, 215; 213, string:"ETag"; 214, identifier:e_tag; 215, keyword_argument; 215, 216; 215, 217; 216, identifier:end_header; 217, True; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:drh; 222, identifier:send_header; 223, argument_list; 223, 224; 223, 225; 223, 233; 224, string:"Cache-Control"; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, string:"max-age={0}"; 228, identifier:format; 229, argument_list; 229, 230; 230, attribute; 230, 231; 230, 232; 231, identifier:self; 232, identifier:max_age; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:end_header; 235, True; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:drh; 240, identifier:send_response; 241, argument_list; 241, 242; 242, identifier:code; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:drh; 247, identifier:send_header; 248, argument_list; 248, 249; 248, 250; 249, string:"Content-Type"; 250, identifier:ctype; 251, expression_statement; 251, 252; 252, call; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:drh; 255, identifier:send_header; 256, argument_list; 256, 257; 256, 258; 257, string:"Content-Length"; 258, identifier:size; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:drh; 263, identifier:end_headers; 264, argument_list; 265, return_statement; 265, 266; 266, identifier:f; 267, expression_statement; 267, 268; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:self; 271, identifier:_add_file_mask; 272, argument_list; 272, 273; 272, 274; 272, 275; 273, identifier:start; 274, identifier:method_str; 275, identifier:send_text | def add_text_mask(self, start, method_str, text_producer):
def send_text(drh, rem_path):
text = text_producer(drh, rem_path)
if not isinstance(text, Response):
text = Response(text)
ctype = text.get_ctype("text/plain")
code = text.code
text = text.response
if text is None:
drh.send_error(404, "File not found")
return None
f = BytesIO()
if isinstance(text, (str, unicode)):
try:
text = text.decode('utf8')
except AttributeError:
pass
text = text.encode('utf8')
f.write(text)
f.flush()
size = f.tell()
f.seek(0)
if drh.request_version >= "HTTP/1.1":
e_tag = "{0:x}".format(zlib.crc32(f.read()) & 0xFFFFFFFF)
f.seek(0)
match = _getheader(drh.headers, 'if-none-match')
if match is not None:
if drh.check_cache(e_tag, match):
f.close()
return None
drh.send_header("ETag", e_tag, end_header=True)
drh.send_header("Cache-Control",
"max-age={0}".format(self.max_age),
end_header=True)
drh.send_response(code)
drh.send_header("Content-Type", ctype)
drh.send_header("Content-Length", size)
drh.end_headers()
return f
self._add_file_mask(start, method_str, send_text) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_token_obj; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:token; 6, default_parameter; 6, 7; 6, 8; 7, identifier:expire; 8, identifier:_token_default; 9, block; 9, 10; 9, 23; 9, 29; 9, 40; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:==; 11, 12; 11, 13; 12, identifier:expire; 13, identifier:_token_default; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:expire; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:get_default_token_expiration; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:now; 26, call; 26, 27; 26, 28; 27, identifier:get_time; 28, argument_list; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:until; 32, conditional_expression:if; 32, 33; 32, 36; 32, 39; 33, binary_operator:+; 33, 34; 33, 35; 34, identifier:now; 35, identifier:expire; 36, comparison_operator:is; 36, 37; 36, 38; 37, identifier:expire; 38, None; 39, None; 40, with_statement; 40, 41; 40, 46; 41, with_clause; 41, 42; 42, with_item; 42, 43; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_token_lock; 46, block; 46, 47; 46, 51; 46, 86; 46, 133; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:first_valid; 50, None; 51, for_statement; 51, 52; 51, 55; 51, 61; 52, tuple_pattern; 52, 53; 52, 54; 53, identifier:pos; 54, identifier:k; 55, call; 55, 56; 55, 57; 56, identifier:enumerate; 57, argument_list; 57, 58; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:_token_timings; 61, block; 61, 62; 61, 72; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:t; 65, subscript; 65, 66; 65, 71; 66, subscript; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:_token_map; 70, identifier:k; 71, integer:0; 72, if_statement; 72, 73; 72, 80; 73, boolean_operator:or; 73, 74; 73, 77; 74, comparison_operator:is; 74, 75; 74, 76; 75, identifier:t; 76, None; 77, comparison_operator:>; 77, 78; 77, 79; 78, identifier:t; 79, identifier:now; 80, block; 80, 81; 80, 85; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:first_valid; 84, identifier:pos; 85, break_statement; 86, if_statement; 86, 87; 86, 90; 86, 103; 87, comparison_operator:is; 87, 88; 87, 89; 88, identifier:first_valid; 89, None; 90, block; 90, 91; 90, 97; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:_token_map; 96, dictionary; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:_token_timings; 102, list:[]; 103, else_clause; 103, 104; 104, block; 104, 105; 104, 121; 105, for_statement; 105, 106; 105, 107; 105, 114; 106, identifier:k; 107, subscript; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:_token_timings; 111, slice; 111, 112; 111, 113; 112, colon; 113, identifier:first_valid; 114, block; 114, 115; 115, delete_statement; 115, 116; 116, subscript; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:_token_map; 120, identifier:k; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:_token_timings; 126, subscript; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:_token_timings; 130, slice; 130, 131; 130, 132; 131, identifier:first_valid; 132, colon; 133, if_statement; 133, 134; 133, 141; 133, 227; 134, boolean_operator:or; 134, 135; 134, 138; 135, comparison_operator:is; 135, 136; 135, 137; 136, identifier:until; 137, None; 138, comparison_operator:>; 138, 139; 138, 140; 139, identifier:until; 140, identifier:now; 141, block; 141, 142; 141, 186; 141, 219; 142, if_statement; 142, 143; 142, 148; 142, 168; 143, comparison_operator:not; 143, 144; 143, 145; 144, identifier:token; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:_token_map; 148, block; 148, 149; 148, 159; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 156; 151, subscript; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:_token_map; 155, identifier:token; 156, tuple; 156, 157; 156, 158; 157, identifier:until; 158, dictionary; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 166; 161, attribute; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:_token_timings; 165, identifier:append; 166, argument_list; 166, 167; 167, identifier:token; 168, else_clause; 168, 169; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 177; 172, subscript; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:_token_map; 176, identifier:token; 177, tuple; 177, 178; 177, 179; 178, identifier:until; 179, subscript; 179, 180; 179, 185; 180, subscript; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:self; 183, identifier:_token_map; 184, identifier:token; 185, integer:1; 186, expression_statement; 186, 187; 187, call; 187, 188; 187, 193; 188, attribute; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:_token_timings; 192, identifier:sort; 193, argument_list; 193, 194; 194, keyword_argument; 194, 195; 194, 196; 195, identifier:key; 196, lambda; 196, 197; 196, 199; 197, lambda_parameters; 197, 198; 198, identifier:k; 199, tuple; 199, 200; 199, 212; 200, conditional_expression:if; 200, 201; 200, 202; 200, 211; 201, integer:1; 202, comparison_operator:is; 202, 203; 202, 210; 203, subscript; 203, 204; 203, 209; 204, subscript; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:self; 207, identifier:_token_map; 208, identifier:k; 209, integer:0; 210, None; 211, integer:0; 212, subscript; 212, 213; 212, 218; 213, subscript; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:_token_map; 217, identifier:k; 218, integer:0; 219, return_statement; 219, 220; 220, subscript; 220, 221; 220, 226; 221, subscript; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:self; 224, identifier:_token_map; 225, identifier:token; 226, integer:1; 227, else_clause; 227, 228; 228, block; 228, 229; 228, 258; 229, if_statement; 229, 230; 229, 235; 230, comparison_operator:in; 230, 231; 230, 232; 231, identifier:token; 232, attribute; 232, 233; 232, 234; 233, identifier:self; 234, identifier:_token_map; 235, block; 235, 236; 235, 252; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:self; 240, identifier:_token_timings; 241, list_comprehension; 241, 242; 241, 243; 241, 248; 242, identifier:k; 243, for_in_clause; 243, 244; 243, 245; 244, identifier:k; 245, attribute; 245, 246; 245, 247; 246, identifier:self; 247, identifier:_token_timings; 248, if_clause; 248, 249; 249, comparison_operator:!=; 249, 250; 249, 251; 250, identifier:k; 251, identifier:token; 252, delete_statement; 252, 253; 253, subscript; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:self; 256, identifier:_token_map; 257, identifier:token; 258, return_statement; 258, 259; 259, dictionary | def get_token_obj(self, token, expire=_token_default):
if expire == _token_default:
expire = self.get_default_token_expiration()
now = get_time()
until = now + expire if expire is not None else None
with self._token_lock:
first_valid = None
for (pos, k) in enumerate(self._token_timings):
t = self._token_map[k][0]
if t is None or t > now:
first_valid = pos
break
if first_valid is None:
self._token_map = {}
self._token_timings = []
else:
for k in self._token_timings[:first_valid]:
del self._token_map[k]
self._token_timings = self._token_timings[first_valid:]
if until is None or until > now:
if token not in self._token_map:
self._token_map[token] = (until, {})
self._token_timings.append(token)
else:
self._token_map[token] = (until, self._token_map[token][1])
self._token_timings.sort(key=lambda k: (
1 if self._token_map[k][0] is None else 0,
self._token_map[k][0]
))
return self._token_map[token][1]
else:
if token in self._token_map:
self._token_timings = [
k for k in self._token_timings if k != token
]
del self._token_map[token]
return {} |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:handle_cmd; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:cmd; 6, block; 6, 7; 6, 15; 6, 19; 6, 121; 6, 132; 6, 154; 6, 161; 6, 213; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:cmd; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:cmd; 13, identifier:strip; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:segments; 18, list:[]; 19, for_statement; 19, 20; 19, 21; 19, 26; 20, identifier:s; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:cmd; 24, identifier:split; 25, argument_list; 26, block; 26, 27; 26, 109; 27, if_statement; 27, 28; 27, 31; 27, 61; 28, attribute; 28, 29; 28, 30; 29, identifier:s; 30, identifier:startswith; 31, ERROR; 31, 32; 31, 40; 31, 41; 31, 42; 31, 50; 31, 56; 32, ERROR; 32, 33; 32, 34; 33, identifier:break; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:segments; 37, identifier:append; 38, argument_list; 38, 39; 39, identifier:s; 40, identifier:args; 41, list:[]; 42, ERROR; 42, 43; 42, 48; 42, 49; 43, not_operator; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:segments; 48, identifier:segments; 49, identifier:cur_cmd; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, string:"_"; 53, identifier:join; 54, argument_list; 54, 55; 55, identifier:segments; 56, comparison_operator:in; 56, 57; 56, 58; 57, identifier:cur_cmd; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:_cmd_methods; 61, block; 61, 62; 61, 70; 61, 99; 61, 108; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:argc; 65, subscript; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:_cmd_argc; 69, identifier:cur_cmd; 70, if_statement; 70, 71; 70, 81; 71, boolean_operator:and; 71, 72; 71, 75; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:argc; 74, None; 75, comparison_operator:!=; 75, 76; 75, 80; 76, call; 76, 77; 76, 78; 77, identifier:len; 78, argument_list; 78, 79; 79, identifier:args; 80, identifier:argc; 81, block; 81, 82; 81, 98; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:msg; 85, argument_list; 85, 86; 85, 87; 85, 93; 85, 94; 86, string:'command {0} expects {1} argument(s), got {2}'; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, string:" "; 90, identifier:join; 91, argument_list; 91, 92; 92, identifier:segments; 93, identifier:argc; 94, call; 94, 95; 94, 96; 95, identifier:len; 96, argument_list; 96, 97; 97, identifier:args; 98, return_statement; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 106; 101, subscript; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:_cmd_methods; 105, identifier:cur_cmd; 106, argument_list; 106, 107; 107, identifier:args; 108, return_statement; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:args; 113, identifier:insert; 114, argument_list; 114, 115; 114, 116; 115, integer:0; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:segments; 119, identifier:pop; 120, argument_list; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:prefix; 124, binary_operator:+; 124, 125; 124, 131; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, string:'_'; 128, identifier:join; 129, argument_list; 129, 130; 130, identifier:args; 131, string:'_'; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 135; 134, identifier:matches; 135, call; 135, 136; 135, 137; 136, identifier:filter; 137, argument_list; 137, 138; 137, 147; 138, lambda; 138, 139; 138, 141; 139, lambda_parameters; 139, 140; 140, identifier:cmd; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:cmd; 144, identifier:startswith; 145, argument_list; 145, 146; 146, identifier:prefix; 147, call; 147, 148; 147, 153; 148, attribute; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:_cmd_methods; 152, identifier:keys; 153, argument_list; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:candidates; 157, call; 157, 158; 157, 159; 158, identifier:set; 159, argument_list; 159, 160; 160, list:[]; 161, for_statement; 161, 162; 161, 163; 161, 164; 162, identifier:m; 163, identifier:matches; 164, block; 164, 165; 164, 177; 164, 188; 164, 206; 165, if_statement; 165, 166; 165, 175; 166, comparison_operator:<=; 166, 167; 166, 171; 167, call; 167, 168; 167, 169; 168, identifier:len; 169, argument_list; 169, 170; 170, identifier:m; 171, call; 171, 172; 171, 173; 172, identifier:len; 173, argument_list; 173, 174; 174, identifier:prefix; 175, block; 175, 176; 176, continue_statement; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:m; 180, subscript; 180, 181; 180, 182; 181, identifier:m; 182, slice; 182, 183; 182, 187; 183, call; 183, 184; 183, 185; 184, identifier:len; 185, argument_list; 185, 186; 186, identifier:prefix; 187, colon; 188, if_statement; 188, 189; 188, 192; 189, comparison_operator:in; 189, 190; 189, 191; 190, string:'_'; 191, identifier:m; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:m; 196, subscript; 196, 197; 196, 198; 197, identifier:m; 198, slice; 198, 199; 198, 200; 199, colon; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:m; 203, identifier:index; 204, argument_list; 204, 205; 205, string:'_'; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:candidates; 210, identifier:add; 211, argument_list; 211, 212; 212, identifier:m; 213, if_statement; 213, 214; 213, 218; 213, 240; 214, call; 214, 215; 214, 216; 215, identifier:len; 216, argument_list; 216, 217; 217, identifier:candidates; 218, block; 218, 219; 218, 230; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 222; 221, identifier:msg; 222, argument_list; 222, 223; 222, 224; 223, string:'command "{0}" needs more arguments:'; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, string:' '; 227, identifier:join; 228, argument_list; 228, 229; 229, identifier:args; 230, for_statement; 230, 231; 230, 232; 230, 233; 231, identifier:c; 232, identifier:candidates; 233, block; 233, 234; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 237; 236, identifier:msg; 237, argument_list; 237, 238; 237, 239; 238, string:' {0}'; 239, identifier:c; 240, else_clause; 240, 241; 241, block; 241, 242; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 245; 244, identifier:msg; 245, argument_list; 245, 246; 245, 249; 246, binary_operator:+; 246, 247; 246, 248; 247, string:'command "{0}" invalid; type '; 248, string:'help or use <TAB> for a list of commands'; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, string:' '; 252, identifier:join; 253, argument_list; 253, 254; 254, identifier:args | def handle_cmd(self, cmd):
cmd = cmd.strip()
segments = []
for s in cmd.split():
if s.startswith('
break
segments.append(s)
args = []
if not len(segments):
return
while segments:
cur_cmd = "_".join(segments)
if cur_cmd in self._cmd_methods:
argc = self._cmd_argc[cur_cmd]
if argc is not None and len(args) != argc:
msg('command {0} expects {1} argument(s), got {2}',
" ".join(segments), argc, len(args))
return
self._cmd_methods[cur_cmd](args)
return
args.insert(0, segments.pop())
prefix = '_'.join(args) + '_'
matches = filter(
lambda cmd: cmd.startswith(prefix), self._cmd_methods.keys())
candidates = set([])
for m in matches:
if len(m) <= len(prefix):
continue
m = m[len(prefix):]
if '_' in m:
m = m[:m.index('_')]
candidates.add(m)
if len(candidates):
msg('command "{0}" needs more arguments:', ' '.join(args))
for c in candidates:
msg(' {0}', c)
else:
msg('command "{0}" invalid; type ' +
'help or use <TAB> for a list of commands',
' '.join(args)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:handle_request; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 16; 5, 44; 5, 50; 5, 54; 5, 60; 5, 79; 5, 172; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:timeout; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:socket; 14, identifier:gettimeout; 15, argument_list; 16, if_statement; 16, 17; 16, 20; 16, 27; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:timeout; 19, None; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:timeout; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:timeout; 27, elif_clause; 27, 28; 27, 33; 28, comparison_operator:is; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:timeout; 32, None; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:timeout; 37, call; 37, 38; 37, 39; 38, identifier:min; 39, argument_list; 39, 40; 39, 41; 40, identifier:timeout; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:timeout; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:ctime; 47, call; 47, 48; 47, 49; 48, identifier:get_time; 49, argument_list; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:done_req; 53, False; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:shutdown_latency; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:shutdown_latency; 60, if_statement; 60, 61; 60, 64; 61, comparison_operator:is; 61, 62; 61, 63; 62, identifier:timeout; 63, None; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:shutdown_latency; 68, conditional_expression:if; 68, 69; 68, 74; 68, 75; 68, 78; 69, call; 69, 70; 69, 71; 70, identifier:min; 71, argument_list; 71, 72; 71, 73; 72, identifier:shutdown_latency; 73, identifier:timeout; 74, line_continuation:\; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:shutdown_latency; 77, None; 78, identifier:timeout; 79, while_statement; 79, 80; 79, 105; 80, boolean_operator:and; 80, 81; 80, 88; 81, not_operator; 81, 82; 82, parenthesized_expression; 82, 83; 83, boolean_operator:or; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:done; 87, identifier:done_req; 88, parenthesized_expression; 88, 89; 89, boolean_operator:or; 89, 90; 89, 97; 90, boolean_operator:or; 90, 91; 90, 94; 91, comparison_operator:is; 91, 92; 91, 93; 92, identifier:timeout; 93, None; 94, comparison_operator:==; 94, 95; 94, 96; 95, identifier:timeout; 96, integer:0; 97, comparison_operator:<; 97, 98; 97, 104; 98, parenthesized_expression; 98, 99; 99, binary_operator:-; 99, 100; 99, 103; 100, call; 100, 101; 100, 102; 101, identifier:get_time; 102, argument_list; 103, identifier:ctime; 104, identifier:timeout; 105, block; 105, 106; 105, 150; 105, 166; 106, try_statement; 106, 107; 106, 121; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:fd_sets; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:select; 114, identifier:select; 115, argument_list; 115, 116; 115, 118; 115, 119; 115, 120; 116, list:[self]; 116, 117; 117, identifier:self; 118, list:[]; 119, list:[]; 120, identifier:shutdown_latency; 121, except_clause; 121, 122; 121, 130; 122, as_pattern; 122, 123; 122, 128; 123, tuple; 123, 124; 123, 125; 124, identifier:OSError; 125, attribute; 125, 126; 125, 127; 126, identifier:select; 127, identifier:error; 128, as_pattern_target; 128, 129; 129, identifier:e; 130, block; 130, 131; 130, 143; 131, if_statement; 131, 132; 131, 141; 132, comparison_operator:!=; 132, 133; 132, 138; 133, subscript; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:e; 136, identifier:args; 137, integer:0; 138, attribute; 138, 139; 138, 140; 139, identifier:errno; 140, identifier:EINTR; 141, block; 141, 142; 142, raise_statement; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:fd_sets; 146, list:[[], [], []]; 146, 147; 146, 148; 146, 149; 147, list:[]; 148, list:[]; 149, list:[]; 150, for_statement; 150, 151; 150, 152; 150, 155; 151, identifier:_fd; 152, subscript; 152, 153; 152, 154; 153, identifier:fd_sets; 154, integer:0; 155, block; 155, 156; 155, 160; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:done_req; 159, True; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:_handle_request_noblock; 165, argument_list; 166, if_statement; 166, 167; 166, 170; 167, comparison_operator:==; 167, 168; 167, 169; 168, identifier:timeout; 169, integer:0; 170, block; 170, 171; 171, break_statement; 172, if_statement; 172, 173; 172, 180; 173, not_operator; 173, 174; 174, parenthesized_expression; 174, 175; 175, boolean_operator:or; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:done; 179, identifier:done_req; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:handle_timeout; 186, argument_list | def handle_request(self):
timeout = self.socket.gettimeout()
if timeout is None:
timeout = self.timeout
elif self.timeout is not None:
timeout = min(timeout, self.timeout)
ctime = get_time()
done_req = False
shutdown_latency = self.shutdown_latency
if timeout is not None:
shutdown_latency = min(shutdown_latency, timeout) \
if shutdown_latency is not None else timeout
while not (self.done or done_req) and (timeout is None or
timeout == 0 or
(get_time() - ctime) < timeout):
try:
fd_sets = select.select([self], [], [], shutdown_latency)
except (OSError, select.error) as e:
if e.args[0] != errno.EINTR:
raise
fd_sets = [[], [], []]
for _fd in fd_sets[0]:
done_req = True
self._handle_request_noblock()
if timeout == 0:
break
if not (self.done or done_req):
self.handle_timeout() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:info_gain_nominal; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:x; 5, identifier:y; 6, identifier:separate_max; 7, block; 7, 8; 7, 17; 7, 27; 7, 34; 7, 45; 7, 58; 7, 96; 7, 105; 7, 115; 7, 311; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:x_vals; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:np; 14, identifier:unique; 15, argument_list; 15, 16; 16, identifier:x; 17, if_statement; 17, 18; 17, 24; 18, comparison_operator:<; 18, 19; 18, 23; 19, call; 19, 20; 19, 21; 20, identifier:len; 21, argument_list; 21, 22; 22, identifier:x_vals; 23, integer:3; 24, block; 24, 25; 25, return_statement; 25, 26; 26, None; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:y_dist; 30, call; 30, 31; 30, 32; 31, identifier:Counter; 32, argument_list; 32, 33; 33, identifier:y; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:h_y; 37, call; 37, 38; 37, 39; 38, identifier:h; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:y_dist; 43, identifier:values; 44, argument_list; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, pattern_list; 47, 48; 47, 49; 48, identifier:dist; 49, identifier:splits; 50, call; 50, 51; 50, 52; 51, identifier:nominal_splits; 52, argument_list; 52, 53; 52, 54; 52, 55; 52, 56; 52, 57; 53, identifier:x; 54, identifier:y; 55, identifier:x_vals; 56, identifier:y_dist; 57, identifier:separate_max; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 63; 60, pattern_list; 60, 61; 60, 62; 61, identifier:indices; 62, identifier:repeat; 63, conditional_expression:if; 63, 64; 63, 74; 63, 80; 64, tuple; 64, 65; 64, 73; 65, call; 65, 66; 65, 67; 66, identifier:range; 67, argument_list; 67, 68; 67, 69; 68, integer:1; 69, call; 69, 70; 69, 71; 70, identifier:len; 71, argument_list; 71, 72; 72, identifier:dist; 73, integer:1; 74, comparison_operator:<; 74, 75; 74, 79; 75, call; 75, 76; 75, 77; 76, identifier:len; 77, argument_list; 77, 78; 78, identifier:dist; 79, integer:50; 80, tuple; 80, 81; 80, 95; 81, call; 81, 82; 81, 83; 82, identifier:range; 83, argument_list; 83, 84; 83, 85; 83, 89; 84, integer:1; 85, call; 85, 86; 85, 87; 86, identifier:len; 87, argument_list; 87, 88; 88, identifier:dist; 89, binary_operator:/; 89, 90; 89, 94; 90, call; 90, 91; 90, 92; 91, identifier:len; 92, argument_list; 92, 93; 93, identifier:dist; 94, integer:10; 95, integer:3; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:interval; 99, binary_operator:/; 99, 100; 99, 104; 100, call; 100, 101; 100, 102; 101, identifier:len; 102, argument_list; 102, 103; 103, identifier:dist; 104, integer:10; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 111; 107, pattern_list; 107, 108; 107, 109; 107, 110; 108, identifier:max_ig; 109, identifier:max_i; 110, identifier:iteration; 111, expression_list; 111, 112; 111, 113; 111, 114; 112, integer:0; 113, integer:1; 114, integer:0; 115, while_statement; 115, 116; 115, 119; 116, comparison_operator:<; 116, 117; 116, 118; 117, identifier:iteration; 118, identifier:repeat; 119, block; 119, 120; 119, 232; 119, 236; 120, for_statement; 120, 121; 120, 122; 120, 123; 121, identifier:i; 122, identifier:indices; 123, block; 123, 124; 123, 141; 123, 158; 123, 191; 123, 219; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:dist0; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:np; 130, identifier:sum; 131, argument_list; 131, 132; 132, list_comprehension; 132, 133; 132, 134; 133, identifier:el; 134, for_in_clause; 134, 135; 134, 136; 135, identifier:el; 136, subscript; 136, 137; 136, 138; 137, identifier:dist; 138, slice; 138, 139; 138, 140; 139, colon; 140, identifier:i; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:dist1; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:np; 147, identifier:sum; 148, argument_list; 148, 149; 149, list_comprehension; 149, 150; 149, 151; 150, identifier:el; 151, for_in_clause; 151, 152; 151, 153; 152, identifier:el; 153, subscript; 153, 154; 153, 155; 154, identifier:dist; 155, slice; 155, 156; 155, 157; 156, identifier:i; 157, colon; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:coef; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:np; 164, identifier:true_divide; 165, argument_list; 165, 166; 165, 187; 166, list:[np.sum(dist0.values()), np.sum(dist1.values())]; 166, 167; 166, 177; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:np; 170, identifier:sum; 171, argument_list; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:dist0; 175, identifier:values; 176, argument_list; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:np; 180, identifier:sum; 181, argument_list; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:dist1; 185, identifier:values; 186, argument_list; 187, call; 187, 188; 187, 189; 188, identifier:len; 189, argument_list; 189, 190; 190, identifier:y; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:ig; 194, binary_operator:-; 194, 195; 194, 196; 195, identifier:h_y; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:np; 199, identifier:dot; 200, argument_list; 200, 201; 200, 202; 201, identifier:coef; 202, list:[h(dist0.values()), h(dist1.values())]; 202, 203; 202, 211; 203, call; 203, 204; 203, 205; 204, identifier:h; 205, argument_list; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:dist0; 209, identifier:values; 210, argument_list; 211, call; 211, 212; 211, 213; 212, identifier:h; 213, argument_list; 213, 214; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:dist1; 217, identifier:values; 218, argument_list; 219, if_statement; 219, 220; 219, 223; 220, comparison_operator:>; 220, 221; 220, 222; 221, identifier:ig; 222, identifier:max_ig; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 229; 226, pattern_list; 226, 227; 226, 228; 227, identifier:max_ig; 228, identifier:max_i; 229, expression_list; 229, 230; 229, 231; 230, identifier:ig; 231, identifier:i; 232, expression_statement; 232, 233; 233, augmented_assignment:+=; 233, 234; 233, 235; 234, identifier:iteration; 235, integer:1; 236, if_statement; 236, 237; 236, 240; 237, comparison_operator:>; 237, 238; 237, 239; 238, identifier:repeat; 239, integer:1; 240, block; 240, 241; 240, 250; 240, 271; 240, 282; 240, 298; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:interval; 244, call; 244, 245; 244, 246; 245, identifier:int; 246, argument_list; 246, 247; 247, binary_operator:*; 247, 248; 247, 249; 248, identifier:interval; 249, float:0.5; 250, if_statement; 250, 251; 250, 258; 250, 268; 251, boolean_operator:and; 251, 252; 251, 255; 252, comparison_operator:in; 252, 253; 252, 254; 253, identifier:max_i; 254, identifier:indices; 255, comparison_operator:>; 255, 256; 255, 257; 256, identifier:interval; 257, integer:0; 258, block; 258, 259; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:middle_index; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:indices; 265, identifier:index; 266, argument_list; 266, 267; 267, identifier:max_i; 268, else_clause; 268, 269; 269, block; 269, 270; 270, break_statement; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:min_index; 274, conditional_expression:if; 274, 275; 274, 276; 274, 279; 275, identifier:middle_index; 276, comparison_operator:==; 276, 277; 276, 278; 277, identifier:middle_index; 278, integer:0; 279, binary_operator:-; 279, 280; 279, 281; 280, identifier:middle_index; 281, integer:1; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 285; 284, identifier:max_index; 285, conditional_expression:if; 285, 286; 285, 287; 285, 295; 286, identifier:middle_index; 287, comparison_operator:==; 287, 288; 287, 289; 288, identifier:middle_index; 289, binary_operator:-; 289, 290; 289, 294; 290, call; 290, 291; 290, 292; 291, identifier:len; 292, argument_list; 292, 293; 293, identifier:indices; 294, integer:1; 295, binary_operator:+; 295, 296; 295, 297; 296, identifier:middle_index; 297, integer:1; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 301; 300, identifier:indices; 301, call; 301, 302; 301, 303; 302, identifier:range; 303, argument_list; 303, 304; 303, 307; 303, 310; 304, subscript; 304, 305; 304, 306; 305, identifier:indices; 306, identifier:min_index; 307, subscript; 307, 308; 307, 309; 308, identifier:indices; 309, identifier:max_index; 310, identifier:interval; 311, return_statement; 311, 312; 312, expression_list; 312, 313; 312, 317; 313, call; 313, 314; 313, 315; 314, identifier:float; 315, argument_list; 315, 316; 316, identifier:max_ig; 317, list:[splits[:max_i], splits[max_i:]]; 317, 318; 317, 323; 318, subscript; 318, 319; 318, 320; 319, identifier:splits; 320, slice; 320, 321; 320, 322; 321, colon; 322, identifier:max_i; 323, subscript; 323, 324; 323, 325; 324, identifier:splits; 325, slice; 325, 326; 325, 327; 326, identifier:max_i; 327, colon | def info_gain_nominal(x, y, separate_max):
x_vals = np.unique(x)
if len(x_vals) < 3:
return None
y_dist = Counter(y)
h_y = h(y_dist.values())
dist, splits = nominal_splits(x, y, x_vals, y_dist, separate_max)
indices, repeat = (range(1, len(dist)), 1) if len(dist) < 50 else (range(1, len(dist), len(dist) / 10), 3)
interval = len(dist) / 10
max_ig, max_i, iteration = 0, 1, 0
while iteration < repeat:
for i in indices:
dist0 = np.sum([el for el in dist[:i]])
dist1 = np.sum([el for el in dist[i:]])
coef = np.true_divide([np.sum(dist0.values()), np.sum(dist1.values())], len(y))
ig = h_y - np.dot(coef, [h(dist0.values()), h(dist1.values())])
if ig > max_ig:
max_ig, max_i = ig, i
iteration += 1
if repeat > 1:
interval = int(interval * 0.5)
if max_i in indices and interval > 0:
middle_index = indices.index(max_i)
else:
break
min_index = middle_index if middle_index == 0 else middle_index - 1
max_index = middle_index if middle_index == len(indices) - 1 else middle_index + 1
indices = range(indices[min_index], indices[max_index], interval)
return float(max_ig), [splits[:max_i], splits[max_i:]] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_endpoints_using_catalog_api; 3, parameters; 3, 4; 3, 5; 4, identifier:domain; 5, identifier:token; 6, block; 6, 7; 6, 14; 6, 18; 6, 22; 6, 28; 6, 32; 6, 156; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:headers; 10, dictionary; 10, 11; 11, pair; 11, 12; 11, 13; 12, string:"X-App-Token"; 13, identifier:token; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:uri; 17, string:"http://api.us.socrata.com/api/catalog/v1?domains={0}&offset={1}&limit=1000"; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:ret; 21, list:[]; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:endpoints_thus_far; 25, call; 25, 26; 25, 27; 26, identifier:set; 27, argument_list; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:offset; 31, integer:0; 32, while_statement; 32, 33; 32, 34; 33, True; 34, block; 34, 35; 34, 78; 34, 86; 34, 100; 34, 109; 35, try_statement; 35, 36; 35, 61; 36, block; 36, 37; 36, 55; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:r; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:requests; 43, identifier:get; 44, argument_list; 44, 45; 44, 52; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:uri; 48, identifier:format; 49, argument_list; 49, 50; 49, 51; 50, identifier:domain; 51, identifier:offset; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:headers; 54, identifier:headers; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:r; 59, identifier:raise_for_status; 60, argument_list; 61, except_clause; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:requests; 64, identifier:HTTPError; 65, block; 65, 66; 66, raise_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:requests; 70, identifier:HTTPError; 71, argument_list; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, string:"An HTTP error was raised during Socrata API ingestion."; 75, identifier:format; 76, argument_list; 76, 77; 77, identifier:domain; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:data; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:r; 84, identifier:json; 85, argument_list; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:endpoints_returned; 89, set_comprehension; 89, 90; 89, 95; 90, subscript; 90, 91; 90, 94; 91, subscript; 91, 92; 91, 93; 92, identifier:r; 93, string:'resource'; 94, string:'id'; 95, for_in_clause; 95, 96; 95, 97; 96, identifier:r; 97, subscript; 97, 98; 97, 99; 98, identifier:data; 99, string:'results'; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:new_endpoints; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:endpoints_returned; 106, identifier:difference; 107, argument_list; 107, 108; 108, identifier:endpoints_thus_far; 109, if_statement; 109, 110; 109, 116; 109, 135; 110, comparison_operator:>=; 110, 111; 110, 115; 111, call; 111, 112; 111, 113; 112, identifier:len; 113, argument_list; 113, 114; 114, identifier:new_endpoints; 115, integer:999; 116, block; 116, 117; 116, 123; 116, 130; 116, 134; 117, expression_statement; 117, 118; 118, augmented_assignment:+=; 118, 119; 118, 120; 119, identifier:ret; 120, subscript; 120, 121; 120, 122; 121, identifier:data; 122, string:'results'; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:endpoints_thus_far; 127, identifier:update; 128, argument_list; 128, 129; 129, identifier:new_endpoints; 130, expression_statement; 130, 131; 131, augmented_assignment:+=; 131, 132; 131, 133; 132, identifier:offset; 133, integer:1000; 134, continue_statement; 135, else_clause; 135, 136; 136, block; 136, 137; 136, 155; 137, expression_statement; 137, 138; 138, augmented_assignment:+=; 138, 139; 138, 140; 139, identifier:ret; 140, list_comprehension; 140, 141; 140, 142; 140, 147; 141, identifier:r; 142, for_in_clause; 142, 143; 142, 144; 143, identifier:r; 144, subscript; 144, 145; 144, 146; 145, identifier:data; 146, string:'results'; 147, if_clause; 147, 148; 148, comparison_operator:in; 148, 149; 148, 154; 149, subscript; 149, 150; 149, 153; 150, subscript; 150, 151; 150, 152; 151, identifier:r; 152, string:'resource'; 153, string:'id'; 154, identifier:new_endpoints; 155, break_statement; 156, return_statement; 156, 157; 157, identifier:ret | def get_endpoints_using_catalog_api(domain, token):
headers = {"X-App-Token": token}
uri = "http://api.us.socrata.com/api/catalog/v1?domains={0}&offset={1}&limit=1000"
ret = []
endpoints_thus_far = set()
offset = 0
while True:
try:
r = requests.get(uri.format(domain, offset), headers=headers)
r.raise_for_status()
except requests.HTTPError:
raise requests.HTTPError("An HTTP error was raised during Socrata API ingestion.".format(domain))
data = r.json()
endpoints_returned = {r['resource']['id'] for r in data['results']}
new_endpoints = endpoints_returned.difference(endpoints_thus_far)
if len(new_endpoints) >= 999:
ret += data['results']
endpoints_thus_far.update(new_endpoints)
offset += 1000
continue
else:
ret += [r for r in data['results'] if r['resource']['id'] in new_endpoints]
break
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:stratify_by_scores; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:scores; 5, default_parameter; 5, 6; 5, 7; 6, identifier:goal_n_strata; 7, string:'auto'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:method; 10, string:'cum_sqrt_F'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:n_bins; 13, string:'auto'; 14, block; 14, 15; 14, 21; 14, 31; 14, 174; 14, 280; 14, 470; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:available_methods; 18, list:['equal_size', 'cum_sqrt_F']; 18, 19; 18, 20; 19, string:'equal_size'; 20, string:'cum_sqrt_F'; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:not; 22, 23; 22, 24; 23, identifier:method; 24, identifier:available_methods; 25, block; 25, 26; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:ValueError; 29, argument_list; 29, 30; 30, string:"method argument is invalid"; 31, if_statement; 31, 32; 31, 41; 32, boolean_operator:or; 32, 33; 32, 37; 33, parenthesized_expression; 33, 34; 34, comparison_operator:==; 34, 35; 34, 36; 35, identifier:method; 36, string:'cum_sqrt_F'; 37, parenthesized_expression; 37, 38; 38, comparison_operator:==; 38, 39; 38, 40; 39, identifier:goal_n_strata; 40, string:'auto'; 41, block; 41, 42; 41, 85; 41, 99; 41, 108; 41, 117; 42, if_statement; 42, 43; 42, 46; 43, comparison_operator:==; 43, 44; 43, 45; 44, identifier:n_bins; 45, string:'auto'; 46, block; 46, 47; 46, 54; 46, 75; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:width_score; 50, call; 50, 51; 50, 52; 51, identifier:_heuristic_bin_width; 52, argument_list; 52, 53; 53, identifier:scores; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:n_bins; 57, call; 57, 58; 57, 73; 58, attribute; 58, 59; 58, 72; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:np; 62, identifier:ceil; 63, argument_list; 63, 64; 64, binary_operator:/; 64, 65; 64, 71; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:sp; 68, identifier:ptp; 69, argument_list; 69, 70; 70, identifier:scores; 71, identifier:width_score; 72, identifier:astype; 73, argument_list; 73, 74; 74, identifier:int; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:print; 78, argument_list; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, string:"Automatically setting n_bins = {}."; 82, identifier:format; 83, argument_list; 83, 84; 84, identifier:n_bins; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 90; 87, pattern_list; 87, 88; 87, 89; 88, identifier:counts; 89, identifier:score_bins; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:np; 93, identifier:histogram; 94, argument_list; 94, 95; 94, 96; 95, identifier:scores; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:bins; 98, identifier:n_bins; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:sqrt_counts; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:np; 105, identifier:sqrt; 106, argument_list; 106, 107; 107, identifier:counts; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:csf; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:np; 114, identifier:cumsum; 115, argument_list; 115, 116; 116, identifier:sqrt_counts; 117, if_statement; 117, 118; 117, 121; 117, 160; 118, comparison_operator:==; 118, 119; 118, 120; 119, identifier:goal_n_strata; 120, string:'auto'; 121, block; 121, 122; 121, 129; 121, 150; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:width_csf; 125, call; 125, 126; 125, 127; 126, identifier:_heuristic_bin_width; 127, argument_list; 127, 128; 128, identifier:csf; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:goal_n_strata; 132, call; 132, 133; 132, 148; 133, attribute; 133, 134; 133, 147; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:np; 137, identifier:ceil; 138, argument_list; 138, 139; 139, binary_operator:/; 139, 140; 139, 146; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:sp; 143, identifier:ptp; 144, argument_list; 144, 145; 145, identifier:csf; 146, identifier:width_csf; 147, identifier:astype; 148, argument_list; 148, 149; 149, identifier:int; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 153; 152, identifier:print; 153, argument_list; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, string:"Automatically setting goal_n_strata = {}."; 157, identifier:format; 158, argument_list; 158, 159; 159, identifier:goal_n_strata; 160, elif_clause; 160, 161; 160, 164; 161, comparison_operator:==; 161, 162; 161, 163; 162, identifier:method; 163, string:'cum_sqrt_F'; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:width_csf; 168, binary_operator:/; 168, 169; 168, 173; 169, subscript; 169, 170; 169, 171; 170, identifier:csf; 171, unary_operator:-; 171, 172; 172, integer:1; 173, identifier:goal_n_strata; 174, if_statement; 174, 175; 174, 178; 175, comparison_operator:==; 175, 176; 175, 177; 176, identifier:method; 177, string:'equal_size'; 178, block; 178, 179; 178, 187; 178, 194; 178, 200; 178, 206; 178, 218; 178, 229; 178, 242; 178, 246; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:sorted_ids; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:scores; 185, identifier:argsort; 186, argument_list; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:n_items; 190, call; 190, 191; 190, 192; 191, identifier:len; 192, argument_list; 192, 193; 193, identifier:sorted_ids; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:quotient; 197, binary_operator://; 197, 198; 197, 199; 198, identifier:n_items; 199, identifier:goal_n_strata; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:remainder; 203, binary_operator:%; 203, 204; 203, 205; 204, identifier:n_items; 205, identifier:goal_n_strata; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:allocations; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:np; 212, identifier:empty; 213, argument_list; 213, 214; 213, 215; 214, identifier:n_items; 215, keyword_argument; 215, 216; 215, 217; 216, identifier:dtype; 217, string:'int'; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:st_pops; 221, list_comprehension; 221, 222; 221, 223; 222, identifier:quotient; 223, for_in_clause; 223, 224; 223, 225; 224, identifier:i; 225, call; 225, 226; 225, 227; 226, identifier:range; 227, argument_list; 227, 228; 228, identifier:goal_n_strata; 229, for_statement; 229, 230; 229, 231; 229, 235; 230, identifier:i; 231, call; 231, 232; 231, 233; 232, identifier:range; 233, argument_list; 233, 234; 234, identifier:remainder; 235, block; 235, 236; 236, expression_statement; 236, 237; 237, augmented_assignment:+=; 237, 238; 237, 241; 238, subscript; 238, 239; 238, 240; 239, identifier:st_pops; 240, identifier:i; 241, integer:1; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:j; 245, integer:0; 246, for_statement; 246, 247; 246, 250; 246, 254; 247, pattern_list; 247, 248; 247, 249; 248, identifier:k; 249, identifier:nk; 250, call; 250, 251; 250, 252; 251, identifier:enumerate; 252, argument_list; 252, 253; 253, identifier:st_pops; 254, block; 254, 255; 254, 259; 254, 265; 254, 276; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:start; 258, identifier:j; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:end; 262, binary_operator:+; 262, 263; 262, 264; 263, identifier:j; 264, identifier:nk; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 275; 267, subscript; 267, 268; 267, 269; 268, identifier:allocations; 269, subscript; 269, 270; 269, 271; 270, identifier:sorted_ids; 271, slice; 271, 272; 271, 273; 271, 274; 272, identifier:start; 273, colon; 274, identifier:end; 275, identifier:k; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:j; 279, identifier:end; 280, if_statement; 280, 281; 280, 284; 281, comparison_operator:==; 281, 282; 281, 283; 282, identifier:method; 283, string:'cum_sqrt_F'; 284, block; 284, 285; 284, 299; 284, 316; 284, 320; 284, 324; 284, 385; 284, 391; 284, 398; 284, 415; 284, 424; 284, 431; 284, 440; 284, 453; 285, if_statement; 285, 286; 285, 289; 286, comparison_operator:>; 286, 287; 286, 288; 287, identifier:goal_n_strata; 288, identifier:n_bins; 289, block; 289, 290; 290, expression_statement; 290, 291; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:warnings; 294, identifier:warn; 295, argument_list; 295, 296; 296, concatenated_string; 296, 297; 296, 298; 297, string:"goal_n_strata > n_bins. "; 298, string:"Consider increasing n_bins."; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:csf_bins; 302, list_comprehension; 302, 303; 302, 306; 303, binary_operator:*; 303, 304; 303, 305; 304, identifier:x; 305, identifier:width_csf; 306, for_in_clause; 306, 307; 306, 308; 307, identifier:x; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:np; 311, identifier:arange; 312, argument_list; 312, 313; 313, binary_operator:+; 313, 314; 313, 315; 314, identifier:goal_n_strata; 315, integer:1; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 319; 318, identifier:j; 319, integer:0; 320, expression_statement; 320, 321; 321, assignment; 321, 322; 321, 323; 322, identifier:new_bins; 323, list:[]; 324, for_statement; 324, 325; 324, 328; 324, 332; 325, tuple_pattern; 325, 326; 325, 327; 326, identifier:idx; 327, identifier:value; 328, call; 328, 329; 328, 330; 329, identifier:enumerate; 330, argument_list; 330, 331; 331, identifier:csf; 332, block; 332, 333; 332, 365; 333, if_statement; 333, 334; 333, 353; 334, boolean_operator:or; 334, 335; 334, 344; 335, comparison_operator:==; 335, 336; 335, 337; 336, identifier:j; 337, parenthesized_expression; 337, 338; 338, binary_operator:-; 338, 339; 338, 343; 339, call; 339, 340; 339, 341; 340, identifier:len; 341, argument_list; 341, 342; 342, identifier:csf_bins; 343, integer:1; 344, comparison_operator:==; 344, 345; 344, 346; 345, identifier:idx; 346, parenthesized_expression; 346, 347; 347, binary_operator:-; 347, 348; 347, 352; 348, call; 348, 349; 348, 350; 349, identifier:len; 350, argument_list; 350, 351; 351, identifier:csf; 352, integer:1; 353, block; 353, 354; 353, 364; 354, expression_statement; 354, 355; 355, call; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, identifier:new_bins; 358, identifier:append; 359, argument_list; 359, 360; 360, subscript; 360, 361; 360, 362; 361, identifier:score_bins; 362, unary_operator:-; 362, 363; 363, integer:1; 364, break_statement; 365, if_statement; 365, 366; 365, 371; 366, comparison_operator:>=; 366, 367; 366, 368; 367, identifier:value; 368, subscript; 368, 369; 368, 370; 369, identifier:csf_bins; 370, identifier:j; 371, block; 371, 372; 371, 381; 372, expression_statement; 372, 373; 373, call; 373, 374; 373, 377; 374, attribute; 374, 375; 374, 376; 375, identifier:new_bins; 376, identifier:append; 377, argument_list; 377, 378; 378, subscript; 378, 379; 378, 380; 379, identifier:score_bins; 380, identifier:idx; 381, expression_statement; 381, 382; 382, augmented_assignment:+=; 382, 383; 382, 384; 383, identifier:j; 384, integer:1; 385, expression_statement; 385, 386; 386, augmented_assignment:-=; 386, 387; 386, 390; 387, subscript; 387, 388; 387, 389; 388, identifier:new_bins; 389, integer:0; 390, float:0.01; 391, expression_statement; 391, 392; 392, augmented_assignment:+=; 392, 393; 392, 397; 393, subscript; 393, 394; 393, 395; 394, identifier:new_bins; 395, unary_operator:-; 395, 396; 396, integer:1; 397, float:0.01; 398, expression_statement; 398, 399; 399, assignment; 399, 400; 399, 401; 400, identifier:allocations; 401, binary_operator:-; 401, 402; 401, 414; 402, call; 402, 403; 402, 406; 403, attribute; 403, 404; 403, 405; 404, identifier:np; 405, identifier:digitize; 406, argument_list; 406, 407; 406, 408; 406, 411; 407, identifier:scores; 408, keyword_argument; 408, 409; 408, 410; 409, identifier:bins; 410, identifier:new_bins; 411, keyword_argument; 411, 412; 411, 413; 412, identifier:right; 413, True; 414, integer:1; 415, expression_statement; 415, 416; 416, assignment; 416, 417; 416, 418; 417, identifier:nonempty_ids; 418, call; 418, 419; 418, 422; 419, attribute; 419, 420; 419, 421; 420, identifier:np; 421, identifier:unique; 422, argument_list; 422, 423; 423, identifier:allocations; 424, expression_statement; 424, 425; 425, assignment; 425, 426; 425, 427; 426, identifier:n_strata; 427, call; 427, 428; 427, 429; 428, identifier:len; 429, argument_list; 429, 430; 430, identifier:nonempty_ids; 431, expression_statement; 431, 432; 432, assignment; 432, 433; 432, 434; 433, identifier:indices; 434, call; 434, 435; 434, 438; 435, attribute; 435, 436; 435, 437; 436, identifier:np; 437, identifier:arange; 438, argument_list; 438, 439; 439, identifier:n_strata; 440, expression_statement; 440, 441; 441, assignment; 441, 442; 441, 443; 442, identifier:allocations; 443, call; 443, 444; 443, 447; 444, attribute; 444, 445; 444, 446; 445, identifier:np; 446, identifier:digitize; 447, argument_list; 447, 448; 447, 449; 447, 450; 448, identifier:allocations; 449, identifier:nonempty_ids; 450, keyword_argument; 450, 451; 450, 452; 451, identifier:right; 452, True; 453, if_statement; 453, 454; 453, 457; 454, comparison_operator:<; 454, 455; 454, 456; 455, identifier:n_strata; 456, identifier:goal_n_strata; 457, block; 457, 458; 458, expression_statement; 458, 459; 459, call; 459, 460; 459, 463; 460, attribute; 460, 461; 460, 462; 461, identifier:warnings; 462, identifier:warn; 463, argument_list; 463, 464; 464, call; 464, 465; 464, 468; 465, attribute; 465, 466; 465, 467; 466, string:"Failed to create {} strata"; 467, identifier:format; 468, argument_list; 468, 469; 469, identifier:goal_n_strata; 470, return_statement; 470, 471; 471, call; 471, 472; 471, 473; 472, identifier:Strata; 473, argument_list; 473, 474; 474, identifier:allocations | def stratify_by_scores(scores, goal_n_strata='auto', method='cum_sqrt_F',
n_bins = 'auto'):
available_methods = ['equal_size', 'cum_sqrt_F']
if method not in available_methods:
raise ValueError("method argument is invalid")
if (method == 'cum_sqrt_F') or (goal_n_strata == 'auto'):
if n_bins == 'auto':
width_score = _heuristic_bin_width(scores)
n_bins = np.ceil(sp.ptp(scores)/width_score).astype(int)
print("Automatically setting n_bins = {}.".format(n_bins))
counts, score_bins = np.histogram(scores, bins=n_bins)
sqrt_counts = np.sqrt(counts)
csf = np.cumsum(sqrt_counts)
if goal_n_strata == 'auto':
width_csf = _heuristic_bin_width(csf)
goal_n_strata = np.ceil(sp.ptp(csf)/width_csf).astype(int)
print("Automatically setting goal_n_strata = {}.".format(goal_n_strata))
elif method == 'cum_sqrt_F':
width_csf = csf[-1]/goal_n_strata
if method == 'equal_size':
sorted_ids = scores.argsort()
n_items = len(sorted_ids)
quotient = n_items // goal_n_strata
remainder = n_items % goal_n_strata
allocations = np.empty(n_items, dtype='int')
st_pops = [quotient for i in range(goal_n_strata)]
for i in range(remainder):
st_pops[i] += 1
j = 0
for k,nk in enumerate(st_pops):
start = j
end = j + nk
allocations[sorted_ids[start:end]] = k
j = end
if method == 'cum_sqrt_F':
if goal_n_strata > n_bins:
warnings.warn("goal_n_strata > n_bins. "
"Consider increasing n_bins.")
csf_bins = [x * width_csf for x in np.arange(goal_n_strata + 1)]
j = 0
new_bins = []
for (idx,value) in enumerate(csf):
if j == (len(csf_bins) - 1) or idx == (len(csf) - 1):
new_bins.append(score_bins[-1])
break
if value >= csf_bins[j]:
new_bins.append(score_bins[idx])
j += 1
new_bins[0] -= 0.01
new_bins[-1] += 0.01
allocations = np.digitize(scores, bins=new_bins, right=True) - 1
nonempty_ids = np.unique(allocations)
n_strata = len(nonempty_ids)
indices = np.arange(n_strata)
allocations = np.digitize(allocations, nonempty_ids, right=True)
if n_strata < goal_n_strata:
warnings.warn("Failed to create {} strata".format(goal_n_strata))
return Strata(allocations) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_target; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:target; 6, block; 6, 7; 6, 18; 6, 28; 6, 50; 6, 95; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:depth; 10, binary_operator:+; 10, 11; 10, 17; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:target; 14, identifier:count; 15, argument_list; 15, 16; 16, string:'.'; 17, integer:1; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:parts; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:target; 24, identifier:split; 25, argument_list; 25, 26; 25, 27; 26, string:'.'; 27, integer:1; 28, for_statement; 28, 29; 28, 30; 28, 33; 29, identifier:m; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:modules; 33, block; 33, 34; 34, if_statement; 34, 35; 34, 42; 35, comparison_operator:==; 35, 36; 35, 39; 36, subscript; 36, 37; 36, 38; 37, identifier:parts; 38, integer:0; 39, attribute; 39, 40; 39, 41; 40, identifier:m; 41, identifier:name; 42, block; 42, 43; 43, if_statement; 43, 44; 43, 47; 44, comparison_operator:<; 44, 45; 44, 46; 45, identifier:depth; 46, integer:3; 47, block; 47, 48; 48, return_statement; 48, 49; 49, identifier:m; 50, for_statement; 50, 51; 50, 52; 50, 55; 51, identifier:p; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:packages; 55, block; 55, 56; 56, if_statement; 56, 57; 56, 64; 57, comparison_operator:==; 57, 58; 57, 61; 58, subscript; 58, 59; 58, 60; 59, identifier:parts; 60, integer:0; 61, attribute; 61, 62; 61, 63; 62, identifier:p; 63, identifier:name; 64, block; 64, 65; 64, 72; 64, 83; 64, 88; 65, if_statement; 65, 66; 65, 69; 66, comparison_operator:==; 66, 67; 66, 68; 67, identifier:depth; 68, integer:1; 69, block; 69, 70; 70, return_statement; 70, 71; 71, identifier:p; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:target; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:p; 78, identifier:_get_target; 79, argument_list; 79, 80; 80, subscript; 80, 81; 80, 82; 81, identifier:parts; 82, integer:1; 83, if_statement; 83, 84; 83, 85; 84, identifier:target; 85, block; 85, 86; 86, return_statement; 86, 87; 87, identifier:target; 88, if_statement; 88, 89; 88, 92; 89, comparison_operator:<; 89, 90; 89, 91; 90, identifier:depth; 91, integer:3; 92, block; 92, 93; 93, return_statement; 93, 94; 94, identifier:p; 95, return_statement; 95, 96; 96, None | def _get_target(self, target):
depth = target.count('.') + 1
parts = target.split('.', 1)
for m in self.modules:
if parts[0] == m.name:
if depth < 3:
return m
for p in self.packages:
if parts[0] == p.name:
if depth == 1:
return p
target = p._get_target(parts[1])
if target:
return target
if depth < 3:
return p
return None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:by_user; 3, parameters; 3, 4; 4, identifier:config; 5, block; 5, 6; 5, 12; 5, 18; 5, 25; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:client; 9, call; 9, 10; 9, 11; 10, identifier:Client; 11, argument_list; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:client; 16, identifier:prepare_connection; 17, argument_list; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:audit_api; 21, call; 21, 22; 21, 23; 22, identifier:API; 23, argument_list; 23, 24; 24, identifier:client; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:CLI; 29, identifier:parse_membership; 30, argument_list; 30, 31; 30, 32; 31, string:'Groups by User'; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:audit_api; 35, identifier:by_user; 36, argument_list | def by_user(config):
client = Client()
client.prepare_connection()
audit_api = API(client)
CLI.parse_membership('Groups by User', audit_api.by_user()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_sortkey; 3, parameters; 3, 4; 4, identifier:table; 5, block; 5, 6; 5, 20; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:wfs; 9, call; 9, 10; 9, 11; 10, identifier:WebFeatureService; 11, argument_list; 11, 12; 11, 17; 12, keyword_argument; 12, 13; 12, 14; 13, identifier:url; 14, attribute; 14, 15; 14, 16; 15, identifier:bcdata; 16, identifier:OWS_URL; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:version; 19, string:"2.0.0"; 20, return_statement; 20, 21; 21, subscript; 21, 22; 21, 39; 22, call; 22, 23; 22, 24; 23, identifier:sorted; 24, argument_list; 24, 25; 25, call; 25, 26; 25, 38; 26, attribute; 26, 27; 26, 37; 27, subscript; 27, 28; 27, 36; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:wfs; 31, identifier:get_schema; 32, argument_list; 32, 33; 33, binary_operator:+; 33, 34; 33, 35; 34, string:"pub:"; 35, identifier:table; 36, string:"properties"; 37, identifier:keys; 38, argument_list; 39, integer:0 | def get_sortkey(table):
wfs = WebFeatureService(url=bcdata.OWS_URL, version="2.0.0")
return sorted(wfs.get_schema("pub:" + table)["properties"].keys())[0] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:define_request; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:dataset; 5, default_parameter; 5, 6; 5, 7; 6, identifier:query; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:crs; 10, string:"epsg:4326"; 11, default_parameter; 11, 12; 11, 13; 12, identifier:bounds; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:sortby; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:pagesize; 19, integer:10000; 20, block; 20, 21; 20, 28; 20, 40; 20, 51; 20, 66; 20, 70; 20, 164; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:table; 24, call; 24, 25; 24, 26; 25, identifier:validate_name; 26, argument_list; 26, 27; 27, identifier:dataset; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:n; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:bcdata; 34, identifier:get_count; 35, argument_list; 35, 36; 35, 37; 36, identifier:table; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:query; 39, identifier:query; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:chunks; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:math; 46, identifier:ceil; 47, argument_list; 47, 48; 48, binary_operator:/; 48, 49; 48, 50; 49, identifier:n; 50, identifier:pagesize; 51, if_statement; 51, 52; 51, 58; 52, boolean_operator:and; 52, 53; 52, 56; 53, comparison_operator:>; 53, 54; 53, 55; 54, identifier:chunks; 55, integer:1; 56, not_operator; 56, 57; 57, identifier:sortby; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:sortby; 62, call; 62, 63; 62, 64; 63, identifier:get_sortkey; 64, argument_list; 64, 65; 65, identifier:table; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:param_dicts; 69, list:[]; 70, for_statement; 70, 71; 70, 72; 70, 76; 71, identifier:i; 72, call; 72, 73; 72, 74; 73, identifier:range; 74, argument_list; 74, 75; 75, identifier:chunks; 76, block; 76, 77; 76, 99; 76, 108; 76, 117; 76, 138; 76, 157; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:request; 80, dictionary; 80, 81; 80, 84; 80, 87; 80, 90; 80, 93; 80, 96; 81, pair; 81, 82; 81, 83; 82, string:"service"; 83, string:"WFS"; 84, pair; 84, 85; 84, 86; 85, string:"version"; 86, string:"2.0.0"; 87, pair; 87, 88; 87, 89; 88, string:"request"; 89, string:"GetFeature"; 90, pair; 90, 91; 90, 92; 91, string:"typeName"; 92, identifier:table; 93, pair; 93, 94; 93, 95; 94, string:"outputFormat"; 95, string:"json"; 96, pair; 96, 97; 96, 98; 97, string:"SRSNAME"; 98, identifier:crs; 99, if_statement; 99, 100; 99, 101; 100, identifier:sortby; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:request; 106, string:"sortby"; 107, identifier:sortby; 108, if_statement; 108, 109; 108, 110; 109, identifier:query; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:request; 115, string:"CQL_FILTER"; 116, identifier:query; 117, if_statement; 117, 118; 117, 119; 118, identifier:bounds; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:request; 124, string:"bbox"; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, string:","; 128, identifier:join; 129, argument_list; 129, 130; 130, list_comprehension; 130, 131; 130, 135; 131, call; 131, 132; 131, 133; 132, identifier:str; 133, argument_list; 133, 134; 134, identifier:b; 135, for_in_clause; 135, 136; 135, 137; 136, identifier:b; 137, identifier:bounds; 138, if_statement; 138, 139; 138, 142; 139, comparison_operator:>; 139, 140; 139, 141; 140, identifier:chunks; 141, integer:1; 142, block; 142, 143; 142, 151; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:request; 147, string:"startIndex"; 148, binary_operator:*; 148, 149; 148, 150; 149, identifier:i; 150, identifier:pagesize; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 156; 153, subscript; 153, 154; 153, 155; 154, identifier:request; 155, string:"count"; 156, identifier:pagesize; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:param_dicts; 161, identifier:append; 162, argument_list; 162, 163; 163, identifier:request; 164, return_statement; 164, 165; 165, identifier:param_dicts | def define_request(
dataset, query=None, crs="epsg:4326", bounds=None, sortby=None, pagesize=10000
):
table = validate_name(dataset)
n = bcdata.get_count(table, query=query)
chunks = math.ceil(n / pagesize)
if chunks > 1 and not sortby:
sortby = get_sortkey(table)
param_dicts = []
for i in range(chunks):
request = {
"service": "WFS",
"version": "2.0.0",
"request": "GetFeature",
"typeName": table,
"outputFormat": "json",
"SRSNAME": crs,
}
if sortby:
request["sortby"] = sortby
if query:
request["CQL_FILTER"] = query
if bounds:
request["bbox"] = ",".join([str(b) for b in bounds])
if chunks > 1:
request["startIndex"] = i * pagesize
request["count"] = pagesize
param_dicts.append(request)
return param_dicts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_sorted; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:resources; 6, block; 6, 7; 6, 11; 6, 48; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:tmp; 10, list:[]; 11, for_statement; 11, 12; 11, 13; 11, 14; 12, identifier:resource; 13, identifier:resources; 14, block; 14, 15; 14, 21; 14, 39; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:path; 18, attribute; 18, 19; 18, 20; 19, identifier:resource; 20, identifier:_path; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:priority; 24, binary_operator:-; 24, 25; 24, 33; 25, binary_operator:*; 25, 26; 25, 32; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:path; 29, identifier:count; 30, argument_list; 30, 31; 31, string:'/'; 32, integer:10; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:path; 36, identifier:count; 37, argument_list; 37, 38; 38, string:'{'; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:tmp; 43, identifier:append; 44, argument_list; 44, 45; 45, tuple; 45, 46; 45, 47; 46, identifier:priority; 47, identifier:resource; 48, return_statement; 48, 49; 49, list_comprehension; 49, 50; 49, 51; 50, identifier:resource; 51, for_in_clause; 51, 52; 51, 55; 52, pattern_list; 52, 53; 52, 54; 53, identifier:prio; 54, identifier:resource; 55, call; 55, 56; 55, 57; 56, identifier:reversed; 57, argument_list; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:sorted; 60, argument_list; 60, 61; 61, identifier:tmp | def _get_sorted(self, resources):
tmp = []
for resource in resources:
path = resource._path
priority = path.count('/') * 10 - path.count('{')
tmp.append((priority, resource))
return [resource for prio, resource in reversed(sorted(tmp))] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:find_new_posts_and_pages; 3, parameters; 3, 4; 4, identifier:db; 5, block; 5, 6; 5, 12; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:Q; 9, call; 9, 10; 9, 11; 10, identifier:Query; 11, argument_list; 12, for_statement; 12, 13; 12, 17; 12, 25; 13, pattern_list; 13, 14; 13, 15; 13, 16; 14, identifier:root; 15, identifier:dirs; 16, identifier:files; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:os; 20, identifier:walk; 21, argument_list; 21, 22; 22, subscript; 22, 23; 22, 24; 23, identifier:CONFIG; 24, string:'content_root'; 25, block; 25, 26; 26, for_statement; 26, 27; 26, 28; 26, 45; 27, identifier:filename; 28, call; 28, 29; 28, 30; 29, identifier:sorted; 30, argument_list; 30, 31; 31, list_comprehension; 31, 32; 31, 33; 31, 36; 32, identifier:f; 33, for_in_clause; 33, 34; 33, 35; 34, identifier:f; 35, identifier:files; 36, if_clause; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:f; 40, identifier:endswith; 41, argument_list; 41, 42; 42, tuple; 42, 43; 42, 44; 43, string:'md'; 44, string:'markdown'; 45, block; 45, 46; 45, 58; 45, 77; 45, 91; 45, 99; 45, 161; 45, 172; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:fullpath; 49, call; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:os; 53, identifier:path; 54, identifier:join; 55, argument_list; 55, 56; 55, 57; 56, identifier:root; 57, identifier:filename; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:_p; 61, call; 61, 62; 61, 75; 62, attribute; 62, 63; 62, 74; 63, subscript; 63, 64; 63, 72; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:fullpath; 67, identifier:split; 68, argument_list; 68, 69; 69, subscript; 69, 70; 69, 71; 70, identifier:CONFIG; 71, string:'content_root'; 72, unary_operator:-; 72, 73; 73, integer:1; 74, identifier:lstrip; 75, argument_list; 75, 76; 76, string:'/'; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:new_mtime; 80, call; 80, 81; 80, 82; 81, identifier:int; 82, argument_list; 82, 83; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:os; 87, identifier:path; 88, identifier:getmtime; 89, argument_list; 89, 90; 90, identifier:fullpath; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, pattern_list; 93, 94; 93, 95; 94, identifier:e; 95, identifier:item; 96, expression_list; 96, 97; 96, 98; 97, None; 98, None; 99, for_statement; 99, 100; 99, 101; 99, 104; 100, identifier:collection; 101, list:['posts', 'pages']; 101, 102; 101, 103; 102, string:'posts'; 103, string:'pages'; 104, block; 104, 105; 104, 120; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:item; 108, call; 108, 109; 108, 114; 109, attribute; 109, 110; 109, 113; 110, subscript; 110, 111; 110, 112; 111, identifier:db; 112, identifier:collection; 113, identifier:get; 114, argument_list; 114, 115; 115, comparison_operator:==; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:Q; 118, identifier:filename; 119, identifier:_p; 120, if_statement; 120, 121; 120, 122; 121, identifier:item; 122, block; 122, 123; 122, 160; 123, if_statement; 123, 124; 123, 129; 124, comparison_operator:>; 124, 125; 124, 126; 125, identifier:new_mtime; 126, subscript; 126, 127; 126, 128; 127, identifier:item; 128, string:'mtime'; 129, block; 129, 130; 129, 148; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, subscript; 133, 134; 133, 135; 134, identifier:db; 135, identifier:collection; 136, identifier:update; 137, argument_list; 137, 138; 137, 142; 138, dictionary; 138, 139; 139, pair; 139, 140; 139, 141; 140, string:'mtime'; 141, identifier:new_mtime; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:doc_ids; 144, list:[item.doc_id]; 144, 145; 145, attribute; 145, 146; 145, 147; 146, identifier:item; 147, identifier:doc_id; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:e; 151, call; 151, 152; 151, 153; 152, identifier:Entry; 153, argument_list; 153, 154; 153, 155; 154, identifier:fullpath; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:doc_id; 157, attribute; 157, 158; 157, 159; 158, identifier:item; 159, identifier:doc_id; 160, break_statement; 161, if_statement; 161, 162; 161, 164; 162, not_operator; 162, 163; 163, identifier:item; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:e; 168, call; 168, 169; 168, 170; 169, identifier:Entry; 170, argument_list; 170, 171; 171, identifier:fullpath; 172, if_statement; 172, 173; 172, 174; 173, identifier:e; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, yield; 176, 177; 177, expression_list; 177, 178; 177, 179; 178, identifier:e; 179, attribute; 179, 180; 179, 181; 180, identifier:e; 181, identifier:id | def find_new_posts_and_pages(db):
Q = Query()
for root, dirs, files in os.walk(CONFIG['content_root']):
for filename in sorted([f for f in files if
f.endswith(('md', 'markdown'))]):
fullpath = os.path.join(root, filename)
_p = fullpath.split(CONFIG['content_root'])[-1].lstrip('/')
new_mtime = int(os.path.getmtime(fullpath))
e, item = None, None
for collection in ['posts', 'pages']:
item = db[collection].get(Q.filename == _p)
if item:
if new_mtime > item['mtime']:
db[collection].update({'mtime': new_mtime},
doc_ids=[item.doc_id])
e = Entry(fullpath, doc_id=item.doc_id)
break
if not item:
e = Entry(fullpath)
if e:
yield e, e.id |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_locations; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:filter_to_my_group; 7, False; 8, block; 8, 9; 8, 19; 8, 23; 8, 60; 8, 64; 8, 199; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:resp; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:_post; 16, argument_list; 16, 17; 16, 18; 17, string:'general-retrievelocations'; 18, string:'locations'; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:groups; 22, dictionary; 23, if_statement; 23, 24; 23, 27; 24, subscript; 24, 25; 24, 26; 25, identifier:resp; 26, string:'groupinfo'; 27, block; 27, 28; 28, for_statement; 28, 29; 28, 30; 28, 33; 29, identifier:group; 30, subscript; 30, 31; 30, 32; 31, identifier:resp; 32, string:'groupinfo'; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 41; 36, subscript; 36, 37; 36, 38; 37, identifier:groups; 38, subscript; 38, 39; 38, 40; 39, identifier:group; 40, string:'id'; 41, call; 41, 42; 41, 43; 42, identifier:Group; 43, argument_list; 43, 44; 43, 52; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:name; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:group; 49, identifier:get; 50, argument_list; 50, 51; 51, string:'name'; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:inventory_id; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:group; 57, identifier:get; 58, argument_list; 58, 59; 59, string:'id'; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:final_resp; 63, list:[]; 64, if_statement; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:resp; 67, string:'data'; 68, block; 68, 69; 68, 89; 69, if_statement; 69, 70; 69, 71; 70, identifier:filter_to_my_group; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 77; 74, subscript; 74, 75; 74, 76; 75, identifier:resp; 76, string:'data'; 77, dictionary; 77, 78; 78, pair; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:groupid; 82, subscript; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:resp; 85, string:'data'; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:groupid; 89, for_statement; 89, 90; 89, 93; 89, 100; 90, pattern_list; 90, 91; 90, 92; 91, identifier:groupid; 92, identifier:sublocation; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, subscript; 95, 96; 95, 97; 96, identifier:resp; 97, string:'data'; 98, identifier:items; 99, argument_list; 100, block; 100, 101; 100, 130; 100, 145; 101, if_statement; 101, 102; 101, 108; 102, comparison_operator:is; 102, 103; 102, 107; 103, call; 103, 104; 103, 105; 104, identifier:type; 105, argument_list; 105, 106; 106, identifier:sublocation; 107, identifier:dict; 108, block; 108, 109; 108, 123; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:sublocation; 112, list_comprehension; 112, 113; 112, 114; 113, identifier:loc; 114, for_in_clause; 114, 115; 114, 118; 115, pattern_list; 115, 116; 115, 117; 116, identifier:_; 117, identifier:loc; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:sublocation; 121, identifier:items; 122, argument_list; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:sublocation; 126, call; 126, 127; 126, 128; 127, identifier:flatten_list; 128, argument_list; 128, 129; 129, identifier:sublocation; 130, if_statement; 130, 131; 130, 137; 131, comparison_operator:is; 131, 132; 131, 136; 132, call; 132, 133; 132, 134; 133, identifier:type; 134, argument_list; 134, 135; 135, identifier:sublocation; 136, identifier:list; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:sublocation; 141, call; 141, 142; 141, 143; 142, identifier:flatten_list; 143, argument_list; 143, 144; 144, identifier:sublocation; 145, for_statement; 145, 146; 145, 147; 145, 148; 146, identifier:location; 147, identifier:sublocation; 148, block; 148, 149; 148, 155; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:group; 152, subscript; 152, 153; 152, 154; 153, identifier:groups; 154, identifier:groupid; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:final_resp; 159, identifier:append; 160, argument_list; 160, 161; 161, call; 161, 162; 161, 163; 162, identifier:Location; 163, argument_list; 163, 164; 163, 172; 163, 180; 163, 188; 163, 191; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:name; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:location; 169, identifier:get; 170, argument_list; 170, 171; 171, string:'name'; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:inventory_id; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:location; 177, identifier:get; 178, argument_list; 178, 179; 179, string:'id'; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:parent; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:location; 185, identifier:get; 186, argument_list; 186, 187; 187, string:'parent'; 188, keyword_argument; 188, 189; 188, 190; 189, identifier:group; 190, identifier:group; 191, keyword_argument; 191, 192; 191, 193; 192, identifier:barcode; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:location; 196, identifier:get; 197, argument_list; 197, 198; 198, string:'barcode'; 199, return_statement; 199, 200; 200, identifier:final_resp | def get_locations(self, filter_to_my_group=False):
resp = self._post('general-retrievelocations', 'locations')
groups = {}
if resp['groupinfo']:
for group in resp['groupinfo']:
groups[group['id']] = Group(
name=group.get('name'),
inventory_id=group.get('id')
)
final_resp = []
if resp['data']:
if filter_to_my_group:
resp['data'] = {self.groupid: resp['data'][self.groupid]}
for groupid, sublocation in resp['data'].items():
if type(sublocation) is dict:
sublocation = [loc for _, loc in sublocation.items()]
sublocation = flatten_list(sublocation)
if type(sublocation) is list:
sublocation = flatten_list(sublocation)
for location in sublocation:
group = groups[groupid]
final_resp.append(Location(
name=location.get('name'),
inventory_id=location.get('id'),
parent=location.get('parent'),
group=group,
barcode=location.get('barcode')
))
return final_resp |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:_image_url; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:image; 5, default_parameter; 5, 6; 5, 7; 6, identifier:dst_color; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:src_color; 10, None; 11, block; 11, 12; 11, 26; 11, 35; 11, 39; 11, 159; 11, 163; 11, 456; 11, 465; 12, if_statement; 12, 13; 12, 16; 13, boolean_operator:and; 13, 14; 13, 15; 14, identifier:src_color; 15, identifier:dst_color; 16, block; 16, 17; 17, if_statement; 17, 18; 17, 20; 18, not_operator; 18, 19; 19, identifier:Image; 20, block; 20, 21; 21, raise_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:Exception; 24, argument_list; 24, 25; 25, string:"Images manipulation require PIL"; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:file; 29, attribute; 29, 30; 29, 34; 30, call; 30, 31; 30, 32; 31, identifier:StringValue; 32, argument_list; 32, 33; 33, identifier:image; 34, identifier:value; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:path; 38, None; 39, if_statement; 39, 40; 39, 44; 39, 104; 40, call; 40, 41; 40, 42; 41, identifier:callable; 42, argument_list; 42, 43; 43, identifier:STATIC_ROOT; 44, block; 44, 45; 45, try_statement; 45, 46; 45, 98; 46, block; 46, 47; 46, 61; 46, 70; 46, 86; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 52; 49, pattern_list; 49, 50; 49, 51; 50, identifier:_file; 51, identifier:_storage; 52, subscript; 52, 53; 52, 60; 53, call; 53, 54; 53, 55; 54, identifier:list; 55, argument_list; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:STATIC_ROOT; 58, argument_list; 58, 59; 59, identifier:file; 60, integer:0; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:d_obj; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:_storage; 67, identifier:modified_time; 68, argument_list; 68, 69; 69, identifier:_file; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:filetime; 73, call; 73, 74; 73, 75; 74, identifier:int; 75, argument_list; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:time; 79, identifier:mktime; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:d_obj; 84, identifier:timetuple; 85, argument_list; 86, if_statement; 86, 87; 86, 88; 87, identifier:dst_color; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:path; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:_storage; 95, identifier:open; 96, argument_list; 96, 97; 97, identifier:_file; 98, except_clause; 98, 99; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:filetime; 103, string:'NA'; 104, else_clause; 104, 105; 105, block; 105, 106; 105, 118; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:_path; 109, call; 109, 110; 109, 115; 110, attribute; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:os; 113, identifier:path; 114, identifier:join; 115, argument_list; 115, 116; 115, 117; 116, identifier:STATIC_ROOT; 117, identifier:file; 118, if_statement; 118, 119; 118, 127; 118, 153; 119, call; 119, 120; 119, 125; 120, attribute; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:os; 123, identifier:path; 124, identifier:exists; 125, argument_list; 125, 126; 126, identifier:_path; 127, block; 127, 128; 127, 142; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:filetime; 131, call; 131, 132; 131, 133; 132, identifier:int; 133, argument_list; 133, 134; 134, call; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:os; 138, identifier:path; 139, identifier:getmtime; 140, argument_list; 140, 141; 141, identifier:_path; 142, if_statement; 142, 143; 142, 144; 143, identifier:dst_color; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:path; 148, call; 148, 149; 148, 150; 149, identifier:open; 150, argument_list; 150, 151; 150, 152; 151, identifier:_path; 152, string:'rb'; 153, else_clause; 153, 154; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:filetime; 158, string:'NA'; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:BASE_URL; 162, identifier:STATIC_URL; 163, if_statement; 163, 164; 163, 165; 164, identifier:path; 165, block; 165, 166; 165, 197; 165, 220; 165, 252; 165, 259; 165, 295; 165, 301; 165, 313; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:src_color; 169, conditional_expression:if; 169, 170; 169, 192; 169, 193; 170, call; 170, 171; 170, 172; 171, identifier:tuple; 172, generator_expression; 172, 173; 172, 180; 173, call; 173, 174; 173, 175; 174, identifier:int; 175, argument_list; 175, 176; 176, call; 176, 177; 176, 178; 177, identifier:round; 178, argument_list; 178, 179; 179, identifier:c; 180, for_in_clause; 180, 181; 180, 182; 181, identifier:c; 182, subscript; 182, 183; 182, 189; 183, attribute; 183, 184; 183, 188; 184, call; 184, 185; 184, 186; 185, identifier:ColorValue; 186, argument_list; 186, 187; 187, identifier:src_color; 188, identifier:value; 189, slice; 189, 190; 189, 191; 190, colon; 191, integer:3; 192, identifier:src_color; 193, tuple; 193, 194; 193, 195; 193, 196; 194, integer:0; 195, integer:0; 196, integer:0; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:dst_color; 200, list_comprehension; 200, 201; 200, 208; 201, call; 201, 202; 201, 203; 202, identifier:int; 203, argument_list; 203, 204; 204, call; 204, 205; 204, 206; 205, identifier:round; 206, argument_list; 206, 207; 207, identifier:c; 208, for_in_clause; 208, 209; 208, 210; 209, identifier:c; 210, subscript; 210, 211; 210, 217; 211, attribute; 211, 212; 211, 216; 212, call; 212, 213; 212, 214; 213, identifier:ColorValue; 214, argument_list; 214, 215; 215, identifier:dst_color; 216, identifier:value; 217, slice; 217, 218; 217, 219; 218, colon; 219, integer:3; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 225; 222, pattern_list; 222, 223; 222, 224; 223, identifier:file_name; 224, identifier:file_ext; 225, call; 225, 226; 225, 231; 226, attribute; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:os; 229, identifier:path; 230, identifier:splitext; 231, argument_list; 231, 232; 232, call; 232, 233; 232, 249; 233, attribute; 233, 234; 233, 248; 234, call; 234, 235; 234, 245; 235, attribute; 235, 236; 235, 244; 236, call; 236, 237; 236, 242; 237, attribute; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:os; 240, identifier:path; 241, identifier:normpath; 242, argument_list; 242, 243; 243, identifier:file; 244, identifier:replace; 245, argument_list; 245, 246; 245, 247; 246, string:'\\'; 247, string:'_'; 248, identifier:replace; 249, argument_list; 249, 250; 249, 251; 250, string:'/'; 251, string:'_'; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:key; 255, tuple; 255, 256; 255, 257; 255, 258; 256, identifier:filetime; 257, identifier:src_color; 258, identifier:dst_color; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:key; 262, binary_operator:+; 262, 263; 262, 266; 263, binary_operator:+; 263, 264; 263, 265; 264, identifier:file_name; 265, string:'-'; 266, call; 266, 267; 266, 292; 267, attribute; 267, 268; 267, 291; 268, call; 268, 269; 268, 289; 269, attribute; 269, 270; 269, 288; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:base64; 273, identifier:urlsafe_b64encode; 274, argument_list; 274, 275; 275, call; 275, 276; 275, 287; 276, attribute; 276, 277; 276, 286; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:hashlib; 280, identifier:md5; 281, argument_list; 281, 282; 282, call; 282, 283; 282, 284; 283, identifier:repr; 284, argument_list; 284, 285; 285, identifier:key; 286, identifier:digest; 287, argument_list; 288, identifier:rstrip; 289, argument_list; 289, 290; 290, string:'='; 291, identifier:replace; 292, argument_list; 292, 293; 292, 294; 293, string:'-'; 294, string:'_'; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:asset_file; 298, binary_operator:+; 298, 299; 298, 300; 299, identifier:key; 300, identifier:file_ext; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:asset_path; 304, call; 304, 305; 304, 310; 305, attribute; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:os; 308, identifier:path; 309, identifier:join; 310, argument_list; 310, 311; 310, 312; 311, identifier:ASSETS_ROOT; 312, identifier:asset_file; 313, if_statement; 313, 314; 313, 322; 313, 345; 314, call; 314, 315; 314, 320; 315, attribute; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:os; 318, identifier:path; 319, identifier:exists; 320, argument_list; 320, 321; 321, identifier:asset_path; 322, block; 322, 323; 322, 327; 322, 331; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:file; 326, identifier:asset_file; 327, expression_statement; 327, 328; 328, assignment; 328, 329; 328, 330; 329, identifier:BASE_URL; 330, identifier:ASSETS_URL; 331, expression_statement; 331, 332; 332, assignment; 332, 333; 332, 334; 333, identifier:filetime; 334, call; 334, 335; 334, 336; 335, identifier:int; 336, argument_list; 336, 337; 337, call; 337, 338; 337, 343; 338, attribute; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, identifier:os; 341, identifier:path; 342, identifier:getmtime; 343, argument_list; 343, 344; 344, identifier:asset_path; 345, else_clause; 345, 346; 346, block; 346, 347; 346, 356; 346, 365; 346, 373; 346, 429; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 350; 349, identifier:image; 350, call; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:Image; 353, identifier:open; 354, argument_list; 354, 355; 355, identifier:path; 356, expression_statement; 356, 357; 357, assignment; 357, 358; 357, 359; 358, identifier:image; 359, call; 359, 360; 359, 363; 360, attribute; 360, 361; 360, 362; 361, identifier:image; 362, identifier:convert; 363, argument_list; 363, 364; 364, string:"RGBA"; 365, expression_statement; 365, 366; 366, assignment; 366, 367; 366, 368; 367, identifier:pixdata; 368, call; 368, 369; 368, 372; 369, attribute; 369, 370; 369, 371; 370, identifier:image; 371, identifier:load; 372, argument_list; 373, for_statement; 373, 374; 373, 375; 373, 383; 374, identifier:y; 375, call; 375, 376; 375, 377; 376, identifier:xrange; 377, argument_list; 377, 378; 378, subscript; 378, 379; 378, 382; 379, attribute; 379, 380; 379, 381; 380, identifier:image; 381, identifier:size; 382, integer:1; 383, block; 383, 384; 384, for_statement; 384, 385; 384, 386; 384, 394; 385, identifier:x; 386, call; 386, 387; 386, 388; 387, identifier:xrange; 388, argument_list; 388, 389; 389, subscript; 389, 390; 389, 393; 390, attribute; 390, 391; 390, 392; 391, identifier:image; 392, identifier:size; 393, integer:0; 394, block; 394, 395; 395, if_statement; 395, 396; 395, 406; 396, comparison_operator:==; 396, 397; 396, 405; 397, subscript; 397, 398; 397, 402; 398, subscript; 398, 399; 398, 400; 398, 401; 399, identifier:pixdata; 400, identifier:x; 401, identifier:y; 402, slice; 402, 403; 402, 404; 403, colon; 404, integer:3; 405, identifier:src_color; 406, block; 406, 407; 406, 422; 407, expression_statement; 407, 408; 408, assignment; 408, 409; 408, 410; 409, identifier:new_color; 410, call; 410, 411; 410, 412; 411, identifier:tuple; 412, argument_list; 412, 413; 413, binary_operator:+; 413, 414; 413, 415; 414, identifier:dst_color; 415, list:[pixdata[x, y][3]]; 415, 416; 416, subscript; 416, 417; 416, 421; 417, subscript; 417, 418; 417, 419; 417, 420; 418, identifier:pixdata; 419, identifier:x; 420, identifier:y; 421, integer:3; 422, expression_statement; 422, 423; 423, assignment; 423, 424; 423, 428; 424, subscript; 424, 425; 424, 426; 424, 427; 425, identifier:pixdata; 426, identifier:x; 427, identifier:y; 428, identifier:new_color; 429, try_statement; 429, 430; 429, 446; 430, block; 430, 431; 430, 438; 430, 442; 431, expression_statement; 431, 432; 432, call; 432, 433; 432, 436; 433, attribute; 433, 434; 433, 435; 434, identifier:image; 435, identifier:save; 436, argument_list; 436, 437; 437, identifier:asset_path; 438, expression_statement; 438, 439; 439, assignment; 439, 440; 439, 441; 440, identifier:file; 441, identifier:asset_file; 442, expression_statement; 442, 443; 443, assignment; 443, 444; 443, 445; 444, identifier:BASE_URL; 445, identifier:ASSETS_URL; 446, except_clause; 446, 447; 446, 448; 447, identifier:IOError; 448, block; 448, 449; 449, expression_statement; 449, 450; 450, call; 450, 451; 450, 454; 451, attribute; 451, 452; 451, 453; 452, identifier:log; 453, identifier:exception; 454, argument_list; 454, 455; 455, string:"Error while saving image"; 456, expression_statement; 456, 457; 457, assignment; 457, 458; 457, 459; 458, identifier:url; 459, binary_operator:%; 459, 460; 459, 461; 460, string:'url("%s%s?_=%s")'; 461, tuple; 461, 462; 461, 463; 461, 464; 462, identifier:BASE_URL; 463, identifier:file; 464, identifier:filetime; 465, return_statement; 465, 466; 466, call; 466, 467; 466, 468; 467, identifier:StringValue; 468, argument_list; 468, 469; 469, identifier:url | def _image_url(image, dst_color=None, src_color=None):
if src_color and dst_color:
if not Image:
raise Exception("Images manipulation require PIL")
file = StringValue(image).value
path = None
if callable(STATIC_ROOT):
try:
_file, _storage = list(STATIC_ROOT(file))[0]
d_obj = _storage.modified_time(_file)
filetime = int(time.mktime(d_obj.timetuple()))
if dst_color:
path = _storage.open(_file)
except:
filetime = 'NA'
else:
_path = os.path.join(STATIC_ROOT, file)
if os.path.exists(_path):
filetime = int(os.path.getmtime(_path))
if dst_color:
path = open(_path, 'rb')
else:
filetime = 'NA'
BASE_URL = STATIC_URL
if path:
src_color = tuple(int(round(c)) for c in ColorValue(
src_color).value[:3]) if src_color else (0, 0, 0)
dst_color = [int(round(c)) for c in ColorValue(dst_color).value[:3]]
file_name, file_ext = os.path.splitext(
os.path.normpath(file).replace('\\', '_').replace('/', '_'))
key = (filetime, src_color, dst_color)
key = file_name + '-' + base64.urlsafe_b64encode(
hashlib.md5(repr(key)).digest()).rstrip('=').replace('-', '_')
asset_file = key + file_ext
asset_path = os.path.join(ASSETS_ROOT, asset_file)
if os.path.exists(asset_path):
file = asset_file
BASE_URL = ASSETS_URL
filetime = int(os.path.getmtime(asset_path))
else:
image = Image.open(path)
image = image.convert("RGBA")
pixdata = image.load()
for y in xrange(image.size[1]):
for x in xrange(image.size[0]):
if pixdata[x, y][:3] == src_color:
new_color = tuple(dst_color + [pixdata[x, y][3]])
pixdata[x, y] = new_color
try:
image.save(asset_path)
file = asset_file
BASE_URL = ASSETS_URL
except IOError:
log.exception("Error while saving image")
url = 'url("%s%s?_=%s")' % (BASE_URL, file, filetime)
return StringValue(url) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:normalize_selectors; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:_selectors; 6, default_parameter; 6, 7; 6, 8; 7, identifier:extra_selectors; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:extra_parents; 11, None; 12, block; 12, 13; 12, 23; 12, 39; 12, 55; 12, 61; 12, 168; 12, 191; 12, 198; 12, 204; 12, 227; 12, 234; 12, 259; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:_selectors; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:_spaces_re; 19, identifier:sub; 20, argument_list; 20, 21; 20, 22; 21, string:' '; 22, identifier:_selectors; 23, if_statement; 23, 24; 23, 29; 24, call; 24, 25; 24, 26; 25, identifier:isinstance; 26, argument_list; 26, 27; 26, 28; 27, identifier:extra_selectors; 28, identifier:basestring; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:extra_selectors; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:extra_selectors; 36, identifier:split; 37, argument_list; 37, 38; 38, string:','; 39, if_statement; 39, 40; 39, 45; 40, call; 40, 41; 40, 42; 41, identifier:isinstance; 42, argument_list; 42, 43; 42, 44; 43, identifier:extra_parents; 44, identifier:basestring; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:extra_parents; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:extra_parents; 52, identifier:split; 53, argument_list; 53, 54; 54, string:'&'; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:parents; 58, call; 58, 59; 58, 60; 59, identifier:set; 60, argument_list; 61, if_statement; 61, 62; 61, 65; 61, 141; 62, comparison_operator:in; 62, 63; 62, 64; 63, string:' extends '; 64, identifier:_selectors; 65, block; 65, 66; 65, 72; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:selectors; 69, call; 69, 70; 69, 71; 70, identifier:set; 71, argument_list; 72, for_statement; 72, 73; 72, 74; 72, 80; 73, identifier:key; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:_selectors; 77, identifier:split; 78, argument_list; 78, 79; 79, string:','; 80, block; 80, 81; 80, 93; 80, 101; 80, 109; 80, 116; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 87; 83, pattern_list; 83, 84; 83, 85; 83, 86; 84, identifier:child; 85, identifier:_; 86, identifier:parent; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:key; 90, identifier:partition; 91, argument_list; 91, 92; 92, string:' extends '; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:child; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:child; 99, identifier:strip; 100, argument_list; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:parent; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:parent; 107, identifier:strip; 108, argument_list; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:selectors; 113, identifier:add; 114, argument_list; 114, 115; 115, identifier:child; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:parents; 120, identifier:update; 121, generator_expression; 121, 122; 121, 127; 121, 135; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:s; 125, identifier:strip; 126, argument_list; 127, for_in_clause; 127, 128; 127, 129; 128, identifier:s; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:parent; 132, identifier:split; 133, argument_list; 133, 134; 134, string:'&'; 135, if_clause; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:s; 139, identifier:strip; 140, argument_list; 141, else_clause; 141, 142; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:selectors; 146, call; 146, 147; 146, 148; 147, identifier:set; 148, generator_expression; 148, 149; 148, 154; 148, 162; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:s; 152, identifier:strip; 153, argument_list; 154, for_in_clause; 154, 155; 154, 156; 155, identifier:s; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:_selectors; 159, identifier:split; 160, argument_list; 160, 161; 161, string:','; 162, if_clause; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:s; 166, identifier:strip; 167, argument_list; 168, if_statement; 168, 169; 168, 170; 169, identifier:extra_selectors; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:selectors; 175, identifier:update; 176, generator_expression; 176, 177; 176, 182; 176, 185; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:s; 180, identifier:strip; 181, argument_list; 182, for_in_clause; 182, 183; 182, 184; 183, identifier:s; 184, identifier:extra_selectors; 185, if_clause; 185, 186; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:s; 189, identifier:strip; 190, argument_list; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:selectors; 195, identifier:discard; 196, argument_list; 196, 197; 197, string:''; 198, if_statement; 198, 199; 198, 201; 199, not_operator; 199, 200; 200, identifier:selectors; 201, block; 201, 202; 202, return_statement; 202, 203; 203, string:''; 204, if_statement; 204, 205; 204, 206; 205, identifier:extra_parents; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:parents; 211, identifier:update; 212, generator_expression; 212, 213; 212, 218; 212, 221; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:s; 216, identifier:strip; 217, argument_list; 218, for_in_clause; 218, 219; 218, 220; 219, identifier:s; 220, identifier:extra_parents; 221, if_clause; 221, 222; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:s; 225, identifier:strip; 226, argument_list; 227, expression_statement; 227, 228; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:parents; 231, identifier:discard; 232, argument_list; 232, 233; 233, string:''; 234, if_statement; 234, 235; 234, 236; 235, identifier:parents; 236, block; 236, 237; 237, return_statement; 237, 238; 238, binary_operator:+; 238, 239; 238, 250; 239, binary_operator:+; 239, 240; 239, 249; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, string:','; 243, identifier:join; 244, argument_list; 244, 245; 245, call; 245, 246; 245, 247; 246, identifier:sorted; 247, argument_list; 247, 248; 248, identifier:selectors; 249, string:' extends '; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, string:'&'; 253, identifier:join; 254, argument_list; 254, 255; 255, call; 255, 256; 255, 257; 256, identifier:sorted; 257, argument_list; 257, 258; 258, identifier:parents; 259, return_statement; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, string:','; 263, identifier:join; 264, argument_list; 264, 265; 265, call; 265, 266; 265, 267; 266, identifier:sorted; 267, argument_list; 267, 268; 268, identifier:selectors | def normalize_selectors(self, _selectors, extra_selectors=None, extra_parents=None):
_selectors = _spaces_re.sub(' ', _selectors)
if isinstance(extra_selectors, basestring):
extra_selectors = extra_selectors.split(',')
if isinstance(extra_parents, basestring):
extra_parents = extra_parents.split('&')
parents = set()
if ' extends ' in _selectors:
selectors = set()
for key in _selectors.split(','):
child, _, parent = key.partition(' extends ')
child = child.strip()
parent = parent.strip()
selectors.add(child)
parents.update(
s.strip() for s in parent.split('&') if s.strip())
else:
selectors = set(
s.strip() for s in _selectors.split(',') if s.strip())
if extra_selectors:
selectors.update(s.strip() for s in extra_selectors if s.strip())
selectors.discard('')
if not selectors:
return ''
if extra_parents:
parents.update(s.strip() for s in extra_parents if s.strip())
parents.discard('')
if parents:
return ','.join(sorted(selectors)) + ' extends ' + '&'.join(sorted(parents))
return ','.join(sorted(selectors)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:_get_properties; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 3, 13; 4, identifier:self; 5, identifier:rule; 6, identifier:p_selectors; 7, identifier:p_parents; 8, identifier:p_children; 9, identifier:scope; 10, identifier:media; 11, identifier:c_lineno; 12, identifier:c_property; 13, identifier:c_codestr; 14, block; 14, 15; 14, 35; 14, 56; 14, 64; 14, 81; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 20; 17, pattern_list; 17, 18; 17, 19; 18, identifier:prop; 19, identifier:value; 20, subscript; 20, 21; 20, 32; 21, parenthesized_expression; 21, 22; 22, binary_operator:+; 22, 23; 22, 30; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:_prop_split_re; 26, identifier:split; 27, argument_list; 27, 28; 27, 29; 28, identifier:c_property; 29, integer:1; 30, list:[None]; 30, 31; 31, None; 32, slice; 32, 33; 32, 34; 33, colon; 34, integer:2; 35, try_statement; 35, 36; 35, 49; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:is_var; 40, parenthesized_expression; 40, 41; 41, comparison_operator:==; 41, 42; 41, 48; 42, subscript; 42, 43; 42, 44; 43, identifier:c_property; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:prop; 48, string:'='; 49, except_clause; 49, 50; 49, 51; 50, identifier:IndexError; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:is_var; 55, False; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:prop; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:prop; 62, identifier:strip; 63, argument_list; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:prop; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:do_glob_math; 71, argument_list; 71, 72; 71, 73; 71, 76; 71, 79; 71, 80; 72, identifier:prop; 73, subscript; 73, 74; 73, 75; 74, identifier:rule; 75, identifier:CONTEXT; 76, subscript; 76, 77; 76, 78; 77, identifier:rule; 78, identifier:OPTIONS; 79, identifier:rule; 80, True; 81, if_statement; 81, 82; 81, 83; 82, identifier:prop; 83, block; 83, 84; 83, 111; 83, 120; 84, if_statement; 84, 85; 84, 86; 85, identifier:value; 86, block; 86, 87; 86, 95; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:value; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:value; 93, identifier:strip; 94, argument_list; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:value; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:calculate; 102, argument_list; 102, 103; 102, 104; 102, 107; 102, 110; 103, identifier:value; 104, subscript; 104, 105; 104, 106; 105, identifier:rule; 106, identifier:CONTEXT; 107, subscript; 107, 108; 107, 109; 108, identifier:rule; 109, identifier:OPTIONS; 110, identifier:rule; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:_prop; 114, binary_operator:+; 114, 115; 114, 119; 115, parenthesized_expression; 115, 116; 116, boolean_operator:or; 116, 117; 116, 118; 117, identifier:scope; 118, string:''; 119, identifier:prop; 120, if_statement; 120, 121; 120, 133; 120, 259; 121, boolean_operator:or; 121, 122; 121, 123; 122, identifier:is_var; 123, boolean_operator:and; 123, 124; 123, 130; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:prop; 127, identifier:startswith; 128, argument_list; 128, 129; 129, string:'$'; 130, comparison_operator:is; 130, 131; 130, 132; 131, identifier:value; 132, None; 133, block; 133, 134; 133, 246; 134, if_statement; 134, 135; 134, 140; 134, 179; 135, call; 135, 136; 135, 137; 136, identifier:isinstance; 137, argument_list; 137, 138; 137, 139; 138, identifier:value; 139, identifier:basestring; 140, block; 140, 141; 141, if_statement; 141, 142; 141, 145; 142, comparison_operator:in; 142, 143; 142, 144; 143, string:'!default'; 144, identifier:value; 145, block; 145, 146; 146, if_statement; 146, 147; 146, 152; 146, 157; 147, comparison_operator:in; 147, 148; 147, 149; 148, identifier:_prop; 149, subscript; 149, 150; 149, 151; 150, identifier:rule; 151, identifier:CONTEXT; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:value; 156, None; 157, else_clause; 157, 158; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:value; 162, call; 162, 163; 162, 178; 163, attribute; 163, 164; 163, 177; 164, call; 164, 165; 164, 174; 165, attribute; 165, 166; 165, 173; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:value; 169, identifier:replace; 170, argument_list; 170, 171; 170, 172; 171, string:'!default'; 172, string:''; 173, identifier:replace; 174, argument_list; 174, 175; 174, 176; 175, string:' '; 176, string:' '; 177, identifier:strip; 178, argument_list; 179, elif_clause; 179, 180; 179, 185; 180, call; 180, 181; 180, 182; 181, identifier:isinstance; 182, argument_list; 182, 183; 182, 184; 183, identifier:value; 184, identifier:ListValue; 185, block; 185, 186; 185, 193; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:value; 189, call; 189, 190; 189, 191; 190, identifier:ListValue; 191, argument_list; 191, 192; 192, identifier:value; 193, for_statement; 193, 194; 193, 197; 193, 204; 194, pattern_list; 194, 195; 194, 196; 195, identifier:k; 196, identifier:v; 197, call; 197, 198; 197, 203; 198, attribute; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:value; 201, identifier:value; 202, identifier:items; 203, argument_list; 204, block; 204, 205; 205, if_statement; 205, 206; 205, 209; 206, comparison_operator:==; 206, 207; 206, 208; 207, identifier:v; 208, string:'!default'; 209, block; 209, 210; 209, 245; 210, if_statement; 210, 211; 210, 216; 210, 221; 211, comparison_operator:in; 211, 212; 211, 213; 212, identifier:_prop; 213, subscript; 213, 214; 213, 215; 214, identifier:rule; 215, identifier:CONTEXT; 216, block; 216, 217; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:value; 220, None; 221, else_clause; 221, 222; 222, block; 222, 223; 222, 229; 223, delete_statement; 223, 224; 224, subscript; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:value; 227, identifier:value; 228, identifier:k; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:value; 232, conditional_expression:if; 232, 233; 232, 238; 232, 244; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:value; 236, identifier:first; 237, argument_list; 238, comparison_operator:==; 238, 239; 238, 243; 239, call; 239, 240; 239, 241; 240, identifier:len; 241, argument_list; 241, 242; 242, identifier:value; 243, integer:1; 244, identifier:value; 245, break_statement; 246, if_statement; 246, 247; 246, 250; 247, comparison_operator:is; 247, 248; 247, 249; 248, identifier:value; 249, None; 250, block; 250, 251; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 258; 253, subscript; 253, 254; 253, 257; 254, subscript; 254, 255; 254, 256; 255, identifier:rule; 256, identifier:CONTEXT; 257, identifier:_prop; 258, identifier:value; 259, else_clause; 259, 260; 260, block; 260, 261; 260, 278; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:_prop; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:self; 267, identifier:apply_vars; 268, argument_list; 268, 269; 268, 270; 268, 273; 268, 276; 268, 277; 269, identifier:_prop; 270, subscript; 270, 271; 270, 272; 271, identifier:rule; 272, identifier:CONTEXT; 273, subscript; 273, 274; 273, 275; 274, identifier:rule; 275, identifier:OPTIONS; 276, identifier:rule; 277, True; 278, expression_statement; 278, 279; 279, call; 279, 280; 279, 285; 280, attribute; 280, 281; 280, 284; 281, subscript; 281, 282; 281, 283; 282, identifier:rule; 283, identifier:PROPERTIES; 284, identifier:append; 285, argument_list; 285, 286; 286, tuple; 286, 287; 286, 288; 286, 289; 287, identifier:c_lineno; 288, identifier:_prop; 289, conditional_expression:if; 289, 290; 289, 294; 289, 297; 290, call; 290, 291; 290, 292; 291, identifier:to_str; 292, argument_list; 292, 293; 293, identifier:value; 294, comparison_operator:is; 294, 295; 294, 296; 295, identifier:value; 296, None; 297, None | def _get_properties(self, rule, p_selectors, p_parents, p_children, scope, media, c_lineno, c_property, c_codestr):
prop, value = (_prop_split_re.split(c_property, 1) + [None])[:2]
try:
is_var = (c_property[len(prop)] == '=')
except IndexError:
is_var = False
prop = prop.strip()
prop = self.do_glob_math(
prop, rule[CONTEXT], rule[OPTIONS], rule, True)
if prop:
if value:
value = value.strip()
value = self.calculate(
value, rule[CONTEXT], rule[OPTIONS], rule)
_prop = (scope or '') + prop
if is_var or prop.startswith('$') and value is not None:
if isinstance(value, basestring):
if '!default' in value:
if _prop in rule[CONTEXT]:
value = None
else:
value = value.replace(
'!default', '').replace(' ', ' ').strip()
elif isinstance(value, ListValue):
value = ListValue(value)
for k, v in value.value.items():
if v == '!default':
if _prop in rule[CONTEXT]:
value = None
else:
del value.value[k]
value = value.first(
) if len(value) == 1 else value
break
if value is not None:
rule[CONTEXT][_prop] = value
else:
_prop = self.apply_vars(
_prop, rule[CONTEXT], rule[OPTIONS], rule, True)
rule[PROPERTIES].append((c_lineno, _prop,
to_str(value) if value is not None else None)) |
0, module; 0, 1; 1, ERROR; 1, 2; 1, 299; 2, function_definition; 2, 3; 2, 4; 2, 9; 3, function_name:link_with_parents; 4, parameters; 4, 5; 4, 6; 4, 7; 4, 8; 5, identifier:self; 6, identifier:parent; 7, identifier:c_selectors; 8, identifier:c_rules; 9, block; 9, 10; 9, 14; 9, 192; 9, 208; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:parent_found; 13, None; 14, for_statement; 14, 15; 14, 18; 14, 25; 15, pattern_list; 15, 16; 15, 17; 16, identifier:p_selectors; 17, identifier:p_rules; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:parts; 23, identifier:items; 24, argument_list; 25, block; 25, 26; 25, 38; 25, 47; 25, 53; 25, 57; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 32; 28, pattern_list; 28, 29; 28, 30; 28, 31; 29, identifier:_p_selectors; 30, identifier:_; 31, identifier:_; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:p_selectors; 35, identifier:partition; 36, argument_list; 36, 37; 37, string:' extends '; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:_p_selectors; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:_p_selectors; 44, identifier:split; 45, argument_list; 45, 46; 46, string:','; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:new_selectors; 50, call; 50, 51; 50, 52; 51, identifier:set; 52, argument_list; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:found; 56, False; 57, for_statement; 57, 58; 57, 59; 57, 60; 58, identifier:p_selector; 59, identifier:_p_selectors; 60, block; 60, 61; 61, if_statement; 61, 62; 61, 65; 62, comparison_operator:in; 62, 63; 62, 64; 63, identifier:parent; 64, identifier:p_selector; 65, block; 65, 66; 66, for_statement; 66, 67; 66, 68; 66, 74; 67, identifier:c_selector; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:c_selectors; 71, identifier:split; 72, argument_list; 72, 73; 73, string:','; 74, block; 74, 75; 74, 83; 74, 93; 74, 112; 74, 122; 74, 143; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 80; 77, pattern_list; 77, 78; 77, 79; 78, identifier:_c_selector; 79, identifier:_parent; 80, expression_list; 80, 81; 80, 82; 81, identifier:c_selector; 82, identifier:parent; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:lcp; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:longest_common_prefix; 90, argument_list; 90, 91; 90, 92; 91, identifier:_c_selector; 92, identifier:_parent; 93, if_statement; 93, 94; 93, 95; 94, identifier:lcp; 95, block; 95, 96; 95, 104; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:_c_selector; 99, subscript; 99, 100; 99, 101; 100, identifier:_c_selector; 101, slice; 101, 102; 101, 103; 102, identifier:lcp; 103, colon; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:_parent; 107, subscript; 107, 108; 107, 109; 108, identifier:_parent; 109, slice; 109, 110; 109, 111; 110, identifier:lcp; 111, colon; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:lcs; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:longest_common_suffix; 119, argument_list; 119, 120; 119, 121; 120, identifier:_c_selector; 121, identifier:_parent; 122, if_statement; 122, 123; 122, 124; 123, identifier:lcs; 124, block; 124, 125; 124, 134; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:_c_selector; 128, subscript; 128, 129; 128, 130; 129, identifier:_c_selector; 130, slice; 130, 131; 130, 132; 131, colon; 132, unary_operator:-; 132, 133; 133, identifier:lcs; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:_parent; 137, subscript; 137, 138; 137, 139; 138, identifier:_parent; 139, slice; 139, 140; 139, 141; 140, colon; 141, unary_operator:-; 141, 142; 142, identifier:lcs; 143, if_statement; 143, 144; 143, 147; 143, 180; 144, boolean_operator:and; 144, 145; 144, 146; 145, identifier:_c_selector; 146, identifier:_parent; 147, ERROR; 147, 148; 147, 149; 147, 152; 147, 154; 147, 165; 147, 177; 148, identifier:prev_symbol; 149, ERROR; 149, 150; 149, 151; 150, ERROR:?; 151, ERROR:!; 152, list:[
0]; 152, 153; 153, integer:0; 154, ERROR; 154, 155; 154, 164; 155, call; 155, 156; 155, 157; 156, string:'
post_symbol = r'; 157, argument_list; 157, 158; 157, 160; 158, ERROR; 158, 159; 159, ERROR:?!; 160, list:[-\w]; 160, 161; 161, unary_operator:-; 161, 162; 161, 163; 162, ERROR:\; 163, identifier:w; 164, identifier:new_parent; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:re; 168, identifier:sub; 169, argument_list; 169, 170; 169, 175; 169, 176; 170, binary_operator:+; 170, 171; 170, 174; 171, binary_operator:+; 171, 172; 171, 173; 172, identifier:prev_symbol; 173, identifier:_parent; 174, identifier:post_symbol; 175, identifier:_c_selector; 176, identifier:p_selector; 177, comparison_operator:!=; 177, 178; 177, 179; 178, identifier:p_selector; 179, identifier:new_parent; 180, block; 180, 181; 180, 188; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:new_selectors; 185, identifier:add; 186, argument_list; 186, 187; 187, identifier:new_parent; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:found; 191, True; 192, if_statement; 192, 193; 192, 194; 193, identifier:found; 194, block; 194, 195; 194, 201; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:parent_found; 198, boolean_operator:or; 198, 199; 198, 200; 199, identifier:parent_found; 200, list:[]; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:parent_found; 205, identifier:extend; 206, argument_list; 206, 207; 207, identifier:p_rules; 208, if_statement; 208, 209; 208, 210; 209, identifier:new_selectors; 210, block; 210, 211; 210, 221; 210, 253; 210, 259; 210, 280; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:new_selectors; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:self; 217, identifier:normalize_selectors; 218, argument_list; 218, 219; 218, 220; 219, identifier:p_selectors; 220, identifier:new_selectors; 221, if_statement; 221, 222; 221, 225; 222, comparison_operator:!=; 222, 223; 222, 224; 223, identifier:new_selectors; 224, identifier:p_selectors; 225, block; 225, 226; 225, 232; 225, 242; 226, delete_statement; 226, 227; 227, subscript; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:self; 230, identifier:parts; 231, identifier:p_selectors; 232, expression_statement; 232, 233; 233, call; 233, 234; 233, 239; 234, attribute; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:self; 237, identifier:parts; 238, identifier:setdefault; 239, argument_list; 239, 240; 239, 241; 240, identifier:new_selectors; 241, list:[]; 242, expression_statement; 242, 243; 243, call; 243, 244; 243, 251; 244, attribute; 244, 245; 244, 250; 245, subscript; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:self; 248, identifier:parts; 249, identifier:new_selectors; 250, identifier:extend; 251, argument_list; 251, 252; 252, identifier:p_rules; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:deps; 256, call; 256, 257; 256, 258; 257, identifier:set; 258, argument_list; 259, for_statement; 259, 260; 259, 261; 259, 264; 260, identifier:c_rule; 261, boolean_operator:or; 261, 262; 261, 263; 262, identifier:c_rules; 263, list:[]; 264, block; 264, 265; 264, 271; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 270; 267, subscript; 267, 268; 267, 269; 268, identifier:c_rule; 269, identifier:SELECTORS; 270, identifier:c_selectors; 271, expression_statement; 271, 272; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:deps; 275, identifier:add; 276, argument_list; 276, 277; 277, subscript; 277, 278; 277, 279; 278, identifier:c_rule; 279, identifier:POSITION; 280, for_statement; 280, 281; 280, 282; 280, 283; 281, identifier:p_rule; 282, identifier:p_rules; 283, block; 283, 284; 283, 290; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 289; 286, subscript; 286, 287; 286, 288; 287, identifier:p_rule; 288, identifier:SELECTORS; 289, identifier:new_selectors; 290, expression_statement; 290, 291; 291, call; 291, 292; 291, 297; 292, attribute; 292, 293; 292, 296; 293, subscript; 293, 294; 293, 295; 294, identifier:p_rule; 295, identifier:DEPS; 296, identifier:update; 297, argument_list; 297, 298; 298, identifier:deps; 299, return_statement; 299, 300; 300, identifier:parent_found | def link_with_parents(self, parent, c_selectors, c_rules):
parent_found = None
for p_selectors, p_rules in self.parts.items():
_p_selectors, _, _ = p_selectors.partition(' extends ')
_p_selectors = _p_selectors.split(',')
new_selectors = set()
found = False
for p_selector in _p_selectors:
if parent in p_selector:
for c_selector in c_selectors.split(','):
_c_selector, _parent = c_selector, parent
lcp = self.longest_common_prefix(_c_selector, _parent)
if lcp:
_c_selector = _c_selector[lcp:]
_parent = _parent[lcp:]
lcs = self.longest_common_suffix(_c_selector, _parent)
if lcs:
_c_selector = _c_selector[:-lcs]
_parent = _parent[:-lcs]
if _c_selector and _parent:
prev_symbol = '(?<![
0] in ('
post_symbol = r'(?![-\w])'
new_parent = re.sub(prev_symbol + _parent +
post_symbol, _c_selector, p_selector)
if p_selector != new_parent:
new_selectors.add(new_parent)
found = True
if found:
parent_found = parent_found or []
parent_found.extend(p_rules)
if new_selectors:
new_selectors = self.normalize_selectors(
p_selectors, new_selectors)
if new_selectors != p_selectors:
del self.parts[p_selectors]
self.parts.setdefault(new_selectors, [])
self.parts[new_selectors].extend(p_rules)
deps = set()
for c_rule in c_rules or []:
c_rule[SELECTORS] = c_selectors
deps.add(c_rule[POSITION])
for p_rule in p_rules:
p_rule[SELECTORS] = new_selectors
p_rule[DEPS].update(
deps)
return parent_found |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:parse_extends; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 87; 5, 91; 5, 95; 6, for_statement; 6, 7; 6, 10; 6, 17; 7, pattern_list; 7, 8; 7, 9; 8, identifier:_selectors; 9, identifier:rules; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:parts; 15, identifier:items; 16, argument_list; 17, block; 17, 18; 18, if_statement; 18, 19; 18, 22; 19, comparison_operator:in; 19, 20; 19, 21; 20, string:' extends '; 21, identifier:_selectors; 22, block; 22, 23; 22, 35; 22, 44; 22, 50; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 29; 25, pattern_list; 25, 26; 25, 27; 25, 28; 26, identifier:selectors; 27, identifier:_; 28, identifier:parent; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:_selectors; 32, identifier:partition; 33, argument_list; 33, 34; 34, string:' extends '; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:parents; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:parent; 41, identifier:split; 42, argument_list; 42, 43; 43, string:'&'; 44, delete_statement; 44, 45; 45, subscript; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:parts; 49, identifier:_selectors; 50, for_statement; 50, 51; 50, 52; 50, 53; 51, identifier:parent; 52, identifier:parents; 53, block; 53, 54; 53, 62; 53, 72; 53, 83; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:new_selectors; 57, binary_operator:+; 57, 58; 57, 61; 58, binary_operator:+; 58, 59; 58, 60; 59, identifier:selectors; 60, string:' extends '; 61, identifier:parent; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:parts; 68, identifier:setdefault; 69, argument_list; 69, 70; 69, 71; 70, identifier:new_selectors; 71, list:[]; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 81; 74, attribute; 74, 75; 74, 80; 75, subscript; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:parts; 79, identifier:new_selectors; 80, identifier:extend; 81, argument_list; 81, 82; 82, identifier:rules; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:rules; 86, list:[]; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:cnt; 90, integer:0; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:parents_left; 94, True; 95, while_statement; 95, 96; 95, 101; 96, boolean_operator:and; 96, 97; 96, 98; 97, identifier:parents_left; 98, comparison_operator:<; 98, 99; 98, 100; 99, identifier:cnt; 100, integer:10; 101, block; 101, 102; 101, 106; 101, 110; 102, expression_statement; 102, 103; 103, augmented_assignment:+=; 103, 104; 103, 105; 104, identifier:cnt; 105, integer:1; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:parents_left; 109, False; 110, for_statement; 110, 111; 110, 112; 110, 119; 111, identifier:_selectors; 112, call; 112, 113; 112, 118; 113, attribute; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:parts; 117, identifier:keys; 118, argument_list; 119, block; 119, 120; 119, 132; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 126; 122, pattern_list; 122, 123; 122, 124; 122, 125; 123, identifier:selectors; 124, identifier:_; 125, identifier:parent; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:_selectors; 129, identifier:partition; 130, argument_list; 130, 131; 131, string:' extends '; 132, if_statement; 132, 133; 132, 134; 133, identifier:parent; 134, block; 134, 135; 134, 139; 134, 147; 134, 155; 134, 161; 134, 171; 134, 182; 134, 193; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:parents_left; 138, True; 139, if_statement; 139, 140; 139, 145; 140, comparison_operator:not; 140, 141; 140, 142; 141, identifier:_selectors; 142, attribute; 142, 143; 142, 144; 143, identifier:self; 144, identifier:parts; 145, block; 145, 146; 146, continue_statement; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:rules; 150, subscript; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:parts; 154, identifier:_selectors; 155, delete_statement; 155, 156; 156, subscript; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:parts; 160, identifier:_selectors; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 168; 163, attribute; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:self; 166, identifier:parts; 167, identifier:setdefault; 168, argument_list; 168, 169; 168, 170; 169, identifier:selectors; 170, list:[]; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 180; 173, attribute; 173, 174; 173, 179; 174, subscript; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:parts; 178, identifier:selectors; 179, identifier:extend; 180, argument_list; 180, 181; 181, identifier:rules; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:parents; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:link_with_parents; 189, argument_list; 189, 190; 189, 191; 189, 192; 190, identifier:parent; 191, identifier:selectors; 192, identifier:rules; 193, if_statement; 193, 194; 193, 197; 193, 206; 194, comparison_operator:is; 194, 195; 194, 196; 195, identifier:parents; 196, None; 197, block; 197, 198; 198, expression_statement; 198, 199; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:log; 202, identifier:warn; 203, argument_list; 203, 204; 203, 205; 204, string:"Parent rule not found: %s"; 205, identifier:parent; 206, else_clause; 206, 207; 207, block; 207, 208; 207, 212; 207, 216; 207, 238; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:new_context; 211, dictionary; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:new_options; 215, dictionary; 216, for_statement; 216, 217; 216, 218; 216, 219; 217, identifier:parent; 218, identifier:parents; 219, block; 219, 220; 219, 229; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:new_context; 224, identifier:update; 225, argument_list; 225, 226; 226, subscript; 226, 227; 226, 228; 227, identifier:parent; 228, identifier:CONTEXT; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:new_options; 233, identifier:update; 234, argument_list; 234, 235; 235, subscript; 235, 236; 235, 237; 236, identifier:parent; 237, identifier:OPTIONS; 238, for_statement; 238, 239; 238, 240; 238, 241; 239, identifier:rule; 240, identifier:rules; 241, block; 241, 242; 241, 250; 241, 259; 241, 265; 241, 273; 241, 282; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:_new_context; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:new_context; 248, identifier:copy; 249, argument_list; 250, expression_statement; 250, 251; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:_new_context; 254, identifier:update; 255, argument_list; 255, 256; 256, subscript; 256, 257; 256, 258; 257, identifier:rule; 258, identifier:CONTEXT; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 264; 261, subscript; 261, 262; 261, 263; 262, identifier:rule; 263, identifier:CONTEXT; 264, identifier:_new_context; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:_new_options; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:new_options; 271, identifier:copy; 272, argument_list; 273, expression_statement; 273, 274; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:_new_options; 277, identifier:update; 278, argument_list; 278, 279; 279, subscript; 279, 280; 279, 281; 280, identifier:rule; 281, identifier:OPTIONS; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 287; 284, subscript; 284, 285; 284, 286; 285, identifier:rule; 286, identifier:OPTIONS; 287, identifier:_new_options | def parse_extends(self):
for _selectors, rules in self.parts.items():
if ' extends ' in _selectors:
selectors, _, parent = _selectors.partition(' extends ')
parents = parent.split('&')
del self.parts[_selectors]
for parent in parents:
new_selectors = selectors + ' extends ' + parent
self.parts.setdefault(new_selectors, [])
self.parts[new_selectors].extend(rules)
rules = []
cnt = 0
parents_left = True
while parents_left and cnt < 10:
cnt += 1
parents_left = False
for _selectors in self.parts.keys():
selectors, _, parent = _selectors.partition(' extends ')
if parent:
parents_left = True
if _selectors not in self.parts:
continue
rules = self.parts[_selectors]
del self.parts[_selectors]
self.parts.setdefault(selectors, [])
self.parts[selectors].extend(rules)
parents = self.link_with_parents(parent, selectors, rules)
if parents is None:
log.warn("Parent rule not found: %s", parent)
else:
new_context = {}
new_options = {}
for parent in parents:
new_context.update(parent[CONTEXT])
new_options.update(parent[OPTIONS])
for rule in rules:
_new_context = new_context.copy()
_new_context.update(rule[CONTEXT])
rule[CONTEXT] = _new_context
_new_options = new_options.copy()
_new_options.update(rule[OPTIONS])
rule[OPTIONS] = _new_options |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:scan; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:restrict; 6, block; 6, 7; 6, 189; 7, while_statement; 7, 8; 7, 9; 8, True; 9, block; 9, 10; 9, 14; 9, 18; 9, 74; 9, 105; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:best_pat; 13, None; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:best_pat_len; 17, integer:0; 18, for_statement; 18, 19; 18, 22; 18, 25; 19, pattern_list; 19, 20; 19, 21; 20, identifier:p; 21, identifier:regexp; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:patterns; 25, block; 25, 26; 25, 40; 25, 54; 26, if_statement; 26, 27; 26, 38; 27, boolean_operator:and; 27, 28; 27, 33; 28, boolean_operator:and; 28, 29; 28, 30; 29, identifier:restrict; 30, comparison_operator:not; 30, 31; 30, 32; 31, identifier:p; 32, identifier:restrict; 33, comparison_operator:not; 33, 34; 33, 35; 34, identifier:p; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:ignore; 38, block; 38, 39; 39, continue_statement; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:m; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:regexp; 46, identifier:match; 47, argument_list; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:input; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:pos; 54, if_statement; 54, 55; 54, 56; 55, identifier:m; 56, block; 56, 57; 56, 61; 56, 73; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:best_pat; 60, identifier:p; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:best_pat_len; 64, call; 64, 65; 64, 66; 65, identifier:len; 66, argument_list; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:m; 70, identifier:group; 71, argument_list; 71, 72; 72, integer:0; 73, break_statement; 74, if_statement; 74, 75; 74, 78; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:best_pat; 77, None; 78, block; 78, 79; 78, 83; 78, 97; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:msg; 82, string:"Bad Token"; 83, if_statement; 83, 84; 83, 85; 84, identifier:restrict; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:msg; 89, binary_operator:+; 89, 90; 89, 91; 90, string:"Trying to find one of "; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, string:", "; 94, identifier:join; 95, argument_list; 95, 96; 96, identifier:restrict; 97, raise_statement; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:SyntaxError; 100, argument_list; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:pos; 104, identifier:msg; 105, if_statement; 105, 106; 105, 111; 105, 118; 106, comparison_operator:in; 106, 107; 106, 108; 107, identifier:best_pat; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:ignore; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, augmented_assignment:+=; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:pos; 117, identifier:best_pat_len; 118, else_clause; 118, 119; 119, block; 119, 120; 119, 128; 119, 147; 119, 153; 119, 188; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:end_pos; 123, binary_operator:+; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:pos; 127, identifier:best_pat_len; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:token; 131, tuple; 131, 132; 131, 135; 131, 136; 131, 137; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:pos; 135, identifier:end_pos; 136, identifier:best_pat; 137, subscript; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:self; 140, identifier:input; 141, slice; 141, 142; 141, 145; 141, 146; 142, attribute; 142, 143; 142, 144; 143, identifier:self; 144, identifier:pos; 145, colon; 146, identifier:end_pos; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:pos; 152, identifier:end_pos; 153, if_statement; 153, 154; 153, 167; 154, boolean_operator:or; 154, 155; 154, 159; 155, not_operator; 155, 156; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:tokens; 159, comparison_operator:!=; 159, 160; 159, 161; 160, identifier:token; 161, subscript; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:tokens; 165, unary_operator:-; 165, 166; 166, integer:1; 167, block; 167, 168; 167, 177; 167, 186; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 175; 170, attribute; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:tokens; 174, identifier:append; 175, argument_list; 175, 176; 176, identifier:token; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 184; 179, attribute; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:restrictions; 183, identifier:append; 184, argument_list; 184, 185; 185, identifier:restrict; 186, return_statement; 186, 187; 187, integer:1; 188, break_statement; 189, return_statement; 189, 190; 190, integer:0 | def scan(self, restrict):
while True:
best_pat = None
best_pat_len = 0
for p, regexp in self.patterns:
if restrict and p not in restrict and p not in self.ignore:
continue
m = regexp.match(self.input, self.pos)
if m:
best_pat = p
best_pat_len = len(m.group(0))
break
if best_pat is None:
msg = "Bad Token"
if restrict:
msg = "Trying to find one of " + ", ".join(restrict)
raise SyntaxError(self.pos, msg)
if best_pat in self.ignore:
self.pos += best_pat_len
else:
end_pos = self.pos + best_pat_len
token = (
self.pos,
end_pos,
best_pat,
self.input[self.pos:end_pos]
)
self.pos = end_pos
if not self.tokens or token != self.tokens[-1]:
self.tokens.append(token)
self.restrictions.append(restrict)
return 1
break
return 0 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:read_form_data; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 18; 5, 24; 6, if_statement; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:self; 9, identifier:processed_data; 10, block; 10, 11; 11, raise_statement; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:exceptions; 15, identifier:AlreadyProcessed; 16, argument_list; 16, 17; 17, string:'The data has already been processed for this form'; 18, if_statement; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:readonly; 22, block; 22, 23; 23, return_statement; 24, if_statement; 24, 25; 24, 32; 25, comparison_operator:==; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:request; 28, identifier:method; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:method; 32, block; 32, 33; 32, 54; 33, if_statement; 33, 34; 33, 39; 33, 46; 34, comparison_operator:==; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:method; 38, string:'POST'; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:data; 43, attribute; 43, 44; 43, 45; 44, identifier:request; 45, identifier:form; 46, else_clause; 46, 47; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:data; 51, attribute; 51, 52; 51, 53; 52, identifier:request; 53, identifier:args; 54, if_statement; 54, 55; 54, 60; 55, comparison_operator:in; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:submitted_hidden_input_name; 59, identifier:data; 60, block; 60, 61; 60, 67; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:processed_data; 66, True; 67, for_statement; 67, 68; 67, 69; 67, 72; 68, identifier:field; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:all_fields; 72, block; 72, 73; 73, if_statement; 73, 74; 73, 77; 73, 79; 74, attribute; 74, 75; 74, 76; 75, identifier:field; 76, identifier:readonly; 77, block; 77, 78; 78, pass_statement; 79, else_clause; 79, 80; 80, block; 80, 81; 80, 88; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:field; 85, identifier:extract_value; 86, argument_list; 86, 87; 87, identifier:data; 88, if_statement; 88, 89; 88, 95; 89, not_operator; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:field; 93, identifier:validate; 94, argument_list; 95, block; 95, 96; 95, 111; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:log; 100, identifier:debug; 101, argument_list; 101, 102; 102, binary_operator:%; 102, 103; 102, 104; 103, string:'Validation error in field \'%s\': %s'; 104, tuple; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:field; 107, identifier:name; 108, attribute; 108, 109; 108, 110; 109, identifier:field; 110, identifier:error; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:has_errors; 116, True | def read_form_data(self):
if self.processed_data:
raise exceptions.AlreadyProcessed('The data has already been processed for this form')
if self.readonly:
return
if request.method == self.method:
if self.method == 'POST':
data = request.form
else:
data = request.args
if self.submitted_hidden_input_name in data:
self.processed_data = True
for field in self.all_fields:
if field.readonly:
pass
else:
field.extract_value(data)
if not field.validate():
log.debug('Validation error in field \'%s\': %s' % (field.name, field.error))
self.has_errors = True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_imm_trans_setattr; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:name; 6, identifier:value; 7, block; 7, 8; 7, 10; 7, 17; 7, 27; 8, expression_statement; 8, 9; 9, string:'''
An immutable's transient setattr allows params to be set, and runs checks as they are.
'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:params; 13, call; 13, 14; 13, 15; 14, identifier:_imm_param_data; 15, argument_list; 15, 16; 16, identifier:self; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:dd; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:object; 23, identifier:__getattribute__; 24, argument_list; 24, 25; 24, 26; 25, identifier:self; 26, string:'__dict__'; 27, if_statement; 27, 28; 27, 31; 27, 166; 28, comparison_operator:in; 28, 29; 28, 30; 29, identifier:name; 30, identifier:params; 31, block; 31, 32; 31, 43; 31, 55; 31, 59; 31, 65; 31, 86; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 40; 34, tuple_pattern; 34, 35; 34, 36; 34, 37; 34, 38; 34, 39; 35, identifier:_; 36, identifier:tx_fn; 37, identifier:arg_lists; 38, identifier:check_fns; 39, identifier:deps; 40, subscript; 40, 41; 40, 42; 41, identifier:params; 42, identifier:name; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:value; 46, conditional_expression:if; 46, 47; 46, 48; 46, 51; 47, identifier:value; 48, comparison_operator:is; 48, 49; 48, 50; 49, identifier:tx_fn; 50, None; 51, call; 51, 52; 51, 53; 52, identifier:tx_fn; 53, argument_list; 53, 54; 54, identifier:value; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:old_deps; 58, dictionary; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:orig_value; 62, subscript; 62, 63; 62, 64; 63, identifier:dd; 64, identifier:name; 65, for_statement; 65, 66; 65, 67; 65, 68; 66, identifier:dep; 67, identifier:deps; 68, block; 68, 69; 69, if_statement; 69, 70; 69, 73; 70, comparison_operator:in; 70, 71; 70, 72; 71, identifier:dep; 72, identifier:dd; 73, block; 73, 74; 73, 82; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:old_deps; 78, identifier:dep; 79, subscript; 79, 80; 79, 81; 80, identifier:dd; 81, identifier:dep; 82, delete_statement; 82, 83; 83, subscript; 83, 84; 83, 85; 84, identifier:dd; 85, identifier:dep; 86, try_statement; 86, 87; 86, 138; 87, block; 87, 88; 87, 94; 87, 134; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:dd; 92, identifier:name; 93, identifier:value; 94, for_statement; 94, 95; 94, 98; 94, 103; 95, tuple_pattern; 95, 96; 95, 97; 96, identifier:args; 97, identifier:check_fn; 98, call; 98, 99; 98, 100; 99, identifier:zip; 100, argument_list; 100, 101; 100, 102; 101, identifier:arg_lists; 102, identifier:check_fns; 103, block; 103, 104; 104, if_statement; 104, 105; 104, 119; 105, not_operator; 105, 106; 106, call; 106, 107; 106, 108; 107, identifier:check_fn; 108, argument_list; 108, 109; 109, list_splat; 109, 110; 110, list_comprehension; 110, 111; 110, 116; 111, call; 111, 112; 111, 113; 112, identifier:getattr; 113, argument_list; 113, 114; 113, 115; 114, identifier:self; 115, identifier:arg; 116, for_in_clause; 116, 117; 116, 118; 117, identifier:arg; 118, identifier:args; 119, block; 119, 120; 120, raise_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:RuntimeError; 123, argument_list; 123, 124; 124, binary_operator:%; 124, 125; 124, 129; 125, parenthesized_expression; 125, 126; 126, binary_operator:+; 126, 127; 126, 128; 127, string:'Changing value of immutable attribute \'%s\''; 128, string:' caused validation failure: %s'; 129, tuple; 129, 130; 129, 131; 130, identifier:name; 131, tuple; 131, 132; 131, 133; 132, identifier:args; 133, identifier:check_fn; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:old_deps; 137, None; 138, finally_clause; 138, 139; 139, block; 139, 140; 140, if_statement; 140, 141; 140, 142; 141, identifier:old_deps; 142, block; 142, 143; 142, 160; 143, for_statement; 143, 144; 143, 147; 143, 153; 144, tuple_pattern; 144, 145; 144, 146; 145, identifier:dep; 146, identifier:val; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:six; 150, identifier:iteritems; 151, argument_list; 151, 152; 152, identifier:old_deps; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:dd; 158, identifier:dep; 159, identifier:val; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:dd; 164, identifier:name; 165, identifier:orig_value; 166, else_clause; 166, 167; 167, block; 167, 168; 168, raise_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:TypeError; 171, argument_list; 171, 172; 172, binary_operator:%; 172, 173; 172, 174; 173, string:'Attempt to change non-parameter member \'%s\' of transient immutable'; 174, identifier:name | def _imm_trans_setattr(self, name, value):
'''
An immutable's transient setattr allows params to be set, and runs checks as they are.
'''
params = _imm_param_data(self)
dd = object.__getattribute__(self, '__dict__')
if name in params:
(_, tx_fn, arg_lists, check_fns, deps) = params[name]
value = value if tx_fn is None else tx_fn(value)
old_deps = {}
orig_value = dd[name]
for dep in deps:
if dep in dd:
old_deps[dep] = dd[dep]
del dd[dep]
try:
dd[name] = value
for (args, check_fn) in zip(arg_lists, check_fns):
if not check_fn(*[getattr(self, arg) for arg in args]):
raise RuntimeError(
('Changing value of immutable attribute \'%s\'' +
' caused validation failure: %s') % (name, (args, check_fn)))
old_deps = None
finally:
if old_deps:
for (dep,val) in six.iteritems(old_deps):
dd[dep] = val
dd[name] = orig_value
else:
raise TypeError(
'Attempt to change non-parameter member \'%s\' of transient immutable' % name) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:verify_consistency; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:predictions; 5, identifier:scores; 6, identifier:proba; 7, identifier:opt_class; 8, block; 8, 9; 8, 25; 8, 40; 8, 55; 8, 70; 8, 85; 8, 100; 8, 115; 8, 132; 8, 149; 8, 207; 9, if_statement; 9, 10; 9, 17; 10, comparison_operator:!=; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:predictions; 13, identifier:shape; 14, attribute; 14, 15; 14, 16; 15, identifier:scores; 16, identifier:shape; 17, block; 17, 18; 18, raise_statement; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:ValueError; 21, argument_list; 21, 22; 22, binary_operator:+; 22, 23; 22, 24; 23, string:"predictions and scores arrays have inconsistent "; 24, string:"dimensions."; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:n_class; 28, conditional_expression:if; 28, 29; 28, 34; 28, 39; 29, subscript; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:scores; 32, identifier:shape; 33, integer:1; 34, comparison_operator:>; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:scores; 37, identifier:ndim; 38, integer:1; 39, integer:1; 40, if_statement; 40, 41; 40, 44; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:proba; 43, None; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:proba; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:np; 51, identifier:repeat; 52, argument_list; 52, 53; 52, 54; 53, False; 54, identifier:n_class; 55, if_statement; 55, 56; 55, 59; 56, comparison_operator:is; 56, 57; 56, 58; 57, identifier:opt_class; 58, None; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:opt_class; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:np; 66, identifier:repeat; 67, argument_list; 67, 68; 67, 69; 68, True; 69, identifier:n_class; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:proba; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:np; 76, identifier:array; 77, argument_list; 77, 78; 77, 79; 77, 82; 78, identifier:proba; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:dtype; 81, identifier:bool; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:ndmin; 84, integer:1; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:opt_class; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:np; 91, identifier:array; 92, argument_list; 92, 93; 92, 94; 92, 97; 93, identifier:opt_class; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:dtype; 96, identifier:bool; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:ndmin; 99, integer:1; 100, if_statement; 100, 101; 100, 109; 101, comparison_operator:<; 101, 102; 101, 108; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:np; 105, identifier:sum; 106, argument_list; 106, 107; 107, identifier:opt_class; 108, integer:1; 109, block; 109, 110; 110, raise_statement; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:ValueError; 113, argument_list; 113, 114; 114, string:"opt_class should contain at least one True value."; 115, if_statement; 115, 116; 115, 126; 116, comparison_operator:!=; 116, 117; 116, 122; 117, subscript; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:predictions; 120, identifier:shape; 121, integer:1; 122, call; 122, 123; 122, 124; 123, identifier:len; 124, argument_list; 124, 125; 125, identifier:proba; 126, block; 126, 127; 127, raise_statement; 127, 128; 128, call; 128, 129; 128, 130; 129, identifier:ValueError; 130, argument_list; 130, 131; 131, string:"mismatch in shape of proba and predictions."; 132, if_statement; 132, 133; 132, 143; 133, comparison_operator:!=; 133, 134; 133, 139; 134, subscript; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:predictions; 137, identifier:shape; 138, integer:1; 139, call; 139, 140; 139, 141; 140, identifier:len; 141, argument_list; 141, 142; 142, identifier:opt_class; 143, block; 143, 144; 144, raise_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:ValueError; 147, argument_list; 147, 148; 148, string:"mismatch in shape of opt_class and predictions."; 149, for_statement; 149, 150; 149, 151; 149, 155; 150, identifier:m; 151, call; 151, 152; 151, 153; 152, identifier:range; 153, argument_list; 153, 154; 154, identifier:n_class; 155, block; 155, 156; 156, if_statement; 156, 157; 156, 186; 157, parenthesized_expression; 157, 158; 158, boolean_operator:and; 158, 159; 158, 183; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:np; 162, identifier:any; 163, argument_list; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:np; 167, identifier:logical_or; 168, argument_list; 168, 169; 168, 176; 169, comparison_operator:<; 169, 170; 169, 175; 170, subscript; 170, 171; 170, 172; 170, 174; 171, identifier:scores; 172, slice; 172, 173; 173, colon; 174, identifier:m; 175, integer:0; 176, comparison_operator:>; 176, 177; 176, 182; 177, subscript; 177, 178; 177, 179; 177, 181; 178, identifier:scores; 179, slice; 179, 180; 180, colon; 181, identifier:m; 182, integer:1; 183, subscript; 183, 184; 183, 185; 184, identifier:proba; 185, identifier:m; 186, block; 186, 187; 186, 201; 187, expression_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:warnings; 191, identifier:warn; 192, argument_list; 192, 193; 193, binary_operator:+; 193, 194; 193, 195; 194, string:"scores fall outside the [0,1] interval for "; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, string:"classifier {}. Setting proba[m]=False."; 198, identifier:format; 199, argument_list; 199, 200; 200, identifier:m; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 206; 203, subscript; 203, 204; 203, 205; 204, identifier:proba; 205, identifier:m; 206, False; 207, return_statement; 207, 208; 208, expression_list; 208, 209; 208, 210; 209, identifier:proba; 210, identifier:opt_class | def verify_consistency(predictions, scores, proba, opt_class):
if predictions.shape != scores.shape:
raise ValueError("predictions and scores arrays have inconsistent " +
"dimensions.")
n_class = scores.shape[1] if scores.ndim > 1 else 1
if proba is None:
proba = np.repeat(False, n_class)
if opt_class is None:
opt_class = np.repeat(True, n_class)
proba = np.array(proba, dtype=bool, ndmin=1)
opt_class = np.array(opt_class, dtype=bool, ndmin=1)
if np.sum(opt_class) < 1:
raise ValueError("opt_class should contain at least one True value.")
if predictions.shape[1] != len(proba):
raise ValueError("mismatch in shape of proba and predictions.")
if predictions.shape[1] != len(opt_class):
raise ValueError("mismatch in shape of opt_class and predictions.")
for m in range(n_class):
if (np.any(np.logical_or(scores[:,m] < 0, scores[:,m] > 1)) and proba[m]):
warnings.warn("scores fall outside the [0,1] interval for " +
"classifier {}. Setting proba[m]=False.".format(m))
proba[m] = False
return proba, opt_class |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_call; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:context; 6, block; 6, 7; 6, 13; 6, 28; 6, 34; 6, 45; 6, 54; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:req; 10, attribute; 10, 11; 10, 12; 11, identifier:context; 12, identifier:request; 13, if_statement; 13, 14; 13, 21; 14, not_operator; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:req; 18, identifier:has_key; 19, argument_list; 19, 20; 20, string:"method"; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:RpcException; 25, argument_list; 25, 26; 25, 27; 26, identifier:ERR_INVALID_REQ; 27, string:"Invalid Request. No 'method'."; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:method; 31, subscript; 31, 32; 31, 33; 32, identifier:req; 33, string:"method"; 34, if_statement; 34, 35; 34, 38; 35, comparison_operator:==; 35, 36; 35, 37; 36, identifier:method; 37, string:"barrister-idl"; 38, block; 38, 39; 39, return_statement; 39, 40; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:contract; 44, identifier:idl_parsed; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, pattern_list; 47, 48; 47, 49; 48, identifier:iface_name; 49, identifier:func_name; 50, call; 50, 51; 50, 52; 51, identifier:unpack_method; 52, argument_list; 52, 53; 53, identifier:method; 54, if_statement; 54, 55; 54, 63; 54, 192; 55, call; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:handlers; 60, identifier:has_key; 61, argument_list; 61, 62; 62, identifier:iface_name; 63, block; 63, 64; 63, 72; 63, 80; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:iface_impl; 67, subscript; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:handlers; 71, identifier:iface_name; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:func; 75, call; 75, 76; 75, 77; 76, identifier:getattr; 77, argument_list; 77, 78; 77, 79; 78, identifier:iface_impl; 79, identifier:func_name; 80, if_statement; 80, 81; 80, 82; 80, 177; 81, identifier:func; 82, block; 82, 83; 82, 103; 82, 119; 82, 140; 82, 159; 82, 175; 83, if_statement; 83, 84; 83, 90; 83, 97; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:req; 87, identifier:has_key; 88, argument_list; 88, 89; 89, string:"params"; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:params; 94, subscript; 94, 95; 94, 96; 95, identifier:req; 96, string:"params"; 97, else_clause; 97, 98; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:params; 102, list:[ ]; 103, if_statement; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:validate_req; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 115; 110, attribute; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:contract; 114, identifier:validate_request; 115, argument_list; 115, 116; 115, 117; 115, 118; 116, identifier:iface_name; 117, identifier:func_name; 118, identifier:params; 119, if_statement; 119, 120; 119, 125; 120, call; 120, 121; 120, 122; 121, identifier:hasattr; 122, argument_list; 122, 123; 122, 124; 123, identifier:iface_impl; 124, string:"barrister_pre"; 125, block; 125, 126; 125, 134; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:pre_hook; 129, call; 129, 130; 129, 131; 130, identifier:getattr; 131, argument_list; 131, 132; 131, 133; 132, identifier:iface_impl; 133, string:"barrister_pre"; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:pre_hook; 137, argument_list; 137, 138; 137, 139; 138, identifier:context; 139, identifier:params; 140, if_statement; 140, 141; 140, 142; 140, 151; 141, identifier:params; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:result; 146, call; 146, 147; 146, 148; 147, identifier:func; 148, argument_list; 148, 149; 149, list_splat; 149, 150; 150, identifier:params; 151, else_clause; 151, 152; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:result; 156, call; 156, 157; 156, 158; 157, identifier:func; 158, argument_list; 159, if_statement; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:validate_resp; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 171; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:self; 169, identifier:contract; 170, identifier:validate_response; 171, argument_list; 171, 172; 171, 173; 171, 174; 172, identifier:iface_name; 173, identifier:func_name; 174, identifier:result; 175, return_statement; 175, 176; 176, identifier:result; 177, else_clause; 177, 178; 178, block; 178, 179; 178, 186; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:msg; 182, binary_operator:%; 182, 183; 182, 184; 183, string:"Method '%s' not found"; 184, parenthesized_expression; 184, 185; 185, identifier:method; 186, raise_statement; 186, 187; 187, call; 187, 188; 187, 189; 188, identifier:RpcException; 189, argument_list; 189, 190; 189, 191; 190, identifier:ERR_METHOD_NOT_FOUND; 191, identifier:msg; 192, else_clause; 192, 193; 193, block; 193, 194; 193, 201; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:msg; 197, binary_operator:%; 197, 198; 197, 199; 198, string:"No implementation of '%s' found"; 199, parenthesized_expression; 199, 200; 200, identifier:iface_name; 201, raise_statement; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:RpcException; 204, argument_list; 204, 205; 204, 206; 205, identifier:ERR_METHOD_NOT_FOUND; 206, identifier:msg | def _call(self, context):
req = context.request
if not req.has_key("method"):
raise RpcException(ERR_INVALID_REQ, "Invalid Request. No 'method'.")
method = req["method"]
if method == "barrister-idl":
return self.contract.idl_parsed
iface_name, func_name = unpack_method(method)
if self.handlers.has_key(iface_name):
iface_impl = self.handlers[iface_name]
func = getattr(iface_impl, func_name)
if func:
if req.has_key("params"):
params = req["params"]
else:
params = [ ]
if self.validate_req:
self.contract.validate_request(iface_name, func_name, params)
if hasattr(iface_impl, "barrister_pre"):
pre_hook = getattr(iface_impl, "barrister_pre")
pre_hook(context, params)
if params:
result = func(*params)
else:
result = func()
if self.validate_resp:
self.contract.validate_response(iface_name, func_name, result)
return result
else:
msg = "Method '%s' not found" % (method)
raise RpcException(ERR_METHOD_NOT_FOUND, msg)
else:
msg = "No implementation of '%s' found" % (iface_name)
raise RpcException(ERR_METHOD_NOT_FOUND, msg) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:validate; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:expected_type; 6, identifier:is_array; 7, identifier:val; 8, block; 8, 9; 8, 190; 9, if_statement; 9, 10; 9, 13; 9, 29; 9, 75; 9, 100; 9, 126; 9, 149; 9, 174; 10, comparison_operator:==; 10, 11; 10, 12; 11, identifier:val; 12, None; 13, block; 13, 14; 14, if_statement; 14, 15; 14, 18; 14, 23; 15, attribute; 15, 16; 15, 17; 16, identifier:expected_type; 17, identifier:optional; 18, block; 18, 19; 19, return_statement; 19, 20; 20, expression_list; 20, 21; 20, 22; 21, True; 22, None; 23, else_clause; 23, 24; 24, block; 24, 25; 25, return_statement; 25, 26; 26, expression_list; 26, 27; 26, 28; 27, False; 28, string:"Value cannot be null"; 29, elif_clause; 29, 30; 29, 31; 30, identifier:is_array; 31, block; 31, 32; 32, if_statement; 32, 33; 32, 39; 32, 48; 33, not_operator; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:isinstance; 36, argument_list; 36, 37; 36, 38; 37, identifier:val; 38, identifier:list; 39, block; 39, 40; 40, return_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:_type_err; 45, argument_list; 45, 46; 45, 47; 46, identifier:val; 47, string:"list"; 48, else_clause; 48, 49; 49, block; 49, 50; 50, for_statement; 50, 51; 50, 52; 50, 53; 51, identifier:v; 52, identifier:val; 53, block; 53, 54; 53, 67; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, pattern_list; 56, 57; 56, 58; 57, identifier:ok; 58, identifier:msg; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:validate; 63, argument_list; 63, 64; 63, 65; 63, 66; 64, identifier:expected_type; 65, False; 66, identifier:v; 67, if_statement; 67, 68; 67, 70; 68, not_operator; 68, 69; 69, identifier:ok; 70, block; 70, 71; 71, return_statement; 71, 72; 72, expression_list; 72, 73; 72, 74; 73, identifier:ok; 74, identifier:msg; 75, elif_clause; 75, 76; 75, 81; 76, comparison_operator:==; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:expected_type; 79, identifier:type; 80, string:"int"; 81, block; 81, 82; 82, if_statement; 82, 83; 82, 91; 83, not_operator; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:isinstance; 86, argument_list; 86, 87; 86, 88; 87, identifier:val; 88, tuple; 88, 89; 88, 90; 89, identifier:long; 90, identifier:int; 91, block; 91, 92; 92, return_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:_type_err; 97, argument_list; 97, 98; 97, 99; 98, identifier:val; 99, string:"int"; 100, elif_clause; 100, 101; 100, 106; 101, comparison_operator:==; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:expected_type; 104, identifier:type; 105, string:"float"; 106, block; 106, 107; 107, if_statement; 107, 108; 107, 117; 108, not_operator; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:isinstance; 111, argument_list; 111, 112; 111, 113; 112, identifier:val; 113, tuple; 113, 114; 113, 115; 113, 116; 114, identifier:float; 115, identifier:int; 116, identifier:long; 117, block; 117, 118; 118, return_statement; 118, 119; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:_type_err; 123, argument_list; 123, 124; 123, 125; 124, identifier:val; 125, string:"float"; 126, elif_clause; 126, 127; 126, 132; 127, comparison_operator:==; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:expected_type; 130, identifier:type; 131, string:"bool"; 132, block; 132, 133; 133, if_statement; 133, 134; 133, 140; 134, not_operator; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:isinstance; 137, argument_list; 137, 138; 137, 139; 138, identifier:val; 139, identifier:bool; 140, block; 140, 141; 141, return_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:_type_err; 146, argument_list; 146, 147; 146, 148; 147, identifier:val; 148, string:"bool"; 149, elif_clause; 149, 150; 149, 155; 150, comparison_operator:==; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:expected_type; 153, identifier:type; 154, string:"string"; 155, block; 155, 156; 156, if_statement; 156, 157; 156, 165; 157, not_operator; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:isinstance; 160, argument_list; 160, 161; 160, 162; 161, identifier:val; 162, tuple; 162, 163; 162, 164; 163, identifier:str; 164, identifier:unicode; 165, block; 165, 166; 166, return_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:_type_err; 171, argument_list; 171, 172; 171, 173; 172, identifier:val; 173, string:"string"; 174, else_clause; 174, 175; 175, block; 175, 176; 176, return_statement; 176, 177; 177, call; 177, 178; 177, 188; 178, attribute; 178, 179; 178, 187; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:get; 183, argument_list; 183, 184; 184, attribute; 184, 185; 184, 186; 185, identifier:expected_type; 186, identifier:type; 187, identifier:validate; 188, argument_list; 188, 189; 189, identifier:val; 190, return_statement; 190, 191; 191, expression_list; 191, 192; 191, 193; 192, True; 193, None | def validate(self, expected_type, is_array, val):
if val == None:
if expected_type.optional:
return True, None
else:
return False, "Value cannot be null"
elif is_array:
if not isinstance(val, list):
return self._type_err(val, "list")
else:
for v in val:
ok, msg = self.validate(expected_type, False, v)
if not ok:
return ok, msg
elif expected_type.type == "int":
if not isinstance(val, (long, int)):
return self._type_err(val, "int")
elif expected_type.type == "float":
if not isinstance(val, (float, int, long)):
return self._type_err(val, "float")
elif expected_type.type == "bool":
if not isinstance(val, bool):
return self._type_err(val, "bool")
elif expected_type.type == "string":
if not isinstance(val, (str, unicode)):
return self._type_err(val, "string")
else:
return self.get(expected_type.type).validate(val)
return True, None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:validate; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:val; 6, block; 6, 7; 6, 25; 6, 90; 6, 99; 6, 132; 7, if_statement; 7, 8; 7, 14; 8, comparison_operator:is; 8, 9; 8, 13; 9, call; 9, 10; 9, 11; 10, identifier:type; 11, argument_list; 11, 12; 12, identifier:val; 13, identifier:dict; 14, block; 14, 15; 15, return_statement; 15, 16; 16, expression_list; 16, 17; 16, 18; 17, False; 18, binary_operator:%; 18, 19; 18, 20; 19, string:"%s is not a dict"; 20, parenthesized_expression; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:str; 23, argument_list; 23, 24; 24, identifier:val; 25, for_statement; 25, 26; 25, 29; 25, 34; 26, pattern_list; 26, 27; 26, 28; 27, identifier:k; 28, identifier:v; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:val; 32, identifier:items; 33, argument_list; 34, block; 34, 35; 34, 44; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:field; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:field; 42, argument_list; 42, 43; 43, identifier:k; 44, if_statement; 44, 45; 44, 46; 44, 78; 45, identifier:field; 46, block; 46, 47; 46, 64; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 52; 49, pattern_list; 49, 50; 49, 51; 50, identifier:ok; 51, identifier:msg; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:contract; 57, identifier:validate; 58, argument_list; 58, 59; 58, 60; 58, 63; 59, identifier:field; 60, attribute; 60, 61; 60, 62; 61, identifier:field; 62, identifier:is_array; 63, identifier:v; 64, if_statement; 64, 65; 64, 67; 65, not_operator; 65, 66; 66, identifier:ok; 67, block; 67, 68; 68, return_statement; 68, 69; 69, expression_list; 69, 70; 69, 71; 70, False; 71, binary_operator:%; 71, 72; 71, 73; 72, string:"field '%s': %s"; 73, tuple; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:field; 76, identifier:name; 77, identifier:msg; 78, else_clause; 78, 79; 79, block; 79, 80; 80, return_statement; 80, 81; 81, expression_list; 81, 82; 81, 83; 82, False; 83, binary_operator:%; 83, 84; 83, 85; 84, string:"field '%s' not found in struct %s"; 85, tuple; 85, 86; 85, 87; 86, identifier:k; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:name; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:all_fields; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:get_all_fields; 97, argument_list; 97, 98; 98, list:[]; 99, for_statement; 99, 100; 99, 101; 99, 102; 100, identifier:field; 101, identifier:all_fields; 102, block; 102, 103; 103, if_statement; 103, 104; 103, 118; 104, boolean_operator:and; 104, 105; 104, 114; 105, not_operator; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:val; 109, identifier:has_key; 110, argument_list; 110, 111; 111, attribute; 111, 112; 111, 113; 112, identifier:field; 113, identifier:name; 114, not_operator; 114, 115; 115, attribute; 115, 116; 115, 117; 116, identifier:field; 117, identifier:optional; 118, block; 118, 119; 119, return_statement; 119, 120; 120, expression_list; 120, 121; 120, 122; 121, False; 122, binary_operator:%; 122, 123; 122, 124; 123, string:"field '%s' missing from: %s"; 124, tuple; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:field; 127, identifier:name; 128, call; 128, 129; 128, 130; 129, identifier:str; 130, argument_list; 130, 131; 131, identifier:val; 132, return_statement; 132, 133; 133, expression_list; 133, 134; 133, 135; 134, True; 135, None | def validate(self, val):
if type(val) is not dict:
return False, "%s is not a dict" % (str(val))
for k, v in val.items():
field = self.field(k)
if field:
ok, msg = self.contract.validate(field, field.is_array, v)
if not ok:
return False, "field '%s': %s" % (field.name, msg)
else:
return False, "field '%s' not found in struct %s" % (k, self.name)
all_fields = self.get_all_fields([])
for field in all_fields:
if not val.has_key(field.name) and not field.optional:
return False, "field '%s' missing from: %s" % (field.name, str(val))
return True, None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:parse_struct; 3, parameters; 3, 4; 4, identifier:s; 5, block; 5, 6; 5, 12; 5, 20; 5, 33; 5, 37; 5, 41; 5, 45; 5, 92; 5, 96; 5, 100; 5, 104; 5, 108; 5, 207; 5, 211; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:docs; 9, subscript; 9, 10; 9, 11; 10, identifier:s; 11, string:'comment'; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:code; 15, binary_operator:%; 15, 16; 15, 17; 16, string:'<span class="k">struct</span> <span class="gs">%s</span>'; 17, subscript; 17, 18; 17, 19; 18, identifier:s; 19, string:'name'; 20, if_statement; 20, 21; 20, 24; 21, subscript; 21, 22; 21, 23; 22, identifier:s; 23, string:'extends'; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, augmented_assignment:+=; 26, 27; 26, 28; 27, identifier:code; 28, binary_operator:%; 28, 29; 28, 30; 29, string:' extends <span class="gs">%s</span>'; 30, subscript; 30, 31; 30, 32; 31, identifier:s; 32, string:'extends'; 33, expression_statement; 33, 34; 34, augmented_assignment:+=; 34, 35; 34, 36; 35, identifier:code; 36, string:' {\n'; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:namelen; 40, integer:0; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:typelen; 44, integer:0; 45, for_statement; 45, 46; 45, 47; 45, 50; 46, identifier:v; 47, subscript; 47, 48; 47, 49; 48, identifier:s; 49, string:"fields"; 50, block; 50, 51; 50, 64; 50, 83; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:tlen; 54, call; 54, 55; 54, 56; 55, identifier:len; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:format_type; 59, argument_list; 59, 60; 59, 61; 60, identifier:v; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:includeOptional; 63, False; 64, if_statement; 64, 65; 64, 73; 65, comparison_operator:>; 65, 66; 65, 72; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, subscript; 69, 70; 69, 71; 70, identifier:v; 71, string:'name'; 72, identifier:namelen; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:namelen; 77, call; 77, 78; 77, 79; 78, identifier:len; 79, argument_list; 79, 80; 80, subscript; 80, 81; 80, 82; 81, identifier:v; 82, string:'name'; 83, if_statement; 83, 84; 83, 87; 84, comparison_operator:>; 84, 85; 84, 86; 85, identifier:tlen; 86, identifier:typelen; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:typelen; 91, identifier:tlen; 92, expression_statement; 92, 93; 93, augmented_assignment:+=; 93, 94; 93, 95; 94, identifier:namelen; 95, integer:1; 96, expression_statement; 96, 97; 97, augmented_assignment:+=; 97, 98; 97, 99; 98, identifier:typelen; 99, integer:1; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:formatstr; 103, string:' <span class="nv">%s</span><span class="kt">%s %s</span>\n'; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:i; 107, integer:0; 108, for_statement; 108, 109; 108, 110; 108, 113; 109, identifier:v; 110, subscript; 110, 111; 110, 112; 111, identifier:s; 112, string:"fields"; 113, block; 113, 114; 113, 152; 113, 156; 113, 174; 113, 203; 114, if_statement; 114, 115; 114, 125; 115, boolean_operator:and; 115, 116; 115, 122; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:v; 119, identifier:has_key; 120, argument_list; 120, 121; 121, string:'comment'; 122, subscript; 122, 123; 122, 124; 123, identifier:v; 124, string:'comment'; 125, block; 125, 126; 125, 135; 126, if_statement; 126, 127; 126, 130; 127, comparison_operator:>; 127, 128; 127, 129; 128, identifier:i; 129, integer:0; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, augmented_assignment:+=; 132, 133; 132, 134; 133, identifier:code; 134, string:"\n"; 135, for_statement; 135, 136; 135, 137; 135, 145; 136, identifier:line; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:v; 141, string:'comment'; 142, identifier:split; 143, argument_list; 143, 144; 144, string:"\n"; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, augmented_assignment:+=; 147, 148; 147, 149; 148, identifier:code; 149, binary_operator:%; 149, 150; 149, 151; 150, string:' <span class="c1">// %s</span>\n'; 151, identifier:line; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:opt; 155, string:""; 156, if_statement; 156, 157; 156, 169; 157, boolean_operator:and; 157, 158; 157, 164; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:v; 161, identifier:has_key; 162, argument_list; 162, 163; 163, string:'optional'; 164, comparison_operator:==; 164, 165; 164, 168; 165, subscript; 165, 166; 165, 167; 166, identifier:v; 167, string:'optional'; 168, True; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:opt; 173, string:" [optional]"; 174, expression_statement; 174, 175; 175, augmented_assignment:+=; 175, 176; 175, 177; 176, identifier:code; 177, binary_operator:%; 177, 178; 177, 179; 178, identifier:formatstr; 179, tuple; 179, 180; 179, 189; 179, 202; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:string; 183, identifier:ljust; 184, argument_list; 184, 185; 184, 188; 185, subscript; 185, 186; 185, 187; 186, identifier:v; 187, string:'name'; 188, identifier:namelen; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:string; 192, identifier:ljust; 193, argument_list; 193, 194; 193, 201; 194, call; 194, 195; 194, 196; 195, identifier:format_type; 196, argument_list; 196, 197; 196, 198; 197, identifier:v; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:includeOptional; 200, False; 201, identifier:typelen; 202, identifier:opt; 203, expression_statement; 203, 204; 204, augmented_assignment:+=; 204, 205; 204, 206; 205, identifier:i; 206, integer:1; 207, expression_statement; 207, 208; 208, augmented_assignment:+=; 208, 209; 208, 210; 209, identifier:code; 210, string:"}"; 211, return_statement; 211, 212; 212, call; 212, 213; 212, 214; 213, identifier:to_section; 214, argument_list; 214, 215; 214, 216; 215, identifier:docs; 216, identifier:code | def parse_struct(s):
docs = s['comment']
code = '<span class="k">struct</span> <span class="gs">%s</span>' % s['name']
if s['extends']:
code += ' extends <span class="gs">%s</span>' % s['extends']
code += ' {\n'
namelen = 0
typelen = 0
for v in s["fields"]:
tlen = len(format_type(v, includeOptional=False))
if len(v['name']) > namelen:
namelen = len(v['name'])
if tlen > typelen:
typelen = tlen
namelen += 1
typelen += 1
formatstr = ' <span class="nv">%s</span><span class="kt">%s %s</span>\n'
i = 0
for v in s["fields"]:
if v.has_key('comment') and v['comment']:
if i > 0: code += "\n"
for line in v['comment'].split("\n"):
code += ' <span class="c1">// %s</span>\n' % line
opt = ""
if v.has_key('optional') and v['optional'] == True:
opt = " [optional]"
code += formatstr % (string.ljust(v['name'], namelen), string.ljust(format_type(v, includeOptional=False), typelen), opt)
i += 1
code += "}"
return to_section(docs, code) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:parse_interface; 3, parameters; 3, 4; 4, identifier:iface; 5, block; 5, 6; 5, 10; 5, 16; 5, 24; 5, 129; 5, 133; 5, 144; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:sections; 9, list:[ ]; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:docs; 13, subscript; 13, 14; 13, 15; 14, identifier:iface; 15, string:'comment'; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:code; 19, binary_operator:%; 19, 20; 19, 21; 20, string:'<span class="k">interface</span> <span class="gs">%s</span> {\n'; 21, subscript; 21, 22; 21, 23; 22, identifier:iface; 23, string:'name'; 24, for_statement; 24, 25; 24, 26; 24, 29; 25, identifier:v; 26, subscript; 26, 27; 26, 28; 27, identifier:iface; 28, string:"functions"; 29, block; 29, 30; 29, 38; 29, 42; 29, 76; 29, 87; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:func_code; 33, binary_operator:%; 33, 34; 33, 35; 34, string:' <span class="nf">%s</span>('; 35, subscript; 35, 36; 35, 37; 36, identifier:v; 37, string:'name'; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:i; 41, integer:0; 42, for_statement; 42, 43; 42, 44; 42, 47; 43, identifier:p; 44, subscript; 44, 45; 44, 46; 45, identifier:v; 46, string:"params"; 47, block; 47, 48; 47, 63; 48, if_statement; 48, 49; 48, 52; 48, 57; 49, comparison_operator:==; 49, 50; 49, 51; 50, identifier:i; 51, integer:0; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:i; 56, integer:1; 57, else_clause; 57, 58; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, augmented_assignment:+=; 60, 61; 60, 62; 61, identifier:func_code; 62, string:", "; 63, expression_statement; 63, 64; 64, augmented_assignment:+=; 64, 65; 64, 66; 65, identifier:func_code; 66, binary_operator:%; 66, 67; 66, 68; 67, string:'<span class="na">%s</span> <span class="kt">%s</span>'; 68, tuple; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:p; 71, string:'name'; 72, call; 72, 73; 72, 74; 73, identifier:format_type; 74, argument_list; 74, 75; 75, identifier:p; 76, expression_statement; 76, 77; 77, augmented_assignment:+=; 77, 78; 77, 79; 78, identifier:func_code; 79, binary_operator:%; 79, 80; 79, 81; 80, string:') <span class="kt">%s</span>\n'; 81, call; 81, 82; 81, 83; 82, identifier:format_type; 83, argument_list; 83, 84; 84, subscript; 84, 85; 84, 86; 85, identifier:v; 86, string:'returns'; 87, if_statement; 87, 88; 87, 98; 87, 123; 88, boolean_operator:and; 88, 89; 88, 95; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:v; 92, identifier:has_key; 93, argument_list; 93, 94; 94, string:'comment'; 95, subscript; 95, 96; 95, 97; 96, identifier:v; 97, string:'comment'; 98, block; 98, 99; 98, 113; 98, 119; 99, if_statement; 99, 100; 99, 101; 100, identifier:code; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:sections; 106, identifier:append; 107, argument_list; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:to_section; 110, argument_list; 110, 111; 110, 112; 111, identifier:docs; 112, identifier:code; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:docs; 116, subscript; 116, 117; 116, 118; 117, identifier:v; 118, string:'comment'; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:code; 122, identifier:func_code; 123, else_clause; 123, 124; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, augmented_assignment:+=; 126, 127; 126, 128; 127, identifier:code; 128, identifier:func_code; 129, expression_statement; 129, 130; 130, augmented_assignment:+=; 130, 131; 130, 132; 131, identifier:code; 132, string:"}"; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:sections; 137, identifier:append; 138, argument_list; 138, 139; 139, call; 139, 140; 139, 141; 140, identifier:to_section; 141, argument_list; 141, 142; 141, 143; 142, identifier:docs; 143, identifier:code; 144, return_statement; 144, 145; 145, identifier:sections | def parse_interface(iface):
sections = [ ]
docs = iface['comment']
code = '<span class="k">interface</span> <span class="gs">%s</span> {\n' % iface['name']
for v in iface["functions"]:
func_code = ' <span class="nf">%s</span>(' % v['name']
i = 0
for p in v["params"]:
if i == 0: i = 1
else: func_code += ", "
func_code += '<span class="na">%s</span> <span class="kt">%s</span>' % (p['name'], format_type(p))
func_code += ') <span class="kt">%s</span>\n' % format_type(v['returns'])
if v.has_key('comment') and v['comment']:
if code:
sections.append(to_section(docs, code))
docs = v['comment']
code = func_code
else:
code += func_code
code += "}"
sections.append(to_section(docs, code))
return sections |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:run; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 18; 5, 24; 5, 30; 5, 37; 5, 60; 5, 80; 5, 86; 5, 94; 5, 101; 5, 211; 5, 218; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:model; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:model; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:configfile; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:configfile; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:interval; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:interval; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:sockets; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:sockets; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:model; 34, identifier:initialize; 35, argument_list; 35, 36; 36, identifier:configfile; 37, if_statement; 37, 38; 37, 43; 37, 51; 38, comparison_operator:==; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:model; 41, identifier:state; 42, string:'pause'; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:logger; 48, identifier:info; 49, argument_list; 49, 50; 50, string:"model initialized and started in pause mode, waiting for requests"; 51, else_clause; 51, 52; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:logger; 57, identifier:info; 58, argument_list; 58, 59; 59, string:"model started and initialized, running"; 60, if_statement; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:tracker; 64, block; 64, 65; 64, 71; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:register; 70, argument_list; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:atexit; 75, identifier:register; 76, argument_list; 76, 77; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:unregister; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:process_incoming; 85, argument_list; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:counter; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:itertools; 92, identifier:count; 93, argument_list; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:logger; 98, identifier:info; 99, argument_list; 99, 100; 100, string:"Entering timeloop..."; 101, for_statement; 101, 102; 101, 103; 101, 104; 102, identifier:i; 103, identifier:counter; 104, block; 104, 105; 104, 126; 104, 134; 104, 145; 104, 152; 104, 158; 105, while_statement; 105, 106; 105, 111; 105, 118; 106, comparison_operator:==; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:model; 109, identifier:state; 110, string:"pause"; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:process_incoming; 117, argument_list; 118, else_clause; 118, 119; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:process_incoming; 125, argument_list; 126, if_statement; 126, 127; 126, 132; 127, comparison_operator:==; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:model; 130, identifier:state; 131, string:"quit"; 132, block; 132, 133; 133, break_statement; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:dt; 137, boolean_operator:or; 137, 138; 137, 143; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:model; 141, identifier:get_time_step; 142, argument_list; 143, unary_operator:-; 143, 144; 144, integer:1; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:model; 149, identifier:update; 150, argument_list; 150, 151; 151, identifier:dt; 152, if_statement; 152, 153; 152, 156; 153, binary_operator:%; 153, 154; 153, 155; 154, identifier:i; 155, identifier:interval; 156, block; 156, 157; 157, continue_statement; 158, for_statement; 158, 159; 158, 160; 158, 163; 159, identifier:key; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:output_vars; 163, block; 163, 164; 163, 173; 163, 183; 163, 195; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:value; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:model; 170, identifier:get_var; 171, argument_list; 171, 172; 172, identifier:key; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:metadata; 176, dictionary; 176, 177; 176, 180; 177, pair; 177, 178; 177, 179; 178, string:'name'; 179, identifier:key; 180, pair; 180, 181; 180, 182; 181, string:'iteration'; 182, identifier:i; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:logger; 187, identifier:debug; 188, argument_list; 188, 189; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, string:"sending {}"; 192, identifier:format; 193, argument_list; 193, 194; 194, identifier:metadata; 195, if_statement; 195, 196; 195, 199; 196, comparison_operator:in; 196, 197; 196, 198; 197, string:'pub'; 198, identifier:sockets; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 203; 202, identifier:send_array; 203, argument_list; 203, 204; 203, 207; 203, 208; 204, subscript; 204, 205; 204, 206; 205, identifier:sockets; 206, string:'pub'; 207, identifier:value; 208, keyword_argument; 208, 209; 208, 210; 209, identifier:metadata; 210, identifier:metadata; 211, expression_statement; 211, 212; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:logger; 215, identifier:info; 216, argument_list; 216, 217; 217, string:"Finalizing..."; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:model; 222, identifier:finalize; 223, argument_list | def run(self):
model = self.model
configfile = self.configfile
interval = self.interval
sockets = self.sockets
model.initialize(configfile)
if model.state == 'pause':
logger.info(
"model initialized and started in pause mode, waiting for requests"
)
else:
logger.info("model started and initialized, running")
if self.tracker:
self.register()
atexit.register(self.unregister)
self.process_incoming()
counter = itertools.count()
logger.info("Entering timeloop...")
for i in counter:
while model.state == "pause":
self.process_incoming()
else:
self.process_incoming()
if model.state == "quit":
break
dt = model.get_time_step() or -1
model.update(dt)
if i % interval:
continue
for key in self.output_vars:
value = model.get_var(key)
metadata = {'name': key, 'iteration': i}
logger.debug("sending {}".format(metadata))
if 'pub' in sockets:
send_array(sockets['pub'], value, metadata=metadata)
logger.info("Finalizing...")
model.finalize() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:save; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 185; 10, if_statement; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:publication; 14, block; 14, 15; 14, 21; 14, 35; 14, 86; 14, 100; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:publication; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:publication; 21, if_statement; 21, 22; 21, 26; 22, not_operator; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:title; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:title; 32, attribute; 32, 33; 32, 34; 33, identifier:publication; 34, identifier:title; 35, if_statement; 35, 36; 35, 40; 36, not_operator; 36, 37; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:subtitle; 40, block; 40, 41; 40, 47; 40, 69; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:first_author; 44, attribute; 44, 45; 44, 46; 45, identifier:publication; 46, identifier:first_author; 47, if_statement; 47, 48; 47, 53; 47, 58; 48, comparison_operator:==; 48, 49; 48, 50; 49, identifier:first_author; 50, attribute; 50, 51; 50, 52; 51, identifier:publication; 52, identifier:last_author; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:authors; 57, identifier:first_author; 58, else_clause; 58, 59; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:authors; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, string:'{} et al.'; 66, identifier:format; 67, argument_list; 67, 68; 68, identifier:first_author; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:subtitle; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, string:'{}, {} ({})'; 77, identifier:format; 78, argument_list; 78, 79; 78, 80; 78, 83; 79, identifier:authors; 80, attribute; 80, 81; 80, 82; 81, identifier:publication; 82, identifier:journal; 83, attribute; 83, 84; 83, 85; 84, identifier:publication; 85, identifier:year; 86, if_statement; 86, 87; 86, 91; 87, not_operator; 87, 88; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:description; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:description; 97, attribute; 97, 98; 97, 99; 98, identifier:publication; 99, identifier:abstract; 100, if_statement; 100, 101; 100, 111; 101, boolean_operator:and; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:publication; 106, identifier:year; 107, not_operator; 107, 108; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:pk; 111, block; 111, 112; 111, 124; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:delta; 115, binary_operator:-; 115, 116; 115, 121; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:timezone; 119, identifier:now; 120, argument_list; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:publish_datetime; 124, if_statement; 124, 125; 124, 140; 125, boolean_operator:and; 125, 126; 125, 135; 126, comparison_operator:<=; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:publish_datetime; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:timezone; 133, identifier:now; 134, argument_list; 135, comparison_operator:==; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:delta; 138, identifier:days; 139, integer:0; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:publish_datetime; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:datetime; 149, identifier:datetime; 150, argument_list; 150, 151; 150, 161; 150, 173; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:year; 153, call; 153, 154; 153, 155; 154, identifier:int; 155, argument_list; 155, 156; 156, attribute; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:publication; 160, identifier:year; 161, keyword_argument; 161, 162; 161, 163; 162, identifier:month; 163, call; 163, 164; 163, 165; 164, identifier:int; 165, argument_list; 165, 166; 166, boolean_operator:or; 166, 167; 166, 172; 167, attribute; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:publication; 171, identifier:month; 172, integer:1; 173, keyword_argument; 173, 174; 173, 175; 174, identifier:day; 175, call; 175, 176; 175, 177; 176, identifier:int; 177, argument_list; 177, 178; 178, boolean_operator:or; 178, 179; 178, 184; 179, attribute; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:publication; 183, identifier:day; 184, integer:1; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 192; 187, attribute; 187, 188; 187, 191; 188, call; 188, 189; 188, 190; 189, identifier:super; 190, argument_list; 191, identifier:save; 192, argument_list; 192, 193; 192, 195; 193, list_splat; 193, 194; 194, identifier:args; 195, dictionary_splat; 195, 196; 196, identifier:kwargs | def save(self, *args, **kwargs):
if self.publication:
publication = self.publication
if not self.title:
self.title = publication.title
if not self.subtitle:
first_author = publication.first_author
if first_author == publication.last_author:
authors = first_author
else:
authors = '{} et al.'.format(first_author)
self.subtitle = '{}, {} ({})'.format(authors,
publication.journal, publication.year)
if not self.description:
self.description = publication.abstract
if self.publication.year and not self.pk:
delta = timezone.now() - self.publish_datetime
if self.publish_datetime <= timezone.now() and delta.days == 0:
self.publish_datetime = datetime.datetime(
year=int(self.publication.year),
month=int(self.publication.month or 1),
day=int(self.publication.day or 1),
)
super().save(*args, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:cmd; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:send; 5, identifier:msg; 6, identifier:args; 7, block; 7, 8; 7, 20; 7, 26; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:implements; 11, list:['the golden gate bridge', 'a large trout', 'a clue-by-four', 'a fresh haddock', 'moon', 'an Itanium', 'fwilson', 'a wombat']; 11, 12; 11, 13; 11, 14; 11, 15; 11, 16; 11, 17; 11, 18; 11, 19; 12, string:'the golden gate bridge'; 13, string:'a large trout'; 14, string:'a clue-by-four'; 15, string:'a fresh haddock'; 16, string:'moon'; 17, string:'an Itanium'; 18, string:'fwilson'; 19, string:'a wombat'; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:methods; 23, list:['around a bit', 'upside the head']; 23, 24; 23, 25; 24, string:'around a bit'; 25, string:'upside the head'; 26, if_statement; 26, 27; 26, 29; 26, 99; 27, not_operator; 27, 28; 28, identifier:msg; 29, block; 29, 30; 29, 49; 29, 75; 29, 79; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:channel; 33, conditional_expression:if; 33, 34; 33, 37; 33, 42; 34, subscript; 34, 35; 34, 36; 35, identifier:args; 36, string:'target'; 37, comparison_operator:!=; 37, 38; 37, 41; 38, subscript; 38, 39; 38, 40; 39, identifier:args; 40, string:'target'; 41, string:'private'; 42, subscript; 42, 43; 42, 48; 43, subscript; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:args; 46, string:'config'; 47, string:'core'; 48, string:'channel'; 49, with_statement; 49, 50; 49, 57; 50, with_clause; 50, 51; 51, with_item; 51, 52; 52, attribute; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:args; 55, string:'handler'; 56, identifier:data_lock; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:users; 61, call; 61, 62; 61, 63; 62, identifier:list; 63, argument_list; 63, 64; 64, call; 64, 65; 64, 74; 65, attribute; 65, 66; 65, 73; 66, subscript; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:args; 70, string:'handler'; 71, identifier:channels; 72, identifier:channel; 73, identifier:users; 74, argument_list; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:slap; 78, string:'slaps %s %s with %s'; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:send; 82, argument_list; 82, 83; 82, 98; 83, binary_operator:%; 83, 84; 83, 85; 84, identifier:slap; 85, tuple; 85, 86; 85, 90; 85, 94; 86, call; 86, 87; 86, 88; 87, identifier:choice; 88, argument_list; 88, 89; 89, identifier:users; 90, call; 90, 91; 90, 92; 91, identifier:choice; 92, argument_list; 92, 93; 93, identifier:methods; 94, call; 94, 95; 94, 96; 95, identifier:choice; 96, argument_list; 96, 97; 97, identifier:implements; 98, string:'action'; 99, else_clause; 99, 100; 100, block; 100, 101; 100, 105; 100, 112; 100, 116; 100, 124; 100, 130; 100, 134; 100, 138; 100, 286; 100, 297; 100, 321; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:reason; 104, string:''; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:method; 108, call; 108, 109; 108, 110; 109, identifier:choice; 110, argument_list; 110, 111; 111, identifier:methods; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:implement; 115, string:''; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:msg; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:msg; 122, identifier:split; 123, argument_list; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:slapee; 127, subscript; 127, 128; 127, 129; 128, identifier:msg; 129, integer:0; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:i; 133, integer:1; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:args; 137, False; 138, while_statement; 138, 139; 138, 145; 139, comparison_operator:<; 139, 140; 139, 141; 140, identifier:i; 141, call; 141, 142; 141, 143; 142, identifier:len; 143, argument_list; 143, 144; 144, identifier:msg; 145, block; 145, 146; 145, 282; 146, if_statement; 146, 147; 146, 152; 146, 208; 146, 270; 147, comparison_operator:==; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:msg; 150, identifier:i; 151, string:'for'; 152, block; 152, 153; 152, 157; 152, 166; 152, 170; 152, 200; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:args; 156, True; 157, if_statement; 157, 158; 157, 159; 158, identifier:reason; 159, block; 159, 160; 159, 165; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 163; 162, identifier:send; 163, argument_list; 163, 164; 164, string:"Invalid Syntax: You can only have one for clause!"; 165, return_statement; 166, expression_statement; 166, 167; 167, augmented_assignment:+=; 167, 168; 167, 169; 168, identifier:i; 169, integer:1; 170, while_statement; 170, 171; 170, 177; 171, comparison_operator:<; 171, 172; 171, 173; 172, identifier:i; 173, call; 173, 174; 173, 175; 174, identifier:len; 175, argument_list; 175, 176; 176, identifier:msg; 177, block; 177, 178; 177, 186; 177, 190; 177, 196; 178, if_statement; 178, 179; 178, 184; 179, comparison_operator:==; 179, 180; 179, 183; 180, subscript; 180, 181; 180, 182; 181, identifier:msg; 182, identifier:i; 183, string:'with'; 184, block; 184, 185; 185, break_statement; 186, expression_statement; 186, 187; 187, augmented_assignment:+=; 187, 188; 187, 189; 188, identifier:reason; 189, string:" "; 190, expression_statement; 190, 191; 191, augmented_assignment:+=; 191, 192; 191, 193; 192, identifier:reason; 193, subscript; 193, 194; 193, 195; 194, identifier:msg; 195, identifier:i; 196, expression_statement; 196, 197; 197, augmented_assignment:+=; 197, 198; 197, 199; 198, identifier:i; 199, integer:1; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:reason; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:reason; 206, identifier:strip; 207, argument_list; 208, elif_clause; 208, 209; 208, 214; 209, comparison_operator:==; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:msg; 212, identifier:i; 213, string:'with'; 214, block; 214, 215; 214, 219; 214, 228; 214, 232; 214, 262; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:args; 218, True; 219, if_statement; 219, 220; 219, 221; 220, identifier:implement; 221, block; 221, 222; 221, 227; 222, expression_statement; 222, 223; 223, call; 223, 224; 223, 225; 224, identifier:send; 225, argument_list; 225, 226; 226, string:"Invalid Synatx: You can only have one with clause!"; 227, return_statement; 228, expression_statement; 228, 229; 229, augmented_assignment:+=; 229, 230; 229, 231; 230, identifier:i; 231, integer:1; 232, while_statement; 232, 233; 232, 239; 233, comparison_operator:<; 233, 234; 233, 235; 234, identifier:i; 235, call; 235, 236; 235, 237; 236, identifier:len; 237, argument_list; 237, 238; 238, identifier:msg; 239, block; 239, 240; 239, 248; 239, 254; 239, 258; 240, if_statement; 240, 241; 240, 246; 241, comparison_operator:==; 241, 242; 241, 245; 242, subscript; 242, 243; 242, 244; 243, identifier:msg; 244, identifier:i; 245, string:'for'; 246, block; 246, 247; 247, break_statement; 248, expression_statement; 248, 249; 249, augmented_assignment:+=; 249, 250; 249, 251; 250, identifier:implement; 251, subscript; 251, 252; 251, 253; 252, identifier:msg; 253, identifier:i; 254, expression_statement; 254, 255; 255, augmented_assignment:+=; 255, 256; 255, 257; 256, identifier:implement; 257, string:' '; 258, expression_statement; 258, 259; 259, augmented_assignment:+=; 259, 260; 259, 261; 260, identifier:i; 261, integer:1; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:implement; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:implement; 268, identifier:strip; 269, argument_list; 270, elif_clause; 270, 271; 270, 273; 271, not_operator; 271, 272; 272, identifier:args; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, augmented_assignment:+=; 275, 276; 275, 277; 276, identifier:slapee; 277, binary_operator:+; 277, 278; 277, 279; 278, string:' '; 279, subscript; 279, 280; 279, 281; 280, identifier:msg; 281, identifier:i; 282, expression_statement; 282, 283; 283, augmented_assignment:+=; 283, 284; 283, 285; 284, identifier:i; 285, integer:1; 286, if_statement; 286, 287; 286, 289; 287, not_operator; 287, 288; 288, identifier:implement; 289, block; 289, 290; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:implement; 293, call; 293, 294; 293, 295; 294, identifier:choice; 295, argument_list; 295, 296; 296, identifier:implements; 297, if_statement; 297, 298; 297, 299; 297, 310; 298, identifier:reason; 299, block; 299, 300; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:slap; 303, binary_operator:%; 303, 304; 303, 305; 304, string:'slaps %s %s with %s for %s'; 305, tuple; 305, 306; 305, 307; 305, 308; 305, 309; 306, identifier:slapee; 307, identifier:method; 308, identifier:implement; 309, identifier:reason; 310, else_clause; 310, 311; 311, block; 311, 312; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 315; 314, identifier:slap; 315, binary_operator:%; 315, 316; 315, 317; 316, string:'slaps %s %s with %s'; 317, tuple; 317, 318; 317, 319; 317, 320; 318, identifier:slapee; 319, identifier:method; 320, identifier:implement; 321, expression_statement; 321, 322; 322, call; 322, 323; 322, 324; 323, identifier:send; 324, argument_list; 324, 325; 324, 326; 325, identifier:slap; 326, string:'action' | def cmd(send, msg, args):
implements = ['the golden gate bridge', 'a large trout', 'a clue-by-four', 'a fresh haddock', 'moon', 'an Itanium', 'fwilson', 'a wombat']
methods = ['around a bit', 'upside the head']
if not msg:
channel = args['target'] if args['target'] != 'private' else args['config']['core']['channel']
with args['handler'].data_lock:
users = list(args['handler'].channels[channel].users())
slap = 'slaps %s %s with %s'
send(slap % (choice(users), choice(methods), choice(implements)), 'action')
else:
reason = ''
method = choice(methods)
implement = ''
msg = msg.split()
slapee = msg[0]
i = 1
args = False
while i < len(msg):
if msg[i] == 'for':
args = True
if reason:
send("Invalid Syntax: You can only have one for clause!")
return
i += 1
while i < len(msg):
if msg[i] == 'with':
break
reason += " "
reason += msg[i]
i += 1
reason = reason.strip()
elif msg[i] == 'with':
args = True
if implement:
send("Invalid Synatx: You can only have one with clause!")
return
i += 1
while i < len(msg):
if msg[i] == 'for':
break
implement += msg[i]
implement += ' '
i += 1
implement = implement.strip()
elif not args:
slapee += ' ' + msg[i]
i += 1
if not implement:
implement = choice(implements)
if reason:
slap = 'slaps %s %s with %s for %s' % (slapee, method, implement, reason)
else:
slap = 'slaps %s %s with %s' % (slapee, method, implement)
send(slap, 'action') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:cmd; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:send; 5, identifier:msg; 6, identifier:args; 7, block; 7, 8; 7, 18; 7, 24; 7, 53; 7, 79; 7, 96; 7, 113; 7, 119; 7, 125; 7, 144; 7, 155; 8, if_statement; 8, 9; 8, 11; 9, not_operator; 9, 10; 10, identifier:msg; 11, block; 11, 12; 11, 17; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:send; 15, argument_list; 15, 16; 16, string:"Invalid Syntax."; 17, return_statement; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:char; 21, subscript; 21, 22; 21, 23; 22, identifier:msg; 23, integer:0; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:msg; 27, list_comprehension; 27, 28; 27, 35; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:x; 31, identifier:replace; 32, argument_list; 32, 33; 32, 34; 33, string:r'\/'; 34, string:'/'; 35, for_in_clause; 35, 36; 35, 37; 36, identifier:x; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:re; 40, identifier:split; 41, argument_list; 41, 42; 41, 45; 41, 50; 42, binary_operator:%; 42, 43; 42, 44; 43, string:r'(?<!\\)\%s'; 44, identifier:char; 45, subscript; 45, 46; 45, 47; 46, identifier:msg; 47, slice; 47, 48; 47, 49; 48, integer:1; 49, colon; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:maxsplit; 52, integer:2; 53, if_statement; 53, 54; 53, 71; 54, boolean_operator:and; 54, 55; 54, 61; 55, comparison_operator:==; 55, 56; 55, 60; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, identifier:msg; 60, integer:2; 61, call; 61, 62; 61, 69; 62, attribute; 62, 63; 62, 68; 63, subscript; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:args; 66, string:'config'; 67, string:'feature'; 68, identifier:getboolean; 69, argument_list; 69, 70; 70, string:'lazyregex'; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:msg; 76, identifier:append; 77, argument_list; 77, 78; 78, string:''; 79, if_statement; 79, 80; 79, 89; 80, boolean_operator:or; 80, 81; 80, 83; 81, not_operator; 81, 82; 82, identifier:msg; 83, comparison_operator:<; 83, 84; 83, 88; 84, call; 84, 85; 84, 86; 85, identifier:len; 86, argument_list; 86, 87; 87, identifier:msg; 88, integer:3; 89, block; 89, 90; 89, 95; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:send; 93, argument_list; 93, 94; 94, string:"Invalid Syntax."; 95, return_statement; 96, if_statement; 96, 97; 96, 102; 97, comparison_operator:==; 97, 98; 97, 101; 98, subscript; 98, 99; 98, 100; 99, identifier:args; 100, string:'type'; 101, string:'privmsg'; 102, block; 102, 103; 102, 112; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:send; 106, argument_list; 106, 107; 107, binary_operator:%; 107, 108; 107, 109; 108, string:"Don't worry, %s is not a grammar Nazi."; 109, subscript; 109, 110; 109, 111; 110, identifier:args; 111, string:'botnick'; 112, return_statement; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:string; 116, subscript; 116, 117; 116, 118; 117, identifier:msg; 118, integer:0; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:replacement; 122, subscript; 122, 123; 122, 124; 123, identifier:msg; 124, integer:1; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:modifiers; 128, call; 128, 129; 128, 130; 129, identifier:get_modifiers; 130, argument_list; 130, 131; 130, 134; 130, 137; 131, subscript; 131, 132; 131, 133; 132, identifier:msg; 133, integer:2; 134, subscript; 134, 135; 134, 136; 135, identifier:args; 136, string:'nick'; 137, subscript; 137, 138; 137, 143; 138, subscript; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:args; 141, string:'config'; 142, string:'core'; 143, string:'nickregex'; 144, if_statement; 144, 145; 144, 148; 145, comparison_operator:is; 145, 146; 145, 147; 146, identifier:modifiers; 147, None; 148, block; 148, 149; 148, 154; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:send; 152, argument_list; 152, 153; 153, string:"Invalid modifiers."; 154, return_statement; 155, try_statement; 155, 156; 155, 264; 156, block; 156, 157; 156, 179; 156, 194; 156, 202; 156, 221; 156, 249; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:regex; 160, conditional_expression:if; 160, 161; 160, 170; 160, 173; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:re; 164, identifier:compile; 165, argument_list; 165, 166; 165, 167; 166, identifier:string; 167, attribute; 167, 168; 167, 169; 168, identifier:re; 169, identifier:IGNORECASE; 170, subscript; 170, 171; 170, 172; 171, identifier:modifiers; 172, string:'ignorecase'; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:re; 176, identifier:compile; 177, argument_list; 177, 178; 178, identifier:string; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:log; 182, call; 182, 183; 182, 184; 183, identifier:get_log; 184, argument_list; 184, 185; 184, 188; 184, 191; 185, subscript; 185, 186; 185, 187; 186, identifier:args; 187, string:'db'; 188, subscript; 188, 189; 188, 190; 189, identifier:args; 190, string:'target'; 191, subscript; 191, 192; 191, 193; 192, identifier:modifiers; 193, string:'nick'; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:workers; 197, attribute; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:args; 200, string:'handler'; 201, identifier:workers; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:result; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:workers; 208, identifier:run_pool; 209, argument_list; 209, 210; 209, 211; 210, identifier:do_replace; 211, list:[log, args['config']['core'], char, regex, replacement]; 211, 212; 211, 213; 211, 218; 211, 219; 211, 220; 212, identifier:log; 213, subscript; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:args; 216, string:'config'; 217, string:'core'; 218, identifier:char; 219, identifier:regex; 220, identifier:replacement; 221, try_statement; 221, 222; 221, 232; 222, block; 222, 223; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:msg; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:result; 229, identifier:get; 230, argument_list; 230, 231; 231, integer:5; 232, except_clause; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:multiprocessing; 235, identifier:TimeoutError; 236, block; 236, 237; 236, 243; 236, 248; 237, expression_statement; 237, 238; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:workers; 241, identifier:restart_pool; 242, argument_list; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 246; 245, identifier:send; 246, argument_list; 246, 247; 247, string:"Sed regex timed out."; 248, return_statement; 249, if_statement; 249, 250; 249, 251; 249, 257; 250, identifier:msg; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 255; 254, identifier:send; 255, argument_list; 255, 256; 256, identifier:msg; 257, else_clause; 257, 258; 258, block; 258, 259; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 262; 261, identifier:send; 262, argument_list; 262, 263; 263, string:"No match found."; 264, except_clause; 264, 265; 264, 271; 265, as_pattern; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:sre_constants; 268, identifier:error; 269, as_pattern_target; 269, 270; 270, identifier:ex; 271, block; 271, 272; 272, raise_statement; 272, 273; 273, call; 273, 274; 273, 275; 274, identifier:CommandFailedException; 275, argument_list; 275, 276; 276, identifier:ex | def cmd(send, msg, args):
if not msg:
send("Invalid Syntax.")
return
char = msg[0]
msg = [x.replace(r'\/', '/') for x in re.split(r'(?<!\\)\%s' % char, msg[1:], maxsplit=2)]
if len(msg) == 2 and args['config']['feature'].getboolean('lazyregex'):
msg.append('')
if not msg or len(msg) < 3:
send("Invalid Syntax.")
return
if args['type'] == 'privmsg':
send("Don't worry, %s is not a grammar Nazi." % args['botnick'])
return
string = msg[0]
replacement = msg[1]
modifiers = get_modifiers(msg[2], args['nick'], args['config']['core']['nickregex'])
if modifiers is None:
send("Invalid modifiers.")
return
try:
regex = re.compile(string, re.IGNORECASE) if modifiers['ignorecase'] else re.compile(string)
log = get_log(args['db'], args['target'], modifiers['nick'])
workers = args['handler'].workers
result = workers.run_pool(do_replace, [log, args['config']['core'], char, regex, replacement])
try:
msg = result.get(5)
except multiprocessing.TimeoutError:
workers.restart_pool()
send("Sed regex timed out.")
return
if msg:
send(msg)
else:
send("No match found.")
except sre_constants.error as ex:
raise CommandFailedException(ex) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_add_single_session_to_to_ordered_dict; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:d; 6, identifier:dataset_index; 7, identifier:recommended_only; 8, block; 8, 9; 9, for_statement; 9, 10; 9, 13; 9, 19; 10, pattern_list; 10, 11; 10, 12; 11, identifier:model_index; 12, identifier:model; 13, call; 13, 14; 13, 15; 14, identifier:enumerate; 15, argument_list; 15, 16; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:models; 19, block; 19, 20; 19, 24; 19, 76; 19, 85; 19, 96; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:show_null; 23, False; 24, if_statement; 24, 25; 24, 26; 25, identifier:recommended_only; 26, block; 26, 27; 27, if_statement; 27, 28; 27, 31; 27, 62; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:recommendation_enabled; 31, block; 31, 32; 32, if_statement; 32, 33; 32, 38; 32, 51; 32, 59; 33, comparison_operator:is; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:recommended_model; 37, None; 38, block; 38, 39; 39, if_statement; 39, 40; 39, 43; 39, 48; 40, comparison_operator:==; 40, 41; 40, 42; 41, identifier:model_index; 42, integer:0; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:show_null; 47, True; 48, else_clause; 48, 49; 49, block; 49, 50; 50, continue_statement; 51, elif_clause; 51, 52; 51, 57; 52, comparison_operator:==; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:recommended_model; 56, identifier:model; 57, block; 57, 58; 58, pass_statement; 59, else_clause; 59, 60; 60, block; 60, 61; 61, continue_statement; 62, else_clause; 62, 63; 63, block; 63, 64; 64, if_statement; 64, 65; 64, 68; 64, 73; 65, comparison_operator:==; 65, 66; 65, 67; 66, identifier:model_index; 67, integer:0; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:show_null; 72, True; 73, else_clause; 73, 74; 74, block; 74, 75; 75, continue_statement; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:d; 81, string:"dataset_index"; 82, identifier:append; 83, argument_list; 83, 84; 84, identifier:dataset_index; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:d; 90, string:"doses_dropped"; 91, identifier:append; 92, argument_list; 92, 93; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:doses_dropped; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:model; 100, identifier:_to_df; 101, argument_list; 101, 102; 101, 103; 101, 104; 102, identifier:d; 103, identifier:model_index; 104, identifier:show_null | def _add_single_session_to_to_ordered_dict(self, d, dataset_index, recommended_only):
for model_index, model in enumerate(self.models):
show_null = False
if recommended_only:
if self.recommendation_enabled:
if self.recommended_model is None:
if model_index == 0:
show_null = True
else:
continue
elif self.recommended_model == model:
pass
else:
continue
else:
if model_index == 0:
show_null = True
else:
continue
d["dataset_index"].append(dataset_index)
d["doses_dropped"].append(self.doses_dropped)
model._to_df(d, model_index, show_null) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_group_models; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 99; 5, 127; 5, 146; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:od; 9, call; 9, 10; 9, 11; 10, identifier:OrderedDict; 11, argument_list; 12, for_statement; 12, 13; 12, 16; 12, 22; 13, pattern_list; 13, 14; 13, 15; 14, identifier:i; 15, identifier:model; 16, call; 16, 17; 16, 18; 17, identifier:enumerate; 18, argument_list; 18, 19; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:models; 22, block; 22, 23; 22, 32; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:output; 26, call; 26, 27; 26, 28; 27, identifier:getattr; 28, argument_list; 28, 29; 28, 30; 28, 31; 29, identifier:model; 30, string:"output"; 31, dictionary; 32, if_statement; 32, 33; 32, 52; 32, 90; 33, boolean_operator:and; 33, 34; 33, 47; 34, boolean_operator:and; 34, 35; 34, 41; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:output; 38, identifier:get; 39, argument_list; 39, 40; 40, string:"AIC"; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:output; 44, identifier:get; 45, argument_list; 45, 46; 46, string:"BMD"; 47, comparison_operator:>; 47, 48; 47, 51; 48, subscript; 48, 49; 48, 50; 49, identifier:output; 50, string:"BMD"; 51, integer:0; 52, block; 52, 53; 52, 67; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:key; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, string:"{}-{}"; 59, identifier:format; 60, argument_list; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:output; 63, string:"AIC"; 64, subscript; 64, 65; 64, 66; 65, identifier:output; 66, string:"BMD"; 67, if_statement; 67, 68; 67, 71; 67, 81; 68, comparison_operator:in; 68, 69; 68, 70; 69, identifier:key; 70, identifier:od; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 79; 74, attribute; 74, 75; 74, 78; 75, subscript; 75, 76; 75, 77; 76, identifier:od; 77, identifier:key; 78, identifier:append; 79, argument_list; 79, 80; 80, identifier:model; 81, else_clause; 81, 82; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:od; 87, identifier:key; 88, list:[model]; 88, 89; 89, identifier:model; 90, else_clause; 90, 91; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:od; 96, identifier:i; 97, list:[model]; 97, 98; 98, identifier:model; 99, function_definition; 99, 100; 99, 101; 99, 103; 100, function_name:_get_num_params; 101, parameters; 101, 102; 102, identifier:model; 103, block; 103, 104; 104, return_statement; 104, 105; 105, parenthesized_expression; 105, 106; 106, conditional_expression:if; 106, 107; 106, 115; 106, 126; 107, call; 107, 108; 107, 109; 108, identifier:len; 109, argument_list; 109, 110; 110, subscript; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:model; 113, identifier:output; 114, string:"parameters"; 115, boolean_operator:and; 115, 116; 115, 121; 116, call; 116, 117; 116, 118; 117, identifier:hasattr; 118, argument_list; 118, 119; 118, 120; 119, identifier:model; 120, string:"output"; 121, comparison_operator:in; 121, 122; 121, 123; 122, string:"parameters"; 123, attribute; 123, 124; 123, 125; 124, identifier:model; 125, identifier:output; 126, integer:0; 127, for_statement; 127, 128; 127, 131; 127, 136; 128, pattern_list; 128, 129; 128, 130; 129, identifier:key; 130, identifier:_models; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:od; 134, identifier:items; 135, argument_list; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:_models; 141, identifier:sort; 142, argument_list; 142, 143; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:key; 145, identifier:_get_num_params; 146, return_statement; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:list; 149, argument_list; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:od; 153, identifier:values; 154, argument_list | def _group_models(self):
od = OrderedDict()
for i, model in enumerate(self.models):
output = getattr(model, "output", {})
if output.get("AIC") and output.get("BMD") and output["BMD"] > 0:
key = "{}-{}".format(output["AIC"], output["BMD"])
if key in od:
od[key].append(model)
else:
od[key] = [model]
else:
od[i] = [model]
def _get_num_params(model):
return (
len(model.output["parameters"])
if hasattr(model, "output") and "parameters" in model.output
else 0
)
for key, _models in od.items():
_models.sort(key=_get_num_params)
return list(od.values()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:random_stats; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:all_stats; 6, identifier:race; 7, identifier:ch_class; 8, block; 8, 9; 8, 13; 8, 17; 8, 38; 8, 42; 8, 135; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:stats; 12, list:[]; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:res; 16, dictionary; 17, for_statement; 17, 18; 17, 19; 17, 20; 18, identifier:s; 19, identifier:all_stats; 20, block; 20, 21; 20, 30; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:stats; 25, identifier:append; 26, argument_list; 26, 27; 27, subscript; 27, 28; 27, 29; 28, identifier:s; 29, string:'stat'; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 37; 32, subscript; 32, 33; 32, 34; 33, identifier:res; 34, subscript; 34, 35; 34, 36; 35, identifier:s; 36, string:'stat'; 37, integer:0; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:cur_stat; 41, integer:0; 42, for_statement; 42, 43; 42, 44; 42, 45; 43, identifier:stat; 44, identifier:stats; 45, block; 45, 46; 45, 75; 45, 104; 45, 129; 46, for_statement; 46, 47; 46, 50; 46, 58; 47, pattern_list; 47, 48; 47, 49; 48, identifier:ndx; 49, identifier:i; 50, call; 50, 51; 50, 52; 51, identifier:enumerate; 52, argument_list; 52, 53; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:classes; 57, identifier:dat; 58, block; 58, 59; 59, if_statement; 59, 60; 59, 65; 60, comparison_operator:==; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:i; 63, string:'name'; 64, identifier:ch_class; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:cur_stat; 69, call; 69, 70; 69, 71; 70, identifier:int; 71, argument_list; 71, 72; 72, subscript; 72, 73; 72, 74; 73, identifier:i; 74, identifier:stat; 75, for_statement; 75, 76; 75, 79; 75, 87; 76, pattern_list; 76, 77; 76, 78; 77, identifier:ndx; 78, identifier:i; 79, call; 79, 80; 79, 81; 80, identifier:enumerate; 81, argument_list; 81, 82; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:races; 86, identifier:dat; 87, block; 87, 88; 88, if_statement; 88, 89; 88, 94; 89, comparison_operator:==; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:i; 92, string:'name'; 93, identifier:race; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, augmented_assignment:+=; 96, 97; 96, 98; 97, identifier:cur_stat; 98, call; 98, 99; 98, 100; 99, identifier:int; 100, argument_list; 100, 101; 101, subscript; 101, 102; 101, 103; 102, identifier:i; 103, identifier:stat; 104, if_statement; 104, 105; 104, 108; 104, 113; 105, comparison_operator:<; 105, 106; 105, 107; 106, identifier:cur_stat; 107, integer:1; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:cur_stat; 112, integer:1; 113, elif_clause; 113, 114; 113, 117; 114, comparison_operator:>; 114, 115; 114, 116; 115, identifier:cur_stat; 116, integer:10; 117, block; 117, 118; 118, if_statement; 118, 119; 118, 124; 119, comparison_operator:not; 119, 120; 119, 121; 120, identifier:stat; 121, tuple; 121, 122; 121, 123; 122, string:'Health'; 123, string:'max_health'; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:cur_stat; 128, integer:10; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 134; 131, subscript; 131, 132; 131, 133; 132, identifier:res; 133, identifier:stat; 134, identifier:cur_stat; 135, return_statement; 135, 136; 136, identifier:res | def random_stats(self, all_stats, race, ch_class):
stats = []
res = {}
for s in all_stats:
stats.append(s['stat'])
res[s['stat']] = 0
cur_stat = 0
for stat in stats:
for ndx, i in enumerate(self.classes.dat):
if i['name'] == ch_class:
cur_stat = int(i[stat])
for ndx, i in enumerate(self.races.dat):
if i['name'] == race:
cur_stat += int(i[stat])
if cur_stat < 1:
cur_stat = 1
elif cur_stat > 10:
if stat not in ('Health', 'max_health'):
cur_stat = 10
res[stat] = cur_stat
return res |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:palette; 3, parameters; 3, 4; 3, 5; 4, identifier:fg; 5, default_parameter; 5, 6; 5, 7; 6, identifier:bg; 7, unary_operator:-; 7, 8; 8, integer:1; 9, block; 9, 10; 9, 24; 9, 38; 9, 52; 9, 76; 9, 94; 9, 134; 9, 174; 9, 187; 10, if_statement; 10, 11; 10, 17; 11, not_operator; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:hasattr; 14, argument_list; 14, 15; 14, 16; 15, identifier:palette; 16, string:"counter"; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:palette; 22, identifier:counter; 23, integer:1; 24, if_statement; 24, 25; 24, 31; 25, not_operator; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:hasattr; 28, argument_list; 28, 29; 28, 30; 29, identifier:palette; 30, string:"selections"; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:palette; 36, identifier:selections; 37, dictionary; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:selection; 41, binary_operator:%; 41, 42; 41, 43; 42, string:"%s%s"; 43, tuple; 43, 44; 43, 48; 44, call; 44, 45; 44, 46; 45, identifier:str; 46, argument_list; 46, 47; 47, identifier:fg; 48, call; 48, 49; 48, 50; 49, identifier:str; 50, argument_list; 50, 51; 51, identifier:bg; 52, if_statement; 52, 53; 52, 59; 53, not_operator; 53, 54; 54, comparison_operator:in; 54, 55; 54, 56; 55, identifier:selection; 56, attribute; 56, 57; 56, 58; 57, identifier:palette; 58, identifier:selections; 59, block; 59, 60; 59, 70; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 67; 62, subscript; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:palette; 65, identifier:selections; 66, identifier:selection; 67, attribute; 67, 68; 67, 69; 68, identifier:palette; 69, identifier:counter; 70, expression_statement; 70, 71; 71, augmented_assignment:+=; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:palette; 74, identifier:counter; 75, integer:1; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:colors; 79, list_comprehension; 79, 80; 79, 81; 79, 87; 80, identifier:c; 81, for_in_clause; 81, 82; 81, 83; 82, identifier:c; 83, call; 83, 84; 83, 85; 84, identifier:dir; 85, argument_list; 85, 86; 86, identifier:_curses; 87, if_clause; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:c; 91, identifier:startswith; 92, argument_list; 92, 93; 93, string:'COLOR'; 94, if_statement; 94, 95; 94, 100; 95, call; 95, 96; 95, 97; 96, identifier:isinstance; 97, argument_list; 97, 98; 97, 99; 98, identifier:fg; 99, identifier:str; 100, block; 100, 101; 101, if_statement; 101, 102; 101, 112; 101, 118; 102, not_operator; 102, 103; 103, comparison_operator:in; 103, 104; 103, 111; 104, binary_operator:+; 104, 105; 104, 106; 105, string:"COLOR_"; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:fg; 109, identifier:upper; 110, argument_list; 111, identifier:colors; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:fg; 116, unary_operator:-; 116, 117; 117, integer:1; 118, else_clause; 118, 119; 119, block; 119, 120; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:fg; 123, call; 123, 124; 123, 125; 124, identifier:getattr; 125, argument_list; 125, 126; 125, 127; 126, identifier:_curses; 127, binary_operator:+; 127, 128; 127, 129; 128, string:"COLOR_"; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:fg; 132, identifier:upper; 133, argument_list; 134, if_statement; 134, 135; 134, 140; 135, call; 135, 136; 135, 137; 136, identifier:isinstance; 137, argument_list; 137, 138; 137, 139; 138, identifier:bg; 139, identifier:str; 140, block; 140, 141; 141, if_statement; 141, 142; 141, 152; 141, 158; 142, not_operator; 142, 143; 143, comparison_operator:in; 143, 144; 143, 151; 144, binary_operator:+; 144, 145; 144, 146; 145, string:"COLOR_"; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:bg; 149, identifier:upper; 150, argument_list; 151, identifier:colors; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:bg; 156, unary_operator:-; 156, 157; 157, integer:1; 158, else_clause; 158, 159; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:bg; 163, call; 163, 164; 163, 165; 164, identifier:getattr; 165, argument_list; 165, 166; 165, 167; 166, identifier:_curses; 167, binary_operator:+; 167, 168; 167, 169; 168, string:"COLOR_"; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:bg; 172, identifier:upper; 173, argument_list; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:_curses; 178, identifier:init_pair; 179, argument_list; 179, 180; 179, 185; 179, 186; 180, subscript; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:palette; 183, identifier:selections; 184, identifier:selection; 185, identifier:fg; 186, identifier:bg; 187, return_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:_curses; 191, identifier:color_pair; 192, argument_list; 192, 193; 193, subscript; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:palette; 196, identifier:selections; 197, identifier:selection | def palette(fg, bg=-1):
if not hasattr(palette, "counter"):
palette.counter = 1
if not hasattr(palette, "selections"):
palette.selections = {}
selection = "%s%s" % (str(fg), str(bg))
if not selection in palette.selections:
palette.selections[selection] = palette.counter
palette.counter += 1
colors = [c for c in dir(_curses) if c.startswith('COLOR')]
if isinstance(fg, str):
if not "COLOR_"+fg.upper() in colors:
fg = -1
else:
fg = getattr(_curses, "COLOR_"+fg.upper())
if isinstance(bg, str):
if not "COLOR_"+bg.upper() in colors:
bg = -1
else:
bg = getattr(_curses, "COLOR_"+bg.upper())
_curses.init_pair(palette.selections[selection], fg, bg)
return _curses.color_pair(palette.selections[selection]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:coordinate; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:panes; 7, list:[]; 8, default_parameter; 8, 9; 8, 10; 9, identifier:index; 10, integer:0; 11, block; 11, 12; 11, 16; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:y; 15, integer:0; 16, for_statement; 16, 17; 16, 20; 16, 26; 17, pattern_list; 17, 18; 17, 19; 18, identifier:i; 19, identifier:element; 20, call; 20, 21; 20, 22; 21, identifier:enumerate; 22, argument_list; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:panes; 26, block; 26, 27; 26, 31; 26, 213; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:x; 30, integer:0; 31, if_statement; 31, 32; 31, 37; 31, 133; 32, call; 32, 33; 32, 34; 33, identifier:isinstance; 34, argument_list; 34, 35; 34, 36; 35, identifier:element; 36, identifier:list; 37, block; 37, 38; 37, 42; 37, 121; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:current_height; 41, integer:0; 42, for_statement; 42, 43; 42, 46; 42, 50; 43, pattern_list; 43, 44; 43, 45; 44, identifier:j; 45, identifier:pane; 46, call; 46, 47; 46, 48; 47, identifier:enumerate; 48, argument_list; 48, 49; 49, identifier:element; 50, block; 50, 51; 50, 57; 50, 63; 50, 69; 50, 81; 50, 109; 50, 117; 51, if_statement; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:pane; 54, identifier:hidden; 55, block; 55, 56; 56, continue_statement; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:current_width; 60, attribute; 60, 61; 60, 62; 61, identifier:pane; 62, identifier:width; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:current_height; 66, attribute; 66, 67; 66, 68; 67, identifier:pane; 68, identifier:height; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:upper; 72, tuple; 72, 73; 72, 76; 73, tuple; 73, 74; 73, 75; 74, identifier:y; 75, identifier:x; 76, tuple; 76, 77; 76, 78; 77, identifier:y; 78, binary_operator:+; 78, 79; 78, 80; 79, identifier:x; 80, identifier:current_width; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:lower; 84, tuple; 84, 85; 84, 96; 85, tuple; 85, 86; 85, 95; 86, binary_operator:+; 86, 87; 86, 88; 87, identifier:y; 88, parenthesized_expression; 88, 89; 89, conditional_expression:if; 89, 90; 89, 91; 89, 94; 90, identifier:current_height; 91, comparison_operator:>; 91, 92; 91, 93; 92, identifier:current_height; 93, integer:1; 94, integer:0; 95, identifier:x; 96, tuple; 96, 97; 96, 106; 97, binary_operator:+; 97, 98; 97, 99; 98, identifier:y; 99, parenthesized_expression; 99, 100; 100, conditional_expression:if; 100, 101; 100, 102; 100, 105; 101, identifier:current_height; 102, comparison_operator:>; 102, 103; 102, 104; 103, identifier:current_height; 104, integer:1; 105, integer:0; 106, binary_operator:+; 106, 107; 106, 108; 107, identifier:x; 108, identifier:current_width; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:pane; 113, identifier:coords; 114, list:[upper, lower]; 114, 115; 114, 116; 115, identifier:upper; 116, identifier:lower; 117, expression_statement; 117, 118; 118, augmented_assignment:+=; 118, 119; 118, 120; 119, identifier:x; 120, identifier:current_width; 121, expression_statement; 121, 122; 122, augmented_assignment:+=; 122, 123; 122, 124; 123, identifier:y; 124, parenthesized_expression; 124, 125; 125, conditional_expression:if; 125, 126; 125, 129; 125, 132; 126, binary_operator:+; 126, 127; 126, 128; 127, identifier:current_height; 128, integer:1; 129, comparison_operator:>; 129, 130; 129, 131; 130, identifier:current_height; 131, integer:1; 132, integer:1; 133, else_clause; 133, 134; 134, block; 134, 135; 134, 141; 134, 147; 134, 153; 134, 165; 134, 193; 134, 201; 135, if_statement; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:element; 138, identifier:hidden; 139, block; 139, 140; 140, continue_statement; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:current_width; 144, attribute; 144, 145; 144, 146; 145, identifier:element; 146, identifier:width; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:current_height; 150, attribute; 150, 151; 150, 152; 151, identifier:element; 152, identifier:height; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:upper; 156, tuple; 156, 157; 156, 160; 157, tuple; 157, 158; 157, 159; 158, identifier:y; 159, identifier:x; 160, tuple; 160, 161; 160, 162; 161, identifier:y; 162, binary_operator:+; 162, 163; 162, 164; 163, identifier:x; 164, identifier:current_width; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:lower; 168, tuple; 168, 169; 168, 180; 169, tuple; 169, 170; 169, 179; 170, binary_operator:+; 170, 171; 170, 172; 171, identifier:y; 172, parenthesized_expression; 172, 173; 173, conditional_expression:if; 173, 174; 173, 175; 173, 178; 174, identifier:current_height; 175, comparison_operator:>; 175, 176; 175, 177; 176, identifier:current_height; 177, integer:1; 178, integer:0; 179, identifier:x; 180, tuple; 180, 181; 180, 190; 181, binary_operator:+; 181, 182; 181, 183; 182, identifier:y; 183, parenthesized_expression; 183, 184; 184, conditional_expression:if; 184, 185; 184, 186; 184, 189; 185, identifier:current_height; 186, comparison_operator:>; 186, 187; 186, 188; 187, identifier:current_height; 188, integer:1; 189, integer:0; 190, binary_operator:+; 190, 191; 190, 192; 191, identifier:x; 192, identifier:current_width; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:element; 197, identifier:coords; 198, list:[upper, lower]; 198, 199; 198, 200; 199, identifier:upper; 200, identifier:lower; 201, expression_statement; 201, 202; 202, augmented_assignment:+=; 202, 203; 202, 204; 203, identifier:y; 204, parenthesized_expression; 204, 205; 205, conditional_expression:if; 205, 206; 205, 209; 205, 212; 206, binary_operator:+; 206, 207; 206, 208; 207, identifier:current_height; 208, integer:1; 209, comparison_operator:>; 209, 210; 209, 211; 210, identifier:current_height; 211, integer:1; 212, integer:1; 213, if_statement; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:debug; 217, block; 217, 218; 217, 233; 217, 259; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:coordinates; 221, binary_operator:+; 221, 222; 221, 223; 222, string:"Coordinates: "; 223, call; 223, 224; 223, 225; 224, identifier:str; 225, argument_list; 225, 226; 226, list_comprehension; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:p; 229, identifier:coords; 230, for_in_clause; 230, 231; 230, 232; 231, identifier:p; 232, identifier:self; 233, if_statement; 233, 234; 233, 242; 234, comparison_operator:>; 234, 235; 234, 239; 235, call; 235, 236; 235, 237; 236, identifier:len; 237, argument_list; 237, 238; 238, identifier:coordinates; 239, attribute; 239, 240; 239, 241; 240, identifier:self; 241, identifier:width; 242, block; 242, 243; 242, 255; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:coordinates; 246, subscript; 246, 247; 246, 248; 247, identifier:coordinates; 248, slice; 248, 249; 248, 250; 249, colon; 250, binary_operator:-; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:self; 253, identifier:width; 254, integer:3; 255, expression_statement; 255, 256; 256, augmented_assignment:+=; 256, 257; 256, 258; 257, identifier:coordinates; 258, string:'...'; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:self; 263, identifier:addstr; 264, argument_list; 264, 265; 264, 270; 264, 271; 265, binary_operator:-; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:self; 268, identifier:height; 269, integer:3; 270, integer:0; 271, identifier:coordinates | def coordinate(self, panes=[], index=0):
y = 0
for i, element in enumerate(self.panes):
x = 0
if isinstance(element, list):
current_height = 0
for j, pane in enumerate(element):
if pane.hidden: continue
current_width = pane.width
current_height = pane.height
upper = ((y, x), (y, x+current_width))
lower = ((y+(current_height if current_height > 1 else 0), x),
(y+(current_height if current_height > 1 else 0), x+current_width))
pane.coords = [upper, lower]
x += current_width
y += (current_height+1 if current_height > 1 else 1)
else:
if element.hidden: continue
current_width = element.width
current_height = element.height
upper = ((y, x), (y, x+current_width))
lower = ((y+(current_height if current_height > 1 else 0), x),
(y+(current_height if current_height > 1 else 0), x+current_width))
element.coords = [upper, lower]
y += (current_height+1 if current_height > 1 else 1)
if self.debug:
coordinates = "Coordinates: " + str([p.coords for p in self])
if len(coordinates) > self.width:
coordinates = coordinates[:self.width - 3]
coordinates += '...'
self.addstr(self.height-3, 0, coordinates) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:_MakePackagePages; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:package; 6, default_parameter; 6, 7; 6, 8; 7, identifier:showprivate; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:nested; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:showinh; 14, False; 15, block; 15, 16; 15, 74; 15, 86; 15, 96; 15, 142; 15, 149; 15, 153; 15, 157; 15, 271; 15, 382; 15, 400; 15, 412; 16, function_definition; 16, 17; 16, 18; 16, 20; 17, function_name:checkNoNested; 18, parameters; 18, 19; 19, identifier:mod; 20, block; 20, 21; 20, 34; 20, 46; 20, 62; 20, 72; 21, try_statement; 21, 22; 21, 29; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:all; 26, attribute; 26, 27; 26, 28; 27, identifier:mod; 28, identifier:__all__; 29, except_clause; 29, 30; 29, 31; 30, identifier:AttributeError; 31, block; 31, 32; 32, return_statement; 32, 33; 33, False; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:mems; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:inspect; 40, identifier:getmembers; 41, argument_list; 41, 42; 41, 43; 42, identifier:mod; 43, attribute; 43, 44; 43, 45; 44, identifier:inspect; 45, identifier:ismodule; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:mems; 49, list_comprehension; 49, 50; 49, 51; 49, 54; 50, identifier:m; 51, for_in_clause; 51, 52; 51, 53; 52, identifier:m; 53, identifier:mems; 54, if_clause; 54, 55; 55, comparison_operator:in; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:m; 58, integer:0; 59, attribute; 59, 60; 59, 61; 60, identifier:mod; 61, identifier:__all__; 62, if_statement; 62, 63; 62, 69; 63, comparison_operator:>; 63, 64; 63, 68; 64, call; 64, 65; 64, 66; 65, identifier:len; 66, argument_list; 66, 67; 67, identifier:mems; 68, integer:0; 69, block; 69, 70; 70, return_statement; 70, 71; 71, False; 72, return_statement; 72, 73; 73, True; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:mods; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:inspect; 80, identifier:getmembers; 81, argument_list; 81, 82; 81, 83; 82, identifier:package; 83, attribute; 83, 84; 83, 85; 84, identifier:inspect; 85, identifier:ismodule; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 92; 88, pattern_list; 88, 89; 88, 90; 88, 91; 89, identifier:nmods; 90, identifier:pvt; 91, identifier:npkgs; 92, expression_list; 92, 93; 92, 94; 92, 95; 93, list:[]; 94, list:[]; 95, list:[]; 96, for_statement; 96, 97; 96, 98; 96, 99; 97, identifier:mod; 98, identifier:mods; 99, block; 99, 100; 100, if_statement; 100, 101; 100, 107; 100, 133; 101, call; 101, 102; 101, 103; 102, identifier:checkNoNested; 103, argument_list; 103, 104; 104, subscript; 104, 105; 104, 106; 105, identifier:mod; 106, integer:1; 107, block; 107, 108; 108, if_statement; 108, 109; 108, 116; 108, 124; 109, comparison_operator:==; 109, 110; 109, 115; 110, subscript; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:mod; 113, integer:0; 114, integer:0; 115, string:'_'; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:pvt; 121, identifier:append; 122, argument_list; 122, 123; 123, identifier:mod; 124, else_clause; 124, 125; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:nmods; 130, identifier:append; 131, argument_list; 131, 132; 132, identifier:mod; 133, else_clause; 133, 134; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:npkgs; 139, identifier:append; 140, argument_list; 140, 141; 141, identifier:mod; 142, if_statement; 142, 143; 142, 144; 143, identifier:showprivate; 144, block; 144, 145; 145, expression_statement; 145, 146; 146, augmented_assignment:+=; 146, 147; 146, 148; 147, identifier:nmods; 148, identifier:pvt; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:files; 152, list:[]; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:ignore; 156, list:[]; 157, for_statement; 157, 158; 157, 159; 157, 160; 158, identifier:pkg; 159, identifier:npkgs; 160, block; 160, 161; 160, 192; 160, 209; 160, 216; 160, 227; 160, 247; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:pt; 164, binary_operator:%; 164, 165; 164, 166; 165, string:'%s/%s/%s'; 166, tuple; 166, 167; 166, 170; 166, 179; 167, attribute; 167, 168; 167, 169; 168, identifier:self; 169, identifier:path; 170, call; 170, 171; 170, 176; 171, attribute; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:package; 174, identifier:__name__; 175, identifier:replace; 176, argument_list; 176, 177; 176, 178; 177, string:'.'; 178, string:'/'; 179, subscript; 179, 180; 179, 190; 180, call; 180, 181; 180, 188; 181, attribute; 181, 182; 181, 187; 182, attribute; 182, 183; 182, 186; 183, subscript; 183, 184; 183, 185; 184, identifier:pkg; 185, integer:1; 186, identifier:__name__; 187, identifier:split; 188, argument_list; 188, 189; 189, string:'.'; 190, unary_operator:-; 190, 191; 191, integer:1; 192, if_statement; 192, 193; 192, 201; 193, call; 193, 194; 193, 199; 194, attribute; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:os; 197, identifier:path; 198, identifier:exists; 199, argument_list; 199, 200; 200, identifier:pt; 201, block; 201, 202; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:shutil; 206, identifier:rmtree; 207, argument_list; 207, 208; 208, identifier:pt; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:os; 213, identifier:makedirs; 214, argument_list; 214, 215; 215, identifier:pt; 216, expression_statement; 216, 217; 217, augmented_assignment:+=; 217, 218; 217, 219; 218, identifier:ignore; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:inspect; 222, identifier:getmembers; 223, argument_list; 223, 224; 224, subscript; 224, 225; 224, 226; 225, identifier:pkg; 226, integer:1; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:f; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:self; 233, identifier:_MakePackagePages; 234, argument_list; 234, 235; 234, 238; 234, 241; 234, 244; 235, subscript; 235, 236; 235, 237; 236, identifier:pkg; 237, integer:1; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:showprivate; 240, identifier:showprivate; 241, keyword_argument; 241, 242; 241, 243; 242, identifier:nested; 243, True; 244, keyword_argument; 244, 245; 244, 246; 245, identifier:showinh; 246, identifier:showinh; 247, expression_statement; 247, 248; 248, call; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:files; 251, identifier:append; 252, argument_list; 252, 253; 253, subscript; 253, 254; 253, 270; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:f; 257, identifier:split; 258, argument_list; 258, 259; 259, binary_operator:+; 259, 260; 259, 269; 260, call; 260, 261; 260, 266; 261, attribute; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:package; 264, identifier:__name__; 265, identifier:replace; 266, argument_list; 266, 267; 266, 268; 267, string:'.'; 268, string:'/'; 269, string:'/'; 270, integer:1; 271, if_statement; 271, 272; 271, 273; 272, identifier:nested; 273, block; 273, 274; 273, 291; 273, 304; 273, 313; 273, 330; 273, 345; 273, 378; 274, try_statement; 274, 275; 274, 282; 275, block; 275, 276; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:name; 279, attribute; 279, 280; 279, 281; 280, identifier:package; 281, identifier:__displayname__; 282, except_clause; 282, 283; 282, 284; 283, identifier:AttributeError; 284, block; 284, 285; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:name; 288, attribute; 288, 289; 288, 290; 289, identifier:package; 290, identifier:__name__; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:index; 294, binary_operator:%; 294, 295; 294, 296; 295, string:r'''
%s
%s
.. toctree::
:maxdepth: 5
'''; 296, tuple; 296, 297; 296, 298; 297, identifier:name; 298, binary_operator:*; 298, 299; 298, 300; 299, string:'*'; 300, call; 300, 301; 300, 302; 301, identifier:len; 302, argument_list; 302, 303; 303, identifier:name; 304, expression_statement; 304, 305; 305, augmented_assignment:+=; 305, 306; 305, 307; 306, identifier:index; 307, call; 307, 308; 307, 311; 308, attribute; 308, 309; 308, 310; 309, string:'\n '; 310, identifier:join; 311, argument_list; 311, 312; 312, identifier:files; 313, expression_statement; 313, 314; 314, augmented_assignment:+=; 314, 315; 314, 316; 315, identifier:index; 316, binary_operator:+; 316, 317; 316, 318; 317, string:'\n '; 318, call; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:self; 321, identifier:_ProduceContent; 322, argument_list; 322, 323; 322, 324; 322, 327; 323, identifier:nmods; 324, keyword_argument; 324, 325; 324, 326; 325, identifier:showprivate; 326, identifier:showprivate; 327, keyword_argument; 327, 328; 327, 329; 328, identifier:showinh; 329, identifier:showinh; 330, expression_statement; 330, 331; 331, assignment; 331, 332; 331, 333; 332, identifier:findex; 333, binary_operator:%; 333, 334; 333, 335; 334, string:'content/%s/index.rst'; 335, parenthesized_expression; 335, 336; 336, call; 336, 337; 336, 342; 337, attribute; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:package; 340, identifier:__name__; 341, identifier:replace; 342, argument_list; 342, 343; 342, 344; 343, string:'.'; 344, string:'/'; 345, with_statement; 345, 346; 345, 356; 346, with_clause; 346, 347; 347, with_item; 347, 348; 348, as_pattern; 348, 349; 348, 354; 349, call; 349, 350; 349, 351; 350, identifier:open; 351, argument_list; 351, 352; 351, 353; 352, identifier:findex; 353, string:'w'; 354, as_pattern_target; 354, 355; 355, identifier:f; 356, block; 356, 357; 356, 371; 357, if_statement; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, identifier:package; 360, identifier:__doc__; 361, block; 361, 362; 362, expression_statement; 362, 363; 363, call; 363, 364; 363, 367; 364, attribute; 364, 365; 364, 366; 365, identifier:f; 366, identifier:write; 367, argument_list; 367, 368; 368, attribute; 368, 369; 368, 370; 369, identifier:package; 370, identifier:__doc__; 371, expression_statement; 371, 372; 372, call; 372, 373; 372, 376; 373, attribute; 373, 374; 373, 375; 374, identifier:f; 375, identifier:write; 376, argument_list; 376, 377; 377, identifier:index; 378, return_statement; 378, 379; 379, binary_operator:+; 379, 380; 379, 381; 380, string:'\n '; 381, identifier:findex; 382, expression_statement; 382, 383; 383, assignment; 383, 384; 383, 385; 384, identifier:names; 385, binary_operator:%; 385, 386; 385, 387; 386, string:'\n %s/%s/'; 387, tuple; 387, 388; 387, 391; 388, attribute; 388, 389; 388, 390; 389, identifier:self; 390, identifier:path; 391, call; 391, 392; 391, 397; 392, attribute; 392, 393; 392, 396; 393, attribute; 393, 394; 393, 395; 394, identifier:package; 395, identifier:__name__; 396, identifier:replace; 397, argument_list; 397, 398; 397, 399; 398, string:'.'; 399, string:'/'; 400, expression_statement; 400, 401; 401, assignment; 401, 402; 401, 403; 402, identifier:nmods; 403, list_comprehension; 403, 404; 403, 405; 403, 408; 404, identifier:m; 405, for_in_clause; 405, 406; 405, 407; 406, identifier:m; 407, identifier:nmods; 408, if_clause; 408, 409; 409, comparison_operator:not; 409, 410; 409, 411; 410, identifier:m; 411, identifier:ignore; 412, return_statement; 412, 413; 413, call; 413, 414; 413, 417; 414, attribute; 414, 415; 414, 416; 415, identifier:names; 416, identifier:join; 417, argument_list; 417, 418; 418, binary_operator:+; 418, 419; 418, 436; 419, call; 419, 420; 419, 434; 420, attribute; 420, 421; 420, 433; 421, call; 421, 422; 421, 425; 422, attribute; 422, 423; 422, 424; 423, identifier:self; 424, identifier:_ProduceContent; 425, argument_list; 425, 426; 425, 427; 425, 430; 426, identifier:nmods; 427, keyword_argument; 427, 428; 427, 429; 428, identifier:showprivate; 429, identifier:showprivate; 430, keyword_argument; 430, 431; 430, 432; 431, identifier:showinh; 432, identifier:showinh; 433, identifier:split; 434, argument_list; 434, 435; 435, string:'\n '; 436, identifier:files | def _MakePackagePages(self, package, showprivate=False, nested=False, showinh=False):
def checkNoNested(mod):
try:
all = mod.__all__
except AttributeError:
return False
mems = inspect.getmembers(mod, inspect.ismodule)
mems = [m for m in mems if m[0] in mod.__all__]
if len(mems) > 0:
return False
return True
mods = inspect.getmembers(package, inspect.ismodule)
nmods, pvt, npkgs = [], [], []
for mod in mods:
if checkNoNested(mod[1]):
if mod[0][0] == '_': pvt.append(mod)
else: nmods.append(mod)
else: npkgs.append(mod)
if showprivate: nmods += pvt
files = []
ignore = []
for pkg in npkgs:
pt = '%s/%s/%s' % (self.path, package.__name__.replace('.', '/'), pkg[1].__name__.split('.')[-1])
if os.path.exists(pt): shutil.rmtree(pt)
os.makedirs(pt)
ignore += inspect.getmembers(pkg[1])
f = self._MakePackagePages(pkg[1], showprivate=showprivate, nested=True, showinh=showinh)
files.append(f.split(package.__name__.replace('.', '/')+'/')[1])
if nested:
try:
name = package.__displayname__
except AttributeError:
name = package.__name__
index = r'''
%s
%s
.. toctree::
:maxdepth: 5
''' % (name, '*' * len(name))
index += '\n '.join(files)
index += '\n ' + self._ProduceContent(nmods, showprivate=showprivate, showinh=showinh)
findex = 'content/%s/index.rst' % (package.__name__.replace('.', '/'))
with open(findex, 'w') as f:
if package.__doc__: f.write(package.__doc__)
f.write(index)
return '\n ' + findex
names = '\n %s/%s/' % ( self.path, package.__name__.replace('.', '/'))
nmods = [m for m in nmods if m not in ignore]
return names.join(self._ProduceContent(nmods, showprivate=showprivate, showinh=showinh).split('\n ')+files) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:_DocPackageFromTop; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:packages; 6, default_parameter; 6, 7; 6, 8; 7, identifier:showprivate; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:showinh; 11, False; 12, block; 12, 13; 12, 17; 12, 30; 12, 47; 12, 54; 12, 61; 12, 303; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:appIndex; 16, string:''; 17, if_statement; 17, 18; 17, 24; 18, not_operator; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:isinstance; 21, argument_list; 21, 22; 21, 23; 22, identifier:packages; 23, identifier:list; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:packages; 28, list:[packages]; 28, 29; 29, identifier:packages; 30, if_statement; 30, 31; 30, 39; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:os; 35, identifier:path; 36, identifier:exists; 37, argument_list; 37, 38; 38, string:'content'; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:shutil; 44, identifier:rmtree; 45, argument_list; 45, 46; 46, string:'content'; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:os; 51, identifier:makedirs; 52, argument_list; 52, 53; 53, string:'content'; 54, expression_statement; 54, 55; 55, augmented_assignment:+=; 55, 56; 55, 57; 56, identifier:appIndex; 57, binary_operator:%; 57, 58; 57, 59; 58, string:r'''
.. toctree::
:maxdepth: 5
:hidden:
:caption: %s:
'''; 59, parenthesized_expression; 59, 60; 60, string:'API Index'; 61, for_statement; 61, 62; 61, 63; 61, 70; 62, identifier:i; 63, call; 63, 64; 63, 65; 64, identifier:range; 65, argument_list; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, identifier:packages; 70, block; 70, 71; 70, 77; 70, 94; 70, 102; 70, 119; 70, 126; 70, 141; 70, 150; 70, 159; 70, 168; 70, 177; 70, 186; 70, 195; 70, 204; 70, 213; 70, 221; 70, 228; 70, 243; 70, 255; 70, 297; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:package; 74, subscript; 74, 75; 74, 76; 75, identifier:packages; 76, identifier:i; 77, try_statement; 77, 78; 77, 85; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:name; 82, attribute; 82, 83; 82, 84; 83, identifier:package; 84, identifier:__displayname__; 85, except_clause; 85, 86; 85, 87; 86, identifier:AttributeError; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:name; 91, attribute; 91, 92; 91, 93; 92, identifier:package; 93, identifier:__name__; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:path; 97, binary_operator:%; 97, 98; 97, 99; 98, string:'content/%s'; 99, attribute; 99, 100; 99, 101; 100, identifier:package; 101, identifier:__name__; 102, if_statement; 102, 103; 102, 111; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:os; 107, identifier:path; 108, identifier:exists; 109, argument_list; 109, 110; 110, identifier:path; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:shutil; 116, identifier:rmtree; 117, argument_list; 117, 118; 118, identifier:path; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:os; 123, identifier:makedirs; 124, argument_list; 124, 125; 125, identifier:path; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:meta; 129, binary_operator:%; 129, 130; 129, 131; 130, string:'About %s\n%s\n'; 131, tuple; 131, 132; 131, 133; 132, identifier:name; 133, binary_operator:*; 133, 134; 133, 135; 134, string:'='; 135, call; 135, 136; 135, 137; 136, identifier:len; 137, argument_list; 137, 138; 138, binary_operator:+; 138, 139; 138, 140; 139, string:'About '; 140, identifier:name; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:author; 144, call; 144, 145; 144, 146; 145, identifier:getattr; 146, argument_list; 146, 147; 146, 148; 146, 149; 147, identifier:package; 148, string:"__author__"; 149, None; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:license; 153, call; 153, 154; 153, 155; 154, identifier:getattr; 155, argument_list; 155, 156; 155, 157; 155, 158; 156, identifier:package; 157, string:"__license__"; 158, None; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:copyright; 162, call; 162, 163; 162, 164; 163, identifier:getattr; 164, argument_list; 164, 165; 164, 166; 164, 167; 165, identifier:package; 166, string:"__copyright__"; 167, None; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:version; 171, call; 171, 172; 171, 173; 172, identifier:getattr; 173, argument_list; 173, 174; 173, 175; 173, 176; 174, identifier:package; 175, string:"__version__"; 176, None; 177, if_statement; 177, 178; 177, 179; 178, identifier:author; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, augmented_assignment:+=; 181, 182; 181, 183; 182, identifier:meta; 183, binary_operator:%; 183, 184; 183, 185; 184, string:'\n* Author: %s'; 185, identifier:author; 186, if_statement; 186, 187; 186, 188; 187, identifier:license; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, augmented_assignment:+=; 190, 191; 190, 192; 191, identifier:meta; 192, binary_operator:%; 192, 193; 192, 194; 193, string:'\n* License: %s'; 194, identifier:license; 195, if_statement; 195, 196; 195, 197; 196, identifier:copyright; 197, block; 197, 198; 198, expression_statement; 198, 199; 199, augmented_assignment:+=; 199, 200; 199, 201; 200, identifier:meta; 201, binary_operator:%; 201, 202; 201, 203; 202, string:'\n* Copyright: %s'; 203, identifier:copyright; 204, if_statement; 204, 205; 204, 206; 205, identifier:version; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, augmented_assignment:+=; 208, 209; 208, 210; 209, identifier:meta; 210, binary_operator:%; 210, 211; 210, 212; 211, string:'\n* Version: %s'; 212, identifier:version; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:about; 216, binary_operator:%; 216, 217; 216, 218; 217, string:'%s/%s'; 218, tuple; 218, 219; 218, 220; 219, identifier:path; 220, string:'index.rst'; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:this_toc; 224, binary_operator:%; 224, 225; 224, 226; 225, string:r'''
.. toctree::
:maxdepth: 5
:caption: %s:
'''; 226, parenthesized_expression; 226, 227; 227, identifier:name; 228, expression_statement; 228, 229; 229, augmented_assignment:+=; 229, 230; 229, 231; 230, identifier:this_toc; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:self; 234, identifier:_MakePackagePages; 235, argument_list; 235, 236; 235, 237; 235, 240; 236, identifier:package; 237, keyword_argument; 237, 238; 237, 239; 238, identifier:showprivate; 239, identifier:showprivate; 240, keyword_argument; 240, 241; 240, 242; 241, identifier:showinh; 242, identifier:showinh; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:this_toc; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:this_toc; 249, identifier:replace; 250, argument_list; 250, 251; 250, 254; 251, binary_operator:%; 251, 252; 251, 253; 252, string:'%s/'; 253, identifier:path; 254, string:''; 255, with_statement; 255, 256; 255, 266; 256, with_clause; 256, 257; 257, with_item; 257, 258; 258, as_pattern; 258, 259; 258, 264; 259, call; 259, 260; 259, 261; 260, identifier:open; 261, argument_list; 261, 262; 261, 263; 262, identifier:about; 263, string:'w'; 264, as_pattern_target; 264, 265; 265, identifier:f; 266, block; 266, 267; 266, 276; 266, 290; 267, expression_statement; 267, 268; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:f; 271, identifier:write; 272, argument_list; 272, 273; 273, binary_operator:%; 273, 274; 273, 275; 274, string:'%s\n\n'; 275, identifier:meta; 276, if_statement; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:package; 279, identifier:__doc__; 280, block; 280, 281; 281, expression_statement; 281, 282; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:f; 285, identifier:write; 286, argument_list; 286, 287; 287, attribute; 287, 288; 287, 289; 288, identifier:package; 289, identifier:__doc__; 290, expression_statement; 290, 291; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:f; 294, identifier:write; 295, argument_list; 295, 296; 296, identifier:this_toc; 297, expression_statement; 297, 298; 298, augmented_assignment:+=; 298, 299; 298, 300; 299, identifier:appIndex; 300, binary_operator:%; 300, 301; 300, 302; 301, string:'\n %s'; 302, identifier:about; 303, return_statement; 303, 304; 304, identifier:appIndex | def _DocPackageFromTop(self, packages, showprivate=False, showinh=False):
appIndex = ''
if not isinstance(packages, list):
packages = [packages]
if os.path.exists('content'):
shutil.rmtree('content')
os.makedirs('content')
appIndex += r'''
.. toctree::
:maxdepth: 5
:hidden:
:caption: %s:
''' % ('API Index')
for i in range(len(packages)):
package = packages[i]
try:
name = package.__displayname__
except AttributeError:
name = package.__name__
path = 'content/%s' % package.__name__
if os.path.exists(path):
shutil.rmtree(path)
os.makedirs(path)
meta = 'About %s\n%s\n' % (name, '='*len('About ' + name))
author = getattr(package, "__author__", None)
license = getattr(package, "__license__", None)
copyright = getattr(package, "__copyright__", None)
version = getattr(package, "__version__", None)
if author: meta += '\n* Author: %s' % author
if license: meta += '\n* License: %s' % license
if copyright: meta += '\n* Copyright: %s' % copyright
if version: meta += '\n* Version: %s' % version
about = '%s/%s' % (path, 'index.rst')
this_toc = r'''
.. toctree::
:maxdepth: 5
:caption: %s:
''' % (name)
this_toc += self._MakePackagePages(package, showprivate=showprivate, showinh=showinh)
this_toc = this_toc.replace('%s/' % path, '')
with open(about, 'w') as f:
f.write('%s\n\n' % meta)
if package.__doc__:
f.write(package.__doc__)
f.write(this_toc)
appIndex += '\n %s' % about
return appIndex |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:cmd; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:send; 5, identifier:msg; 6, identifier:args; 7, block; 7, 8; 7, 27; 7, 40; 7, 81; 7, 93; 7, 97; 7, 101; 7, 163; 7, 178; 8, if_statement; 8, 9; 8, 20; 9, not_operator; 9, 10; 10, call; 10, 11; 10, 18; 11, attribute; 11, 12; 11, 17; 12, subscript; 12, 13; 12, 16; 13, subscript; 13, 14; 13, 15; 14, identifier:args; 15, string:'config'; 16, string:'feature'; 17, identifier:getboolean; 18, argument_list; 18, 19; 19, string:'hooks'; 20, block; 20, 21; 20, 26; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:send; 24, argument_list; 24, 25; 25, string:"Hooks are disabled, and this command depends on hooks. Please contact the bot admin(s)."; 26, return_statement; 27, if_statement; 27, 28; 27, 33; 28, comparison_operator:==; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:args; 31, string:'type'; 32, string:'privmsg'; 33, block; 33, 34; 33, 39; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:send; 37, argument_list; 37, 38; 38, string:"Note-passing should be done in public."; 39, return_statement; 40, try_statement; 40, 41; 40, 72; 41, block; 41, 42; 41, 55; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, pattern_list; 44, 45; 44, 46; 45, identifier:nick; 46, identifier:note; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:msg; 50, identifier:split; 51, argument_list; 51, 52; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:maxsplit; 54, integer:1; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:nicks; 58, call; 58, 59; 58, 60; 59, identifier:set; 60, generator_expression; 60, 61; 60, 62; 60, 70; 61, identifier:x; 62, for_in_clause; 62, 63; 62, 64; 63, identifier:x; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:nick; 67, identifier:split; 68, argument_list; 68, 69; 69, string:','; 70, if_clause; 70, 71; 71, identifier:x; 72, except_clause; 72, 73; 72, 74; 73, identifier:ValueError; 74, block; 74, 75; 74, 80; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:send; 78, argument_list; 78, 79; 79, string:"Not enough arguments."; 80, return_statement; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:nickregex; 84, binary_operator:+; 84, 85; 84, 92; 85, subscript; 85, 86; 85, 91; 86, subscript; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:args; 89, string:'config'; 90, string:'core'; 91, string:'nickregex'; 92, string:'+$'; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:successful_nicks; 96, list:[]; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:failed_nicks; 100, list:[]; 101, for_statement; 101, 102; 101, 103; 101, 104; 102, identifier:nick; 103, identifier:nicks; 104, block; 104, 105; 105, if_statement; 105, 106; 105, 113; 105, 154; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:re; 109, identifier:match; 110, argument_list; 110, 111; 110, 112; 111, identifier:nickregex; 112, identifier:nick; 113, block; 113, 114; 113, 138; 113, 147; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:row; 117, call; 117, 118; 117, 119; 118, identifier:Notes; 119, argument_list; 119, 120; 119, 123; 119, 128; 119, 131; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:note; 122, identifier:note; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:submitter; 125, subscript; 125, 126; 125, 127; 126, identifier:args; 127, string:'nick'; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:nick; 130, identifier:nick; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:time; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:datetime; 136, identifier:now; 137, argument_list; 138, expression_statement; 138, 139; 139, call; 139, 140; 139, 145; 140, attribute; 140, 141; 140, 144; 141, subscript; 141, 142; 141, 143; 142, identifier:args; 143, string:'db'; 144, identifier:add; 145, argument_list; 145, 146; 146, identifier:row; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:successful_nicks; 151, identifier:append; 152, argument_list; 152, 153; 153, identifier:nick; 154, else_clause; 154, 155; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:failed_nicks; 160, identifier:append; 161, argument_list; 161, 162; 162, identifier:nick; 163, if_statement; 163, 164; 163, 165; 164, identifier:successful_nicks; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 169; 168, identifier:send; 169, argument_list; 169, 170; 170, binary_operator:%; 170, 171; 170, 172; 171, string:"Note left for %s."; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, string:", "; 175, identifier:join; 176, argument_list; 176, 177; 177, identifier:successful_nicks; 178, if_statement; 178, 179; 178, 180; 179, identifier:failed_nicks; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:send; 184, argument_list; 184, 185; 185, binary_operator:%; 185, 186; 185, 187; 186, string:"Invalid nick(s): %s."; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, string:", "; 190, identifier:join; 191, argument_list; 191, 192; 192, identifier:failed_nicks | def cmd(send, msg, args):
if not args['config']['feature'].getboolean('hooks'):
send("Hooks are disabled, and this command depends on hooks. Please contact the bot admin(s).")
return
if args['type'] == 'privmsg':
send("Note-passing should be done in public.")
return
try:
nick, note = msg.split(maxsplit=1)
nicks = set(x for x in nick.split(',') if x)
except ValueError:
send("Not enough arguments.")
return
nickregex = args['config']['core']['nickregex'] + '+$'
successful_nicks = []
failed_nicks = []
for nick in nicks:
if re.match(nickregex, nick):
row = Notes(note=note, submitter=args['nick'], nick=nick, time=datetime.now())
args['db'].add(row)
successful_nicks.append(nick)
else:
failed_nicks.append(nick)
if successful_nicks:
send("Note left for %s." % ", ".join(successful_nicks))
if failed_nicks:
send("Invalid nick(s): %s." % ", ".join(failed_nicks)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:add_category; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:category; 6, block; 6, 7; 6, 9; 7, expression_statement; 7, 8; 8, string:'''
Add unicode category to set
Unicode categories are strings like 'Ll', 'Lu', 'Nd', etc.
See `unicodedata.category()`
'''; 9, if_statement; 9, 10; 9, 15; 9, 22; 9, 37; 9, 69; 9, 103; 9, 145; 10, comparison_operator:==; 10, 11; 10, 12; 11, identifier:category; 12, attribute; 12, 13; 12, 14; 13, identifier:sre; 14, identifier:CATEGORY_DIGIT; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, augmented_assignment:|=; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_categories; 21, identifier:UNICODE_DIGIT_CATEGORIES; 22, elif_clause; 22, 23; 22, 28; 23, comparison_operator:==; 23, 24; 23, 25; 24, identifier:category; 25, attribute; 25, 26; 25, 27; 26, identifier:sre; 27, identifier:CATEGORY_NOT_DIGIT; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, augmented_assignment:|=; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:_categories; 34, binary_operator:-; 34, 35; 34, 36; 35, identifier:UNICODE_CATEGORIES; 36, identifier:UNICODE_DIGIT_CATEGORIES; 37, elif_clause; 37, 38; 37, 43; 38, comparison_operator:==; 38, 39; 38, 40; 39, identifier:category; 40, attribute; 40, 41; 40, 42; 41, identifier:sre; 42, identifier:CATEGORY_SPACE; 43, block; 43, 44; 43, 50; 44, expression_statement; 44, 45; 45, augmented_assignment:|=; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:_categories; 49, identifier:UNICODE_SPACE_CATEGORIES; 50, for_statement; 50, 51; 50, 52; 50, 59; 51, identifier:c; 52, parenthesized_expression; 52, 53; 53, conditional_expression:if; 53, 54; 53, 55; 53, 58; 54, identifier:UNICODE_SPACE_CHARS; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:_unicode; 58, identifier:SPACE_CHARS; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 67; 62, attribute; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:_whitelist_chars; 66, identifier:add; 67, argument_list; 67, 68; 68, identifier:c; 69, elif_clause; 69, 70; 69, 75; 70, comparison_operator:==; 70, 71; 70, 72; 71, identifier:category; 72, attribute; 72, 73; 72, 74; 73, identifier:sre; 74, identifier:CATEGORY_NOT_SPACE; 75, block; 75, 76; 75, 84; 76, expression_statement; 76, 77; 77, augmented_assignment:|=; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_categories; 81, binary_operator:-; 81, 82; 81, 83; 82, identifier:UNICODE_CATEGORIES; 83, identifier:UNICODE_SPACE_CATEGORIES; 84, for_statement; 84, 85; 84, 86; 84, 93; 85, identifier:c; 86, parenthesized_expression; 86, 87; 87, conditional_expression:if; 87, 88; 87, 89; 87, 92; 88, identifier:UNICODE_SPACE_CHARS; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:_unicode; 92, identifier:SPACE_CHARS; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 101; 96, attribute; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:_blacklist_chars; 100, identifier:add; 101, argument_list; 101, 102; 102, identifier:c; 103, elif_clause; 103, 104; 103, 109; 104, comparison_operator:==; 104, 105; 104, 106; 105, identifier:category; 106, attribute; 106, 107; 106, 108; 107, identifier:sre; 108, identifier:CATEGORY_WORD; 109, block; 109, 110; 109, 116; 109, 125; 110, expression_statement; 110, 111; 111, augmented_assignment:|=; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:_categories; 115, identifier:UNICODE_WORD_CATEGORIES; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 123; 118, attribute; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:self; 121, identifier:_whitelist_chars; 122, identifier:add; 123, argument_list; 123, 124; 124, string:u'_'; 125, if_statement; 125, 126; 125, 131; 126, boolean_operator:and; 126, 127; 126, 128; 127, identifier:HAS_WEIRD_WORD_CHARS; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:_unicode; 131, block; 131, 132; 132, for_statement; 132, 133; 132, 134; 132, 135; 133, identifier:c; 134, identifier:UNICODE_WEIRD_NONWORD_CHARS; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:_blacklist_chars; 142, identifier:add; 143, argument_list; 143, 144; 144, identifier:c; 145, elif_clause; 145, 146; 145, 151; 146, comparison_operator:==; 146, 147; 146, 148; 147, identifier:category; 148, attribute; 148, 149; 148, 150; 149, identifier:sre; 150, identifier:CATEGORY_NOT_WORD; 151, block; 151, 152; 151, 160; 151, 169; 152, expression_statement; 152, 153; 153, augmented_assignment:|=; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:_categories; 157, binary_operator:-; 157, 158; 157, 159; 158, identifier:UNICODE_CATEGORIES; 159, identifier:UNICODE_WORD_CATEGORIES; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 167; 162, attribute; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:_blacklist_chars; 166, identifier:add; 167, argument_list; 167, 168; 168, string:u'_'; 169, if_statement; 169, 170; 169, 175; 170, boolean_operator:and; 170, 171; 170, 172; 171, identifier:HAS_WEIRD_WORD_CHARS; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:_unicode; 175, block; 175, 176; 176, for_statement; 176, 177; 176, 178; 176, 179; 177, identifier:c; 178, identifier:UNICODE_WEIRD_NONWORD_CHARS; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 187; 182, attribute; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:_whitelist_chars; 186, identifier:add; 187, argument_list; 187, 188; 188, identifier:c | def add_category(self, category):
'''
Add unicode category to set
Unicode categories are strings like 'Ll', 'Lu', 'Nd', etc.
See `unicodedata.category()`
'''
if category == sre.CATEGORY_DIGIT:
self._categories |= UNICODE_DIGIT_CATEGORIES
elif category == sre.CATEGORY_NOT_DIGIT:
self._categories |= UNICODE_CATEGORIES - UNICODE_DIGIT_CATEGORIES
elif category == sre.CATEGORY_SPACE:
self._categories |= UNICODE_SPACE_CATEGORIES
for c in (UNICODE_SPACE_CHARS if self._unicode else SPACE_CHARS):
self._whitelist_chars.add(c)
elif category == sre.CATEGORY_NOT_SPACE:
self._categories |= UNICODE_CATEGORIES - UNICODE_SPACE_CATEGORIES
for c in (UNICODE_SPACE_CHARS if self._unicode else SPACE_CHARS):
self._blacklist_chars.add(c)
elif category == sre.CATEGORY_WORD:
self._categories |= UNICODE_WORD_CATEGORIES
self._whitelist_chars.add(u'_')
if HAS_WEIRD_WORD_CHARS and self._unicode:
for c in UNICODE_WEIRD_NONWORD_CHARS:
self._blacklist_chars.add(c)
elif category == sre.CATEGORY_NOT_WORD:
self._categories |= UNICODE_CATEGORIES - UNICODE_WORD_CATEGORIES
self._blacklist_chars.add(u'_')
if HAS_WEIRD_WORD_CHARS and self._unicode:
for c in UNICODE_WEIRD_NONWORD_CHARS:
self._whitelist_chars.add(c) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_estimate_free; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 16; 5, 32; 5, 40; 5, 47; 5, 60; 5, 67; 5, 80; 5, 94; 5, 102; 5, 114; 5, 120; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:capacity_deferred; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:channel; 14, identifier:total_capacity; 15, argument_list; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:open_tasks_deferred; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:channel; 24, identifier:tasks; 25, argument_list; 25, 26; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:state; 28, list:[task_states.OPEN]; 28, 29; 29, attribute; 29, 30; 29, 31; 30, identifier:task_states; 31, identifier:OPEN; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:avg_delta_deferred; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:estimate_duration; 39, argument_list; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:deferreds; 43, list:[capacity_deferred,
open_tasks_deferred,
avg_delta_deferred]; 43, 44; 43, 45; 43, 46; 44, identifier:capacity_deferred; 45, identifier:open_tasks_deferred; 46, identifier:avg_delta_deferred; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:results; 50, yield; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:defer; 54, identifier:gatherResults; 55, argument_list; 55, 56; 55, 57; 56, identifier:deferreds; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:consumeErrors; 59, True; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 66; 62, pattern_list; 62, 63; 62, 64; 62, 65; 63, identifier:capacity; 64, identifier:open_tasks; 65, identifier:avg_delta; 66, identifier:results; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:open_weight; 70, call; 70, 71; 70, 72; 71, identifier:sum; 72, argument_list; 72, 73; 73, list_comprehension; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:task; 76, identifier:weight; 77, for_in_clause; 77, 78; 77, 79; 78, identifier:task; 79, identifier:open_tasks; 80, if_statement; 80, 81; 80, 84; 81, comparison_operator:>=; 81, 82; 81, 83; 82, identifier:open_weight; 83, identifier:capacity; 84, block; 84, 85; 85, raise_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:NotImplementedError; 88, argument_list; 88, 89; 89, binary_operator:%; 89, 90; 89, 91; 90, string:'channel %d is at capacity'; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:channel_id; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:start_time; 97, binary_operator:+; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:created; 101, identifier:SLEEPTIME; 102, if_statement; 102, 103; 102, 106; 103, comparison_operator:is; 103, 104; 103, 105; 104, identifier:avg_delta; 105, None; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:defer; 111, identifier:returnValue; 112, argument_list; 112, 113; 113, None; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:est_completion; 117, binary_operator:+; 117, 118; 117, 119; 118, identifier:start_time; 119, identifier:avg_delta; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:defer; 124, identifier:returnValue; 125, argument_list; 125, 126; 126, identifier:est_completion | def _estimate_free(self):
capacity_deferred = self.channel.total_capacity()
open_tasks_deferred = self.channel.tasks(state=[task_states.OPEN])
avg_delta_deferred = self.estimate_duration()
deferreds = [capacity_deferred,
open_tasks_deferred,
avg_delta_deferred]
results = yield defer.gatherResults(deferreds, consumeErrors=True)
capacity, open_tasks, avg_delta = results
open_weight = sum([task.weight for task in open_tasks])
if open_weight >= capacity:
raise NotImplementedError('channel %d is at capacity' %
self.channel_id)
start_time = self.created + SLEEPTIME
if avg_delta is None:
defer.returnValue(None)
est_completion = start_time + avg_delta
defer.returnValue(est_completion) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:package; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 21; 5, 37; 5, 52; 5, 67; 5, 75; 5, 82; 5, 164; 6, if_statement; 6, 7; 6, 12; 7, comparison_operator:==; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:method; 11, string:'buildNotification'; 12, block; 12, 13; 13, return_statement; 13, 14; 14, subscript; 14, 15; 14, 20; 15, subscript; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:params; 19, integer:1; 20, string:'name'; 21, if_statement; 21, 22; 21, 30; 22, comparison_operator:in; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:method; 26, tuple; 26, 27; 26, 28; 26, 29; 27, string:'createImage'; 28, string:'image'; 29, string:'livecd'; 30, block; 30, 31; 31, return_statement; 31, 32; 32, subscript; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:params; 36, integer:0; 37, if_statement; 37, 38; 37, 43; 38, comparison_operator:==; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:method; 42, string:'indirectionimage'; 43, block; 43, 44; 44, return_statement; 44, 45; 45, subscript; 45, 46; 45, 51; 46, subscript; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:params; 50, integer:0; 51, string:'name'; 52, if_statement; 52, 53; 52, 64; 53, comparison_operator:not; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:method; 57, tuple; 57, 58; 57, 59; 57, 60; 57, 61; 57, 62; 57, 63; 58, string:'build'; 59, string:'buildArch'; 60, string:'buildContainer'; 61, string:'buildMaven'; 62, string:'buildSRPMFromSCM'; 63, string:'maven'; 64, block; 64, 65; 65, return_statement; 65, 66; 66, None; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:source; 70, subscript; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:params; 74, integer:0; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:o; 78, call; 78, 79; 78, 80; 79, identifier:urlparse; 80, argument_list; 80, 81; 81, identifier:source; 82, if_statement; 82, 83; 82, 89; 82, 116; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:source; 86, identifier:endswith; 87, argument_list; 87, 88; 88, string:'.src.rpm'; 89, block; 89, 90; 89, 101; 89, 114; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:srpm; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:os; 97, identifier:path; 98, identifier:basename; 99, argument_list; 99, 100; 100, identifier:source; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 107; 103, tuple_pattern; 103, 104; 103, 105; 103, 106; 104, identifier:name; 105, identifier:version; 106, identifier:release; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:srpm; 110, identifier:rsplit; 111, argument_list; 111, 112; 111, 113; 112, string:'-'; 113, integer:2; 114, return_statement; 114, 115; 115, identifier:name; 116, elif_clause; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:o; 119, identifier:scheme; 120, block; 120, 121; 120, 134; 120, 151; 120, 162; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:package; 124, call; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:os; 128, identifier:path; 129, identifier:basename; 130, argument_list; 130, 131; 131, attribute; 131, 132; 131, 133; 132, identifier:o; 133, identifier:path; 134, if_statement; 134, 135; 134, 141; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:package; 138, identifier:endswith; 139, argument_list; 139, 140; 140, string:'.git'; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:package; 145, subscript; 145, 146; 145, 147; 146, identifier:package; 147, slice; 147, 148; 147, 149; 148, colon; 149, unary_operator:-; 149, 150; 150, integer:4; 151, if_statement; 151, 152; 151, 157; 152, comparison_operator:==; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:method; 156, string:'buildContainer'; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, augmented_assignment:+=; 159, 160; 159, 161; 160, identifier:package; 161, string:'-container'; 162, return_statement; 162, 163; 163, identifier:package; 164, raise_statement; 164, 165; 165, call; 165, 166; 165, 167; 166, identifier:ValueError; 167, argument_list; 167, 168; 168, binary_operator:%; 168, 169; 168, 170; 169, string:'could not parse source "%s"'; 170, identifier:source | def package(self):
if self.method == 'buildNotification':
return self.params[1]['name']
if self.method in ('createImage', 'image', 'livecd'):
return self.params[0]
if self.method == 'indirectionimage':
return self.params[0]['name']
if self.method not in ('build', 'buildArch', 'buildContainer',
'buildMaven', 'buildSRPMFromSCM', 'maven'):
return None
source = self.params[0]
o = urlparse(source)
if source.endswith('.src.rpm'):
srpm = os.path.basename(source)
(name, version, release) = srpm.rsplit('-', 2)
return name
elif o.scheme:
package = os.path.basename(o.path)
if package.endswith('.git'):
package = package[:-4]
if self.method == 'buildContainer':
package += '-container'
return package
raise ValueError('could not parse source "%s"' % source) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:is_admin; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:send; 6, identifier:nick; 7, default_parameter; 7, 8; 7, 9; 8, identifier:required_role; 9, string:'admin'; 10, block; 10, 11; 10, 17; 11, if_statement; 11, 12; 11, 14; 12, not_operator; 12, 13; 13, identifier:required_role; 14, block; 14, 15; 15, return_statement; 15, 16; 16, True; 17, with_statement; 17, 18; 17, 30; 18, with_clause; 18, 19; 19, with_item; 19, 20; 20, as_pattern; 20, 21; 20, 28; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:db; 26, identifier:session_scope; 27, argument_list; 28, as_pattern_target; 28, 29; 29, identifier:session; 30, block; 30, 31; 30, 57; 30, 64; 30, 77; 30, 92; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:admin; 34, call; 34, 35; 34, 56; 35, attribute; 35, 36; 35, 55; 36, call; 36, 37; 36, 47; 37, attribute; 37, 38; 37, 46; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:session; 41, identifier:query; 42, argument_list; 42, 43; 43, attribute; 43, 44; 43, 45; 44, identifier:orm; 45, identifier:Permissions; 46, identifier:filter; 47, argument_list; 47, 48; 48, comparison_operator:==; 48, 49; 48, 54; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:orm; 52, identifier:Permissions; 53, identifier:nick; 54, identifier:nick; 55, identifier:first; 56, argument_list; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:admin; 60, None; 61, block; 61, 62; 62, return_statement; 62, 63; 63, False; 64, if_statement; 64, 65; 64, 74; 65, boolean_operator:and; 65, 66; 65, 69; 66, comparison_operator:==; 66, 67; 66, 68; 67, identifier:required_role; 68, string:"owner"; 69, comparison_operator:!=; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:admin; 72, identifier:role; 73, string:"owner"; 74, block; 74, 75; 75, return_statement; 75, 76; 76, False; 77, if_statement; 77, 78; 77, 89; 78, not_operator; 78, 79; 79, call; 79, 80; 79, 87; 80, attribute; 80, 81; 80, 86; 81, subscript; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:config; 85, string:'feature'; 86, identifier:getboolean; 87, argument_list; 87, 88; 88, string:'nickserv'; 89, block; 89, 90; 90, return_statement; 90, 91; 91, True; 92, if_statement; 92, 93; 92, 97; 92, 128; 93, not_operator; 93, 94; 94, attribute; 94, 95; 94, 96; 95, identifier:admin; 96, identifier:registered; 97, block; 97, 98; 97, 105; 97, 126; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:update_authstatus; 103, argument_list; 103, 104; 104, identifier:nick; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:is; 106, 107; 106, 108; 107, identifier:send; 108, None; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:send; 113, argument_list; 113, 114; 113, 117; 114, binary_operator:%; 114, 115; 114, 116; 115, string:"Unverified admin: %s"; 116, identifier:nick; 117, keyword_argument; 117, 118; 117, 119; 118, identifier:target; 119, subscript; 119, 120; 119, 125; 120, subscript; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:config; 124, string:'core'; 125, string:'channel'; 126, return_statement; 126, 127; 127, False; 128, else_clause; 128, 129; 129, block; 129, 130; 129, 163; 130, if_statement; 130, 131; 130, 137; 131, not_operator; 131, 132; 132, subscript; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:features; 136, string:'account-notify'; 137, block; 137, 138; 138, if_statement; 138, 139; 138, 155; 139, comparison_operator:>; 139, 140; 139, 149; 140, binary_operator:-; 140, 141; 140, 146; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:datetime; 144, identifier:now; 145, argument_list; 146, attribute; 146, 147; 146, 148; 147, identifier:admin; 148, identifier:time; 149, call; 149, 150; 149, 151; 150, identifier:timedelta; 151, argument_list; 151, 152; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:minutes; 154, integer:5; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:update_authstatus; 161, argument_list; 161, 162; 162, identifier:nick; 163, return_statement; 163, 164; 164, True | def is_admin(self, send, nick, required_role='admin'):
if not required_role:
return True
with self.db.session_scope() as session:
admin = session.query(orm.Permissions).filter(orm.Permissions.nick == nick).first()
if admin is None:
return False
if required_role == "owner" and admin.role != "owner":
return False
if not self.config['feature'].getboolean('nickserv'):
return True
if not admin.registered:
self.update_authstatus(nick)
if send is not None:
send("Unverified admin: %s" % nick, target=self.config['core']['channel'])
return False
else:
if not self.features['account-notify']:
if datetime.now() - admin.time > timedelta(minutes=5):
self.update_authstatus(nick)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:do_mode; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:target; 6, identifier:msg; 7, identifier:nick; 8, identifier:send; 9, block; 9, 10; 9, 21; 9, 84; 9, 138; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:mode_changes; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:irc; 17, identifier:modes; 18, identifier:parse_channel_modes; 19, argument_list; 19, 20; 20, identifier:msg; 21, with_statement; 21, 22; 21, 27; 22, with_clause; 22, 23; 23, with_item; 23, 24; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:data_lock; 27, block; 27, 28; 28, for_statement; 28, 29; 28, 30; 28, 31; 29, identifier:change; 30, identifier:mode_changes; 31, block; 31, 32; 31, 58; 32, if_statement; 32, 33; 32, 38; 33, comparison_operator:==; 33, 34; 33, 37; 34, subscript; 34, 35; 34, 36; 35, identifier:change; 36, integer:1; 37, string:'v'; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 50; 41, subscript; 41, 42; 41, 47; 42, subscript; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:voiced; 46, identifier:target; 47, subscript; 47, 48; 47, 49; 48, identifier:change; 49, integer:2; 50, conditional_expression:if; 50, 51; 50, 52; 50, 57; 51, True; 52, comparison_operator:==; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:change; 55, integer:0; 56, string:'+'; 57, False; 58, if_statement; 58, 59; 58, 64; 59, comparison_operator:==; 59, 60; 59, 63; 60, subscript; 60, 61; 60, 62; 61, identifier:change; 62, integer:1; 63, string:'o'; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 76; 67, subscript; 67, 68; 67, 73; 68, subscript; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:opers; 72, identifier:target; 73, subscript; 73, 74; 73, 75; 74, identifier:change; 75, integer:2; 76, conditional_expression:if; 76, 77; 76, 78; 76, 83; 77, True; 78, comparison_operator:==; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:change; 81, integer:0; 82, string:'+'; 83, False; 84, if_statement; 84, 85; 84, 97; 85, list_comprehension; 85, 86; 85, 87; 85, 90; 86, identifier:x; 87, for_in_clause; 87, 88; 87, 89; 88, identifier:x; 89, identifier:mode_changes; 90, if_clause; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:check_mode; 95, argument_list; 95, 96; 96, identifier:x; 97, block; 97, 98; 97, 108; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:send; 101, argument_list; 101, 102; 101, 105; 102, binary_operator:%; 102, 103; 102, 104; 103, string:"%s: :("; 104, identifier:nick; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:target; 107, identifier:target; 108, if_statement; 108, 109; 108, 117; 109, not_operator; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:is_admin; 114, argument_list; 114, 115; 114, 116; 115, None; 116, identifier:nick; 117, block; 117, 118; 117, 128; 118, expression_statement; 118, 119; 119, call; 119, 120; 119, 121; 120, identifier:send; 121, argument_list; 121, 122; 121, 125; 122, binary_operator:%; 122, 123; 122, 124; 123, string:"OP %s"; 124, identifier:target; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:target; 127, string:'ChanServ'; 128, expression_statement; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:send; 131, argument_list; 131, 132; 131, 135; 132, binary_operator:%; 132, 133; 132, 134; 133, string:"UNBAN %s"; 134, identifier:target; 135, keyword_argument; 135, 136; 135, 137; 136, identifier:target; 137, string:'ChanServ'; 138, if_statement; 138, 139; 138, 147; 139, comparison_operator:>; 139, 140; 139, 146; 140, call; 140, 141; 140, 142; 141, identifier:len; 142, argument_list; 142, 143; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:guarded; 146, integer:0; 147, block; 147, 148; 147, 161; 147, 171; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:regex; 151, binary_operator:%; 151, 152; 151, 153; 152, string:r"(.*(-v|-o|\+q|\+b)[^ ]*) (%s)"; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, string:"|"; 156, identifier:join; 157, argument_list; 157, 158; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:guarded; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:match; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:re; 167, identifier:search; 168, argument_list; 168, 169; 168, 170; 169, identifier:regex; 170, identifier:msg; 171, if_statement; 171, 172; 171, 188; 172, boolean_operator:and; 172, 173; 172, 174; 173, identifier:match; 174, comparison_operator:not; 174, 175; 174, 176; 175, identifier:nick; 176, list:[match.group(3), self.connection.real_nickname]; 176, 177; 176, 183; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:match; 180, identifier:group; 181, argument_list; 181, 182; 182, integer:3; 183, attribute; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:connection; 187, identifier:real_nickname; 188, block; 188, 189; 188, 209; 188, 219; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:modestring; 192, binary_operator:%; 192, 193; 192, 194; 193, string:"+voe-qb %s"; 194, parenthesized_expression; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, string:" "; 198, identifier:join; 199, argument_list; 199, 200; 200, binary_operator:*; 200, 201; 200, 208; 201, list:[match.group(3)]; 201, 202; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:match; 205, identifier:group; 206, argument_list; 206, 207; 207, integer:3; 208, integer:5; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 216; 211, attribute; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:self; 214, identifier:connection; 215, identifier:mode; 216, argument_list; 216, 217; 216, 218; 217, identifier:target; 218, identifier:modestring; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 222; 221, identifier:send; 222, argument_list; 222, 223; 222, 228; 223, binary_operator:%; 223, 224; 223, 225; 224, string:'Mode %s on %s by the guard system'; 225, tuple; 225, 226; 225, 227; 226, identifier:modestring; 227, identifier:target; 228, keyword_argument; 228, 229; 228, 230; 229, identifier:target; 230, subscript; 230, 231; 230, 236; 231, subscript; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:self; 234, identifier:config; 235, string:'core'; 236, string:'ctrlchan' | def do_mode(self, target, msg, nick, send):
mode_changes = irc.modes.parse_channel_modes(msg)
with self.data_lock:
for change in mode_changes:
if change[1] == 'v':
self.voiced[target][change[2]] = True if change[0] == '+' else False
if change[1] == 'o':
self.opers[target][change[2]] = True if change[0] == '+' else False
if [x for x in mode_changes if self.check_mode(x)]:
send("%s: :(" % nick, target=target)
if not self.is_admin(None, nick):
send("OP %s" % target, target='ChanServ')
send("UNBAN %s" % target, target='ChanServ')
if len(self.guarded) > 0:
regex = r"(.*(-v|-o|\+q|\+b)[^ ]*) (%s)" % "|".join(self.guarded)
match = re.search(regex, msg)
if match and nick not in [match.group(3), self.connection.real_nickname]:
modestring = "+voe-qb %s" % (" ".join([match.group(3)] * 5))
self.connection.mode(target, modestring)
send('Mode %s on %s by the guard system' % (modestring, target), target=self.config['core']['ctrlchan']) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:do_kick; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:self; 5, identifier:send; 6, identifier:target; 7, identifier:nick; 8, identifier:msg; 9, default_parameter; 9, 10; 9, 11; 10, identifier:slogan; 11, True; 12, block; 12, 13; 12, 20; 12, 35; 12, 62; 12, 72; 13, if_statement; 13, 14; 13, 18; 14, not_operator; 14, 15; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:kick_enabled; 18, block; 18, 19; 19, return_statement; 20, if_statement; 20, 21; 20, 26; 21, comparison_operator:not; 21, 22; 21, 23; 22, identifier:target; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:channels; 26, block; 26, 27; 26, 34; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:send; 30, argument_list; 30, 31; 31, binary_operator:%; 31, 32; 31, 33; 32, string:"%s: you're lucky, private message kicking hasn't been implemented yet."; 33, identifier:nick; 34, return_statement; 35, with_statement; 35, 36; 35, 41; 36, with_clause; 36, 37; 37, with_item; 37, 38; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:data_lock; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:ops; 45, list_comprehension; 45, 46; 45, 47; 45, 60; 46, identifier:k; 47, for_in_clause; 47, 48; 47, 51; 48, pattern_list; 48, 49; 48, 50; 49, identifier:k; 50, identifier:v; 51, call; 51, 52; 51, 59; 52, attribute; 52, 53; 52, 58; 53, subscript; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:opers; 57, identifier:target; 58, identifier:items; 59, argument_list; 60, if_clause; 60, 61; 61, identifier:v; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:botnick; 65, subscript; 65, 66; 65, 71; 66, subscript; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:config; 70, string:'core'; 71, string:'nick'; 72, if_statement; 72, 73; 72, 76; 72, 106; 72, 147; 73, comparison_operator:not; 73, 74; 73, 75; 74, identifier:botnick; 75, identifier:ops; 76, block; 76, 77; 76, 86; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:ops; 80, conditional_expression:if; 80, 81; 80, 83; 80, 85; 81, list:['someone']; 81, 82; 82, string:'someone'; 83, not_operator; 83, 84; 84, identifier:ops; 85, identifier:ops; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:send; 89, argument_list; 89, 90; 89, 103; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:textutils; 93, identifier:gen_creffett; 94, argument_list; 94, 95; 95, binary_operator:%; 95, 96; 95, 97; 96, string:"%s: /op the bot"; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:random; 100, identifier:choice; 101, argument_list; 101, 102; 102, identifier:ops; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:target; 105, identifier:target; 106, elif_clause; 106, 107; 106, 118; 107, boolean_operator:and; 107, 108; 107, 115; 108, comparison_operator:<; 108, 109; 108, 114; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:random; 112, identifier:random; 113, argument_list; 114, float:0.01; 115, comparison_operator:==; 115, 116; 115, 117; 116, identifier:msg; 117, string:"shutting caps lock off"; 118, block; 118, 119; 119, if_statement; 119, 120; 119, 123; 119, 134; 120, comparison_operator:in; 120, 121; 120, 122; 121, identifier:nick; 122, identifier:ops; 123, block; 123, 124; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 127; 126, identifier:send; 127, argument_list; 127, 128; 127, 131; 128, binary_operator:%; 128, 129; 128, 130; 129, string:"%s: HUEHUEHUE GIBE CAPSLOCK PLS I REPORT U"; 130, identifier:nick; 131, keyword_argument; 131, 132; 131, 133; 132, identifier:target; 133, identifier:target; 134, else_clause; 134, 135; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:connection; 142, identifier:kick; 143, argument_list; 143, 144; 143, 145; 143, 146; 144, identifier:target; 145, identifier:nick; 146, string:"HUEHUEHUE GIBE CAPSLOCK PLS I REPORT U"; 147, else_clause; 147, 148; 148, block; 148, 149; 148, 165; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:msg; 152, conditional_expression:if; 152, 153; 152, 163; 152, 164; 153, call; 153, 154; 153, 162; 154, attribute; 154, 155; 154, 161; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:textutils; 158, identifier:gen_slogan; 159, argument_list; 159, 160; 160, identifier:msg; 161, identifier:upper; 162, argument_list; 163, identifier:slogan; 164, identifier:msg; 165, if_statement; 165, 166; 165, 169; 165, 182; 166, comparison_operator:in; 166, 167; 166, 168; 167, identifier:nick; 168, identifier:ops; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:send; 173, argument_list; 173, 174; 173, 179; 174, binary_operator:%; 174, 175; 174, 176; 175, string:"%s: %s"; 176, tuple; 176, 177; 176, 178; 177, identifier:nick; 178, identifier:msg; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:target; 181, identifier:target; 182, else_clause; 182, 183; 183, block; 183, 184; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 191; 186, attribute; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:self; 189, identifier:connection; 190, identifier:kick; 191, argument_list; 191, 192; 191, 193; 191, 194; 192, identifier:target; 193, identifier:nick; 194, identifier:msg | def do_kick(self, send, target, nick, msg, slogan=True):
if not self.kick_enabled:
return
if target not in self.channels:
send("%s: you're lucky, private message kicking hasn't been implemented yet." % nick)
return
with self.data_lock:
ops = [k for k, v in self.opers[target].items() if v]
botnick = self.config['core']['nick']
if botnick not in ops:
ops = ['someone'] if not ops else ops
send(textutils.gen_creffett("%s: /op the bot" % random.choice(ops)), target=target)
elif random.random() < 0.01 and msg == "shutting caps lock off":
if nick in ops:
send("%s: HUEHUEHUE GIBE CAPSLOCK PLS I REPORT U" % nick, target=target)
else:
self.connection.kick(target, nick, "HUEHUEHUE GIBE CAPSLOCK PLS I REPORT U")
else:
msg = textutils.gen_slogan(msg).upper() if slogan else msg
if nick in ops:
send("%s: %s" % (nick, msg), target=target)
else:
self.connection.kick(target, nick, msg) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:handle_msg; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:c; 6, identifier:e; 7, block; 7, 8; 7, 36; 7, 64; 7, 77; 7, 106; 7, 137; 7, 148; 7, 160; 7, 178; 7, 196; 7, 227; 7, 245; 7, 276; 7, 294; 7, 305; 7, 313; 7, 329; 7, 340; 8, if_statement; 8, 9; 8, 19; 8, 28; 9, comparison_operator:not; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:e; 12, identifier:type; 13, list:['authenticate', 'error', 'join', 'part', 'quit']; 13, 14; 13, 15; 13, 16; 13, 17; 13, 18; 14, string:'authenticate'; 15, string:'error'; 16, string:'join'; 17, string:'part'; 18, string:'quit'; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:nick; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:e; 26, identifier:source; 27, identifier:nick; 28, else_clause; 28, 29; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:nick; 33, attribute; 33, 34; 33, 35; 34, identifier:e; 35, identifier:source; 36, if_statement; 36, 37; 36, 42; 36, 47; 37, comparison_operator:is; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:e; 40, identifier:arguments; 41, None; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:msg; 46, string:""; 47, else_clause; 47, 48; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:msg; 52, call; 52, 53; 52, 63; 53, attribute; 53, 54; 53, 62; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, string:" "; 57, identifier:join; 58, argument_list; 58, 59; 59, attribute; 59, 60; 59, 61; 60, identifier:e; 61, identifier:arguments; 62, identifier:strip; 63, argument_list; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:target; 67, conditional_expression:if; 67, 68; 67, 69; 67, 74; 68, identifier:nick; 69, comparison_operator:==; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:e; 72, identifier:type; 73, string:'privmsg'; 74, attribute; 74, 75; 74, 76; 75, identifier:e; 76, identifier:target; 77, function_definition; 77, 78; 77, 79; 77, 90; 78, function_name:send; 79, parameters; 79, 80; 79, 81; 79, 84; 79, 87; 80, identifier:msg; 81, default_parameter; 81, 82; 81, 83; 82, identifier:mtype; 83, string:'privmsg'; 84, default_parameter; 84, 85; 84, 86; 85, identifier:target; 86, identifier:target; 87, default_parameter; 87, 88; 87, 89; 88, identifier:ignore_length; 89, False; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:send; 96, argument_list; 96, 97; 96, 98; 96, 103; 96, 104; 96, 105; 97, identifier:target; 98, attribute; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:connection; 102, identifier:real_nickname; 103, identifier:msg; 104, identifier:mtype; 105, identifier:ignore_length; 106, if_statement; 106, 107; 106, 125; 107, comparison_operator:in; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:e; 110, identifier:type; 111, list:[
'account', 'authenticate', 'bannedfromchan', 'cap', 'ctcpreply', 'error', 'featurelist', 'nosuchnick', 'nick', 'nicknameinuse',
'privnotice', 'welcome', 'whospcrpl'
]; 111, 112; 111, 113; 111, 114; 111, 115; 111, 116; 111, 117; 111, 118; 111, 119; 111, 120; 111, 121; 111, 122; 111, 123; 111, 124; 112, string:'account'; 113, string:'authenticate'; 114, string:'bannedfromchan'; 115, string:'cap'; 116, string:'ctcpreply'; 117, string:'error'; 118, string:'featurelist'; 119, string:'nosuchnick'; 120, string:'nick'; 121, string:'nicknameinuse'; 122, string:'privnotice'; 123, string:'welcome'; 124, string:'whospcrpl'; 125, block; 125, 126; 125, 136; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:self; 130, identifier:handle_event; 131, argument_list; 131, 132; 131, 133; 131, 134; 131, 135; 132, identifier:msg; 133, identifier:send; 134, identifier:c; 135, identifier:e; 136, return_statement; 137, if_statement; 137, 138; 137, 146; 138, boolean_operator:and; 138, 139; 138, 141; 139, not_operator; 139, 140; 140, identifier:msg; 141, comparison_operator:!=; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:e; 144, identifier:type; 145, string:'join'; 146, block; 146, 147; 147, return_statement; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:do_log; 153, argument_list; 153, 154; 153, 155; 153, 156; 153, 157; 154, identifier:target; 155, identifier:nick; 156, identifier:msg; 157, attribute; 157, 158; 157, 159; 158, identifier:e; 159, identifier:type; 160, if_statement; 160, 161; 160, 166; 161, comparison_operator:==; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:e; 164, identifier:type; 165, string:'mode'; 166, block; 166, 167; 166, 177; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:self; 171, identifier:do_mode; 172, argument_list; 172, 173; 172, 174; 172, 175; 172, 176; 173, identifier:target; 174, identifier:msg; 175, identifier:nick; 176, identifier:send; 177, return_statement; 178, if_statement; 178, 179; 178, 184; 179, comparison_operator:==; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:e; 182, identifier:type; 183, string:'join'; 184, block; 184, 185; 184, 195; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:self; 189, identifier:handle_join; 190, argument_list; 190, 191; 190, 192; 190, 193; 190, 194; 191, identifier:c; 192, identifier:e; 193, identifier:target; 194, identifier:send; 195, return_statement; 196, if_statement; 196, 197; 196, 202; 197, comparison_operator:==; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:e; 200, identifier:type; 201, string:'part'; 202, block; 202, 203; 202, 226; 203, if_statement; 203, 204; 203, 209; 204, comparison_operator:==; 204, 205; 204, 206; 205, identifier:nick; 206, attribute; 206, 207; 206, 208; 207, identifier:c; 208, identifier:real_nickname; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 213; 212, identifier:send; 213, argument_list; 213, 214; 213, 217; 214, binary_operator:%; 214, 215; 214, 216; 215, string:"Parted channel %s"; 216, identifier:target; 217, keyword_argument; 217, 218; 217, 219; 218, identifier:target; 219, subscript; 219, 220; 219, 225; 220, subscript; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:self; 223, identifier:config; 224, string:'core'; 225, string:'ctrlchan'; 226, return_statement; 227, if_statement; 227, 228; 227, 233; 228, comparison_operator:==; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:e; 231, identifier:type; 232, string:'kick'; 233, block; 233, 234; 233, 244; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:self; 238, identifier:handle_kick; 239, argument_list; 239, 240; 239, 241; 239, 242; 239, 243; 240, identifier:c; 241, identifier:e; 242, identifier:target; 243, identifier:send; 244, return_statement; 245, if_statement; 245, 246; 245, 265; 246, boolean_operator:and; 246, 247; 246, 258; 247, comparison_operator:==; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:e; 250, identifier:target; 251, subscript; 251, 252; 251, 257; 252, subscript; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:self; 255, identifier:config; 256, string:'core'; 257, string:'ctrlchan'; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:self; 261, identifier:is_admin; 262, argument_list; 262, 263; 262, 264; 263, None; 264, identifier:nick; 265, block; 265, 266; 266, expression_statement; 266, 267; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:control; 270, identifier:handle_ctrlchan; 271, argument_list; 271, 272; 271, 273; 271, 274; 271, 275; 272, identifier:self; 273, identifier:msg; 274, identifier:nick; 275, identifier:send; 276, if_statement; 276, 277; 276, 292; 277, boolean_operator:and; 277, 278; 277, 284; 278, call; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:self; 281, identifier:is_ignored; 282, argument_list; 282, 283; 283, identifier:nick; 284, not_operator; 284, 285; 285, call; 285, 286; 285, 289; 286, attribute; 286, 287; 286, 288; 287, identifier:self; 288, identifier:is_admin; 289, argument_list; 289, 290; 289, 291; 290, None; 291, identifier:nick; 292, block; 292, 293; 293, return_statement; 294, expression_statement; 294, 295; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:self; 298, identifier:handle_hooks; 299, argument_list; 299, 300; 299, 301; 299, 302; 299, 303; 299, 304; 300, identifier:send; 301, identifier:nick; 302, identifier:target; 303, identifier:e; 304, identifier:msg; 305, if_statement; 305, 306; 305, 311; 306, comparison_operator:==; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:e; 309, identifier:type; 310, string:'pubnotice'; 311, block; 311, 312; 312, return_statement; 313, expression_statement; 313, 314; 314, assignment; 314, 315; 314, 316; 315, identifier:msg; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:misc; 319, identifier:get_cmdchar; 320, argument_list; 320, 321; 320, 324; 320, 325; 320, 326; 321, attribute; 321, 322; 321, 323; 322, identifier:self; 323, identifier:config; 324, identifier:c; 325, identifier:msg; 326, attribute; 326, 327; 326, 328; 327, identifier:e; 328, identifier:type; 329, expression_statement; 329, 330; 330, assignment; 330, 331; 330, 334; 331, pattern_list; 331, 332; 331, 333; 332, identifier:cmd_name; 333, identifier:cmdargs; 334, call; 334, 335; 334, 338; 335, attribute; 335, 336; 335, 337; 336, identifier:self; 337, identifier:get_cmd; 338, argument_list; 338, 339; 339, identifier:msg; 340, if_statement; 340, 341; 340, 349; 340, 362; 341, call; 341, 342; 341, 347; 342, attribute; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:registry; 345, identifier:command_registry; 346, identifier:is_registered; 347, argument_list; 347, 348; 348, identifier:cmd_name; 349, block; 349, 350; 350, expression_statement; 350, 351; 351, call; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:self; 354, identifier:run_cmd; 355, argument_list; 355, 356; 355, 357; 355, 358; 355, 359; 355, 360; 355, 361; 356, identifier:send; 357, identifier:nick; 358, identifier:target; 359, identifier:cmd_name; 360, identifier:cmdargs; 361, identifier:e; 362, elif_clause; 362, 363; 362, 366; 363, comparison_operator:==; 363, 364; 363, 365; 364, identifier:cmd_name; 365, string:'reload'; 366, block; 366, 367; 367, with_statement; 367, 368; 367, 380; 368, with_clause; 368, 369; 369, with_item; 369, 370; 370, as_pattern; 370, 371; 370, 378; 371, call; 371, 372; 371, 377; 372, attribute; 372, 373; 372, 376; 373, attribute; 373, 374; 373, 375; 374, identifier:self; 375, identifier:db; 376, identifier:session_scope; 377, argument_list; 378, as_pattern_target; 378, 379; 379, identifier:session; 380, block; 380, 381; 381, if_statement; 381, 382; 381, 405; 382, call; 382, 383; 382, 404; 383, attribute; 383, 384; 383, 403; 384, call; 384, 385; 384, 395; 385, attribute; 385, 386; 385, 394; 386, call; 386, 387; 386, 390; 387, attribute; 387, 388; 387, 389; 388, identifier:session; 389, identifier:query; 390, argument_list; 390, 391; 391, attribute; 391, 392; 391, 393; 392, identifier:orm; 393, identifier:Permissions; 394, identifier:filter; 395, argument_list; 395, 396; 396, comparison_operator:==; 396, 397; 396, 402; 397, attribute; 397, 398; 397, 401; 398, attribute; 398, 399; 398, 400; 399, identifier:orm; 400, identifier:Permissions; 401, identifier:nick; 402, identifier:nick; 403, identifier:count; 404, argument_list; 405, block; 405, 406; 406, expression_statement; 406, 407; 407, call; 407, 408; 407, 409; 408, identifier:send; 409, argument_list; 409, 410; 410, string:"Aye Aye Capt'n" | def handle_msg(self, c, e):
if e.type not in ['authenticate', 'error', 'join', 'part', 'quit']:
nick = e.source.nick
else:
nick = e.source
if e.arguments is None:
msg = ""
else:
msg = " ".join(e.arguments).strip()
target = nick if e.type == 'privmsg' else e.target
def send(msg, mtype='privmsg', target=target, ignore_length=False):
self.send(target, self.connection.real_nickname, msg, mtype, ignore_length)
if e.type in [
'account', 'authenticate', 'bannedfromchan', 'cap', 'ctcpreply', 'error', 'featurelist', 'nosuchnick', 'nick', 'nicknameinuse',
'privnotice', 'welcome', 'whospcrpl'
]:
self.handle_event(msg, send, c, e)
return
if not msg and e.type != 'join':
return
self.do_log(target, nick, msg, e.type)
if e.type == 'mode':
self.do_mode(target, msg, nick, send)
return
if e.type == 'join':
self.handle_join(c, e, target, send)
return
if e.type == 'part':
if nick == c.real_nickname:
send("Parted channel %s" % target, target=self.config['core']['ctrlchan'])
return
if e.type == 'kick':
self.handle_kick(c, e, target, send)
return
if e.target == self.config['core']['ctrlchan'] and self.is_admin(None, nick):
control.handle_ctrlchan(self, msg, nick, send)
if self.is_ignored(nick) and not self.is_admin(None, nick):
return
self.handle_hooks(send, nick, target, e, msg)
if e.type == 'pubnotice':
return
msg = misc.get_cmdchar(self.config, c, msg, e.type)
cmd_name, cmdargs = self.get_cmd(msg)
if registry.command_registry.is_registered(cmd_name):
self.run_cmd(send, nick, target, cmd_name, cmdargs, e)
elif cmd_name == 'reload':
with self.db.session_scope() as session:
if session.query(orm.Permissions).filter(orm.Permissions.nick == nick).count():
send("Aye Aye Capt'n") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:cmd; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:send; 5, identifier:msg; 6, identifier:args; 7, block; 7, 8; 7, 14; 7, 33; 7, 67; 7, 77; 7, 87; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:nick; 11, subscript; 11, 12; 11, 13; 12, identifier:args; 13, string:'nick'; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:channel; 17, conditional_expression:if; 17, 18; 17, 21; 17, 26; 18, subscript; 18, 19; 18, 20; 19, identifier:args; 20, string:'target'; 21, comparison_operator:!=; 21, 22; 21, 25; 22, subscript; 22, 23; 22, 24; 23, identifier:args; 24, string:'target'; 25, string:'private'; 26, subscript; 26, 27; 26, 32; 27, subscript; 27, 28; 27, 31; 28, subscript; 28, 29; 28, 30; 29, identifier:args; 30, string:'config'; 31, string:'core'; 32, string:'channel'; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:levels; 36, dictionary; 36, 37; 36, 40; 36, 43; 36, 46; 36, 49; 36, 52; 36, 55; 36, 58; 36, 61; 36, 64; 37, pair; 37, 38; 37, 39; 38, integer:1; 39, string:'Whirr...'; 40, pair; 40, 41; 40, 42; 41, integer:2; 42, string:'Vrrm...'; 43, pair; 43, 44; 43, 45; 44, integer:3; 45, string:'Zzzzhhhh...'; 46, pair; 46, 47; 46, 48; 47, integer:4; 48, string:'SHFRRRRM...'; 49, pair; 49, 50; 49, 51; 50, integer:5; 51, string:'GEEEEZZSH...'; 52, pair; 52, 53; 52, 54; 53, integer:6; 54, string:'PLAAAAIIID...'; 55, pair; 55, 56; 55, 57; 56, integer:7; 57, string:'KKKRRRAAKKKAAKRAKKGGARGHGIZZZZ...'; 58, pair; 58, 59; 58, 60; 59, integer:8; 60, string:'Nuke'; 61, pair; 61, 62; 61, 63; 62, integer:9; 63, string:'nneeeaaaooowwwwww..... BOOOOOSH BLAM KABOOM'; 64, pair; 64, 65; 64, 66; 65, integer:10; 66, string:'ssh root@remote.tjhsst.edu rm -rf ~%s'; 67, if_statement; 67, 68; 67, 70; 68, not_operator; 68, 69; 69, identifier:msg; 70, block; 70, 71; 70, 76; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:send; 74, argument_list; 74, 75; 75, string:'What to microwave?'; 76, return_statement; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:match; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:re; 83, identifier:match; 84, argument_list; 84, 85; 84, 86; 85, string:'(-?[0-9]*) (.*)'; 86, identifier:msg; 87, if_statement; 87, 88; 87, 90; 87, 96; 88, not_operator; 88, 89; 89, identifier:match; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:send; 94, argument_list; 94, 95; 95, string:'Power level?'; 96, else_clause; 96, 97; 97, block; 97, 98; 97, 110; 97, 119; 97, 130; 97, 141; 97, 205; 97, 211; 97, 234; 97, 239; 97, 256; 97, 268; 97, 282; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:level; 101, call; 101, 102; 101, 103; 102, identifier:int; 103, argument_list; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:match; 107, identifier:group; 108, argument_list; 108, 109; 109, integer:1; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:target; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:match; 116, identifier:group; 117, argument_list; 117, 118; 118, integer:2; 119, if_statement; 119, 120; 119, 123; 120, comparison_operator:>; 120, 121; 120, 122; 121, identifier:level; 122, integer:10; 123, block; 123, 124; 123, 129; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 127; 126, identifier:send; 127, argument_list; 127, 128; 128, string:'Aborting to prevent extinction of human race.'; 129, return_statement; 130, if_statement; 130, 131; 130, 134; 131, comparison_operator:<; 131, 132; 131, 133; 132, identifier:level; 133, integer:1; 134, block; 134, 135; 134, 140; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:send; 138, argument_list; 138, 139; 139, string:'Anti-matter not yet implemented.'; 140, return_statement; 141, if_statement; 141, 142; 141, 145; 142, comparison_operator:>; 142, 143; 142, 144; 143, identifier:level; 144, integer:7; 145, block; 145, 146; 146, if_statement; 146, 147; 146, 154; 146, 161; 146, 173; 147, not_operator; 147, 148; 148, call; 148, 149; 148, 152; 149, subscript; 149, 150; 149, 151; 150, identifier:args; 151, string:'is_admin'; 152, argument_list; 152, 153; 153, identifier:nick; 154, block; 154, 155; 154, 160; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 158; 157, identifier:send; 158, argument_list; 158, 159; 159, string:"I'm sorry. Nukes are a admin-only feature"; 160, return_statement; 161, elif_clause; 161, 162; 161, 167; 162, comparison_operator:==; 162, 163; 162, 164; 163, identifier:msg; 164, subscript; 164, 165; 164, 166; 165, identifier:args; 166, string:'botnick'; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:send; 171, argument_list; 171, 172; 172, string:"Sorry, Self-Nuking is disabled pending aquisition of a Lead-Lined Fridge."; 173, else_clause; 173, 174; 174, block; 174, 175; 175, with_statement; 175, 176; 175, 183; 176, with_clause; 176, 177; 177, with_item; 177, 178; 178, attribute; 178, 179; 178, 182; 179, subscript; 179, 180; 179, 181; 180, identifier:args; 181, string:'handler'; 182, identifier:data_lock; 183, block; 183, 184; 184, if_statement; 184, 185; 184, 198; 185, comparison_operator:not; 185, 186; 185, 187; 186, identifier:target; 187, call; 187, 188; 187, 197; 188, attribute; 188, 189; 188, 196; 189, subscript; 189, 190; 189, 195; 190, attribute; 190, 191; 190, 194; 191, subscript; 191, 192; 191, 193; 192, identifier:args; 193, string:'handler'; 194, identifier:channels; 195, identifier:channel; 196, identifier:users; 197, argument_list; 198, block; 198, 199; 198, 204; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 202; 201, identifier:send; 202, argument_list; 202, 203; 203, string:"I'm sorry. Anonymous Nuking is not allowed"; 204, return_statement; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:msg; 208, subscript; 208, 209; 208, 210; 209, identifier:levels; 210, integer:1; 211, for_statement; 211, 212; 211, 213; 211, 220; 212, identifier:i; 213, call; 213, 214; 213, 215; 214, identifier:range; 215, argument_list; 215, 216; 215, 217; 216, integer:2; 217, binary_operator:+; 217, 218; 217, 219; 218, identifier:level; 219, integer:1; 220, block; 220, 221; 221, if_statement; 221, 222; 221, 225; 222, comparison_operator:<; 222, 223; 222, 224; 223, identifier:i; 224, integer:8; 225, block; 225, 226; 226, expression_statement; 226, 227; 227, augmented_assignment:+=; 227, 228; 227, 229; 228, identifier:msg; 229, binary_operator:+; 229, 230; 229, 231; 230, string:' '; 231, subscript; 231, 232; 231, 233; 232, identifier:levels; 233, identifier:i; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 237; 236, identifier:send; 237, argument_list; 237, 238; 238, identifier:msg; 239, if_statement; 239, 240; 239, 243; 240, comparison_operator:>=; 240, 241; 240, 242; 241, identifier:level; 242, integer:8; 243, block; 243, 244; 244, expression_statement; 244, 245; 245, call; 245, 246; 245, 247; 246, identifier:do_nuke; 247, argument_list; 247, 248; 247, 253; 247, 254; 247, 255; 248, attribute; 248, 249; 248, 252; 249, subscript; 249, 250; 249, 251; 250, identifier:args; 251, string:'handler'; 252, identifier:connection; 253, identifier:nick; 254, identifier:target; 255, identifier:channel; 256, if_statement; 256, 257; 256, 260; 257, comparison_operator:>=; 257, 258; 257, 259; 258, identifier:level; 259, integer:9; 260, block; 260, 261; 261, expression_statement; 261, 262; 262, call; 262, 263; 262, 264; 263, identifier:send; 264, argument_list; 264, 265; 265, subscript; 265, 266; 265, 267; 266, identifier:levels; 267, integer:9; 268, if_statement; 268, 269; 268, 272; 269, comparison_operator:==; 269, 270; 269, 271; 270, identifier:level; 271, integer:10; 272, block; 272, 273; 273, expression_statement; 273, 274; 274, call; 274, 275; 274, 276; 275, identifier:send; 276, argument_list; 276, 277; 277, binary_operator:%; 277, 278; 277, 281; 278, subscript; 278, 279; 278, 280; 279, identifier:levels; 280, integer:10; 281, identifier:target; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 285; 284, identifier:send; 285, argument_list; 285, 286; 286, binary_operator:%; 286, 287; 286, 288; 287, string:'Ding, your %s is ready.'; 288, identifier:target | def cmd(send, msg, args):
nick = args['nick']
channel = args['target'] if args['target'] != 'private' else args['config']['core']['channel']
levels = {
1: 'Whirr...',
2: 'Vrrm...',
3: 'Zzzzhhhh...',
4: 'SHFRRRRM...',
5: 'GEEEEZZSH...',
6: 'PLAAAAIIID...',
7: 'KKKRRRAAKKKAAKRAKKGGARGHGIZZZZ...',
8: 'Nuke',
9: 'nneeeaaaooowwwwww..... BOOOOOSH BLAM KABOOM',
10: 'ssh root@remote.tjhsst.edu rm -rf ~%s'
}
if not msg:
send('What to microwave?')
return
match = re.match('(-?[0-9]*) (.*)', msg)
if not match:
send('Power level?')
else:
level = int(match.group(1))
target = match.group(2)
if level > 10:
send('Aborting to prevent extinction of human race.')
return
if level < 1:
send('Anti-matter not yet implemented.')
return
if level > 7:
if not args['is_admin'](nick):
send("I'm sorry. Nukes are a admin-only feature")
return
elif msg == args['botnick']:
send("Sorry, Self-Nuking is disabled pending aquisition of a Lead-Lined Fridge.")
else:
with args['handler'].data_lock:
if target not in args['handler'].channels[channel].users():
send("I'm sorry. Anonymous Nuking is not allowed")
return
msg = levels[1]
for i in range(2, level + 1):
if i < 8:
msg += ' ' + levels[i]
send(msg)
if level >= 8:
do_nuke(args['handler'].connection, nick, target, channel)
if level >= 9:
send(levels[9])
if level == 10:
send(levels[10] % target)
send('Ding, your %s is ready.' % target) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:cmdloop; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:intro; 7, None; 8, block; 8, 9; 8, 11; 8, 17; 8, 65; 9, expression_statement; 9, 10; 10, string:''' Override the command loop to handle Ctrl-C. '''; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:preloop; 16, argument_list; 17, if_statement; 17, 18; 17, 25; 18, boolean_operator:and; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:use_rawinput; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:completekey; 25, block; 25, 26; 26, try_statement; 26, 27; 26, 61; 27, block; 27, 28; 27, 31; 27, 41; 27, 50; 28, import_statement; 28, 29; 29, dotted_name; 29, 30; 30, identifier:readline; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:old_completer; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:readline; 39, identifier:get_completer; 40, argument_list; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:readline; 45, identifier:set_completer; 46, argument_list; 46, 47; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:complete; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:readline; 54, identifier:parse_and_bind; 55, argument_list; 55, 56; 56, binary_operator:+; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:completekey; 60, string:': complete'; 61, except_clause; 61, 62; 61, 63; 62, identifier:ImportError; 63, block; 63, 64; 64, pass_statement; 65, try_statement; 65, 66; 65, 262; 66, block; 66, 67; 66, 78; 66, 99; 66, 103; 66, 256; 67, if_statement; 67, 68; 67, 71; 68, comparison_operator:is; 68, 69; 68, 70; 69, identifier:intro; 70, None; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:intro; 77, identifier:intro; 78, if_statement; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:intro; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:stdout; 89, identifier:write; 90, argument_list; 90, 91; 91, binary_operator:+; 91, 92; 91, 98; 92, call; 92, 93; 92, 94; 93, identifier:str; 94, argument_list; 94, 95; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:intro; 98, string:"\n"; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:stop; 102, None; 103, while_statement; 103, 104; 103, 106; 104, not_operator; 104, 105; 105, identifier:stop; 106, block; 106, 107; 106, 228; 106, 237; 106, 246; 107, if_statement; 107, 108; 107, 111; 107, 123; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:cmdqueue; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:line; 115, call; 115, 116; 115, 121; 116, attribute; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:cmdqueue; 120, identifier:pop; 121, argument_list; 121, 122; 122, integer:0; 123, else_clause; 123, 124; 124, block; 124, 125; 125, if_statement; 125, 126; 125, 129; 125, 175; 126, attribute; 126, 127; 126, 128; 127, identifier:self; 128, identifier:use_rawinput; 129, block; 129, 130; 130, try_statement; 130, 131; 130, 161; 130, 168; 131, block; 131, 132; 132, if_statement; 132, 133; 132, 140; 132, 150; 133, comparison_operator:==; 133, 134; 133, 139; 134, subscript; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:sys; 137, identifier:version_info; 138, integer:0; 139, integer:2; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:line; 144, call; 144, 145; 144, 146; 145, identifier:raw_input; 146, argument_list; 146, 147; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:prompt; 150, else_clause; 150, 151; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:line; 155, call; 155, 156; 155, 157; 156, identifier:input; 157, argument_list; 157, 158; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:prompt; 161, except_clause; 161, 162; 161, 163; 162, identifier:EOFError; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:line; 167, string:'EOF'; 168, except_clause; 168, 169; 168, 170; 169, identifier:KeyboardInterrupt; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:line; 174, string:'ctrlc'; 175, else_clause; 175, 176; 176, block; 176, 177; 176, 188; 176, 196; 176, 206; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 184; 179, attribute; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:self; 182, identifier:stdout; 183, identifier:write; 184, argument_list; 184, 185; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:prompt; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 195; 190, attribute; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:self; 193, identifier:stdout; 194, identifier:flush; 195, argument_list; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:line; 199, call; 199, 200; 199, 205; 200, attribute; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:self; 203, identifier:stdin; 204, identifier:readline; 205, argument_list; 206, if_statement; 206, 207; 206, 212; 206, 217; 207, not_operator; 207, 208; 208, call; 208, 209; 208, 210; 209, identifier:len; 210, argument_list; 210, 211; 211, identifier:line; 212, block; 212, 213; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:line; 216, string:'EOF'; 217, else_clause; 217, 218; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:line; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:line; 225, identifier:rstrip; 226, argument_list; 226, 227; 227, string:'\r\n'; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:line; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:self; 234, identifier:precmd; 235, argument_list; 235, 236; 236, identifier:line; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:stop; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:self; 243, identifier:onecmd; 244, argument_list; 244, 245; 245, identifier:line; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:stop; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:self; 252, identifier:postcmd; 253, argument_list; 253, 254; 253, 255; 254, identifier:stop; 255, identifier:line; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:self; 260, identifier:postloop; 261, argument_list; 262, finally_clause; 262, 263; 263, block; 263, 264; 264, if_statement; 264, 265; 264, 272; 265, boolean_operator:and; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:self; 268, identifier:use_rawinput; 269, attribute; 269, 270; 269, 271; 270, identifier:self; 271, identifier:completekey; 272, block; 272, 273; 273, try_statement; 273, 274; 273, 287; 274, block; 274, 275; 274, 278; 275, import_statement; 275, 276; 276, dotted_name; 276, 277; 277, identifier:readline; 278, expression_statement; 278, 279; 279, call; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:readline; 282, identifier:set_completer; 283, argument_list; 283, 284; 284, attribute; 284, 285; 284, 286; 285, identifier:self; 286, identifier:old_completer; 287, except_clause; 287, 288; 287, 289; 288, identifier:ImportError; 289, block; 289, 290; 290, pass_statement | def cmdloop(self, intro=None):
''' Override the command loop to handle Ctrl-C. '''
self.preloop()
if self.use_rawinput and self.completekey:
try:
import readline
self.old_completer = readline.get_completer()
readline.set_completer(self.complete)
readline.parse_and_bind(self.completekey + ': complete')
except ImportError:
pass
try:
if intro is not None:
self.intro = intro
if self.intro:
self.stdout.write(str(self.intro)+"\n")
stop = None
while not stop:
if self.cmdqueue:
line = self.cmdqueue.pop(0)
else:
if self.use_rawinput:
try:
if sys.version_info[0] == 2:
line = raw_input(self.prompt)
else:
line = input(self.prompt)
except EOFError:
line = 'EOF'
except KeyboardInterrupt:
line = 'ctrlc'
else:
self.stdout.write(self.prompt)
self.stdout.flush()
line = self.stdin.readline()
if not len(line):
line = 'EOF'
else:
line = line.rstrip('\r\n')
line = self.precmd(line)
stop = self.onecmd(line)
stop = self.postcmd(stop, line)
self.postloop()
finally:
if self.use_rawinput and self.completekey:
try:
import readline
readline.set_completer(self.old_completer)
except ImportError:
pass |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:free; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:local_path; 6, block; 6, 7; 6, 9; 6, 17; 6, 27; 6, 35; 6, 45; 6, 52; 6, 61; 6, 72; 6, 83; 6, 93; 6, 131; 6, 140; 6, 288; 7, expression_statement; 7, 8; 8, string:'''
Stop synchronization of local_path
'''; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:config; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:get_config; 16, argument_list; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:folder; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:st_util; 23, identifier:find_folder_with_path; 24, argument_list; 24, 25; 24, 26; 25, identifier:local_path; 26, identifier:config; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:delete_folder; 32, argument_list; 32, 33; 32, 34; 33, identifier:local_path; 34, identifier:config; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:pruned; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:st_util; 41, identifier:prune_devices; 42, argument_list; 42, 43; 42, 44; 43, identifier:folder; 44, identifier:config; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:set_config; 50, argument_list; 50, 51; 51, identifier:config; 52, if_statement; 52, 53; 52, 54; 53, identifier:pruned; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:restart; 60, argument_list; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:dir_config; 64, call; 64, 65; 64, 70; 65, attribute; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:adapter; 69, identifier:get_dir_config; 70, argument_list; 70, 71; 71, identifier:local_path; 72, if_statement; 72, 73; 72, 75; 73, not_operator; 73, 74; 74, identifier:dir_config; 75, block; 75, 76; 76, raise_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:custom_errors; 80, identifier:FileNotInConfig; 81, argument_list; 81, 82; 82, identifier:local_path; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:kodrive_config; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:adapter; 91, identifier:get_config; 92, argument_list; 93, for_statement; 93, 94; 93, 95; 93, 98; 94, identifier:key; 95, subscript; 95, 96; 95, 97; 96, identifier:kodrive_config; 97, string:'directories'; 98, block; 98, 99; 98, 107; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:d; 102, subscript; 102, 103; 102, 106; 103, subscript; 103, 104; 103, 105; 104, identifier:kodrive_config; 105, string:'directories'; 106, identifier:key; 107, if_statement; 107, 108; 107, 123; 108, comparison_operator:==; 108, 109; 108, 117; 109, call; 109, 110; 109, 115; 110, attribute; 110, 111; 110, 114; 111, subscript; 111, 112; 111, 113; 112, identifier:d; 113, string:'local_path'; 114, identifier:rstrip; 115, argument_list; 115, 116; 116, string:'/'; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:local_path; 120, identifier:rstrip; 121, argument_list; 121, 122; 122, string:'/'; 123, block; 123, 124; 123, 130; 124, delete_statement; 124, 125; 125, subscript; 125, 126; 125, 129; 126, subscript; 126, 127; 126, 128; 127, identifier:kodrive_config; 128, string:'directories'; 129, identifier:key; 130, break_statement; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 138; 133, attribute; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:self; 136, identifier:adapter; 137, identifier:set_config; 138, argument_list; 138, 139; 139, identifier:kodrive_config; 140, if_statement; 140, 141; 140, 148; 141, boolean_operator:and; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:dir_config; 144, string:'is_shared'; 145, subscript; 145, 146; 145, 147; 146, identifier:dir_config; 147, string:'server'; 148, block; 148, 149; 148, 155; 148, 161; 148, 184; 148, 213; 148, 221; 148, 233; 148, 241; 148, 249; 148, 262; 148, 272; 148, 279; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:r_api_key; 152, subscript; 152, 153; 152, 154; 153, identifier:dir_config; 154, string:'api_key'; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:r_device_id; 158, subscript; 158, 159; 158, 160; 159, identifier:dir_config; 160, string:'device_id'; 161, if_statement; 161, 162; 161, 165; 161, 172; 162, subscript; 162, 163; 162, 164; 163, identifier:dir_config; 164, string:'host'; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:host; 169, subscript; 169, 170; 169, 171; 170, identifier:dir_config; 171, string:'host'; 172, else_clause; 172, 173; 173, block; 173, 174; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:host; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:self; 180, identifier:devid_to_ip; 181, argument_list; 181, 182; 181, 183; 182, identifier:r_device_id; 183, False; 184, try_statement; 184, 185; 184, 205; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:remote; 189, call; 189, 190; 189, 191; 190, identifier:SyncthingProxy; 191, argument_list; 191, 192; 191, 193; 191, 194; 191, 195; 192, identifier:r_device_id; 193, identifier:host; 194, identifier:r_api_key; 195, keyword_argument; 195, 196; 195, 197; 196, identifier:port; 197, conditional_expression:if; 197, 198; 197, 201; 197, 204; 198, subscript; 198, 199; 198, 200; 199, identifier:dir_config; 200, string:'port'; 201, comparison_operator:in; 201, 202; 201, 203; 202, string:'port'; 203, identifier:dir_config; 204, None; 205, except_clause; 205, 206; 205, 210; 206, as_pattern; 206, 207; 206, 208; 207, identifier:Exception; 208, as_pattern_target; 208, 209; 209, identifier:e; 210, block; 210, 211; 211, return_statement; 211, 212; 212, True; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:r_config; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:remote; 219, identifier:get_config; 220, argument_list; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:r_folder; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:st_util; 227, identifier:find_folder_with_path; 228, argument_list; 228, 229; 228, 232; 229, subscript; 229, 230; 229, 231; 230, identifier:dir_config; 231, string:'remote_path'; 232, identifier:r_config; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:r_config; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:remote; 239, identifier:get_config; 240, argument_list; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:self_devid; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:self; 247, identifier:get_device_id; 248, argument_list; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:del_device; 252, call; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:remote; 255, identifier:delete_device_from_folder; 256, argument_list; 256, 257; 256, 260; 256, 261; 257, subscript; 257, 258; 257, 259; 258, identifier:dir_config; 259, string:'remote_path'; 260, identifier:self_devid; 261, identifier:r_config; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:pruned; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:st_util; 268, identifier:prune_devices; 269, argument_list; 269, 270; 269, 271; 270, identifier:r_folder; 271, identifier:r_config; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:remote; 276, identifier:set_config; 277, argument_list; 277, 278; 278, identifier:r_config; 279, if_statement; 279, 280; 279, 281; 280, identifier:pruned; 281, block; 281, 282; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:remote; 286, identifier:restart; 287, argument_list; 288, return_statement; 288, 289; 289, True | def free(self, local_path):
'''
Stop synchronization of local_path
'''
config = self.get_config()
folder = st_util.find_folder_with_path(local_path, config)
self.delete_folder(local_path, config)
pruned = st_util.prune_devices(folder, config)
self.set_config(config)
if pruned:
self.restart()
dir_config = self.adapter.get_dir_config(local_path)
if not dir_config:
raise custom_errors.FileNotInConfig(local_path)
kodrive_config = self.adapter.get_config()
for key in kodrive_config['directories']:
d = kodrive_config['directories'][key]
if d['local_path'].rstrip('/') == local_path.rstrip('/'):
del kodrive_config['directories'][key]
break
self.adapter.set_config(kodrive_config)
if dir_config['is_shared'] and dir_config['server']:
r_api_key = dir_config['api_key']
r_device_id = dir_config['device_id']
if dir_config['host']:
host = dir_config['host']
else:
host = self.devid_to_ip(r_device_id, False)
try:
remote = SyncthingProxy(
r_device_id, host, r_api_key,
port=dir_config['port'] if 'port' in dir_config else None
)
except Exception as e:
return True
r_config = remote.get_config()
r_folder = st_util.find_folder_with_path(
dir_config['remote_path'], r_config
)
r_config = remote.get_config()
self_devid = self.get_device_id()
del_device = remote.delete_device_from_folder(
dir_config['remote_path'], self_devid, r_config
)
pruned = st_util.prune_devices(r_folder, r_config)
remote.set_config(r_config)
if pruned:
remote.restart()
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_package_update_list; 3, parameters; 3, 4; 3, 5; 4, identifier:package_name; 5, identifier:version; 6, block; 6, 7; 6, 18; 6, 25; 6, 33; 6, 37; 6, 41; 6, 45; 6, 49; 6, 53; 6, 57; 6, 61; 6, 65; 6, 69; 6, 284; 6, 310; 6, 321; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:package_version; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:semantic_version; 14, identifier:Version; 15, identifier:coerce; 16, argument_list; 16, 17; 17, identifier:version; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:package_data; 21, call; 21, 22; 21, 23; 22, identifier:get_pypi_package_data; 23, argument_list; 23, 24; 24, identifier:package_name; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:version_data; 28, call; 28, 29; 28, 30; 29, identifier:get_pypi_package_data; 30, argument_list; 30, 31; 30, 32; 31, identifier:package_name; 32, identifier:version; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:current_release; 36, string:''; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:current_release_license; 40, string:''; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:latest_release; 44, string:''; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:latest_release_license; 48, string:''; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:major_updates; 52, list:[]; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:minor_updates; 56, list:[]; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:patch_updates; 60, list:[]; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:pre_releases; 64, list:[]; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:non_semantic_versions; 68, list:[]; 69, if_statement; 69, 70; 69, 71; 70, identifier:package_data; 71, block; 71, 72; 71, 80; 71, 95; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:latest_release; 75, subscript; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:package_data; 78, string:'info'; 79, string:'version'; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:latest_release_license; 83, conditional_expression:if; 83, 84; 83, 89; 83, 94; 84, subscript; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:package_data; 87, string:'info'; 88, string:'license'; 89, subscript; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:package_data; 92, string:'info'; 93, string:'license'; 94, string:''; 95, for_statement; 95, 96; 95, 99; 95, 106; 96, pattern_list; 96, 97; 96, 98; 97, identifier:release; 98, identifier:info; 99, call; 99, 100; 99, 105; 100, attribute; 100, 101; 100, 104; 101, subscript; 101, 102; 101, 103; 102, identifier:package_data; 103, string:'releases'; 104, identifier:items; 105, argument_list; 106, block; 106, 107; 106, 114; 106, 118; 106, 135; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:parsed_release; 110, call; 110, 111; 110, 112; 111, identifier:parse; 112, argument_list; 112, 113; 113, identifier:release; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:upload_time; 117, None; 118, if_statement; 118, 119; 118, 120; 119, identifier:info; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:upload_time; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:datetime; 127, identifier:strptime; 128, argument_list; 128, 129; 128, 134; 129, subscript; 129, 130; 129, 133; 130, subscript; 130, 131; 130, 132; 131, identifier:info; 132, integer:0; 133, string:'upload_time'; 134, string:"%Y-%m-%dT%H:%M:%S"; 135, try_statement; 135, 136; 135, 268; 136, block; 136, 137; 136, 148; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:release_version; 140, call; 140, 141; 140, 146; 141, attribute; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:semantic_version; 144, identifier:Version; 145, identifier:coerce; 146, argument_list; 146, 147; 147, identifier:release; 148, if_statement; 148, 149; 148, 153; 148, 253; 149, not_operator; 149, 150; 150, attribute; 150, 151; 150, 152; 151, identifier:parsed_release; 152, identifier:is_prerelease; 153, block; 153, 154; 154, if_statement; 154, 155; 154, 169; 154, 183; 154, 218; 155, comparison_operator:in; 155, 156; 155, 157; 156, identifier:release_version; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:semantic_version; 160, identifier:Spec; 161, argument_list; 161, 162; 162, binary_operator:%; 162, 163; 162, 164; 163, string:">=%s"; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:package_version; 167, identifier:next_major; 168, argument_list; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:major_updates; 174, identifier:append; 175, argument_list; 175, 176; 176, dictionary; 176, 177; 176, 180; 177, pair; 177, 178; 177, 179; 178, string:'version'; 179, identifier:release; 180, pair; 180, 181; 180, 182; 181, string:'upload_time'; 182, identifier:upload_time; 183, elif_clause; 183, 184; 183, 204; 184, comparison_operator:in; 184, 185; 184, 186; 185, identifier:release_version; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:semantic_version; 189, identifier:Spec; 190, argument_list; 190, 191; 191, binary_operator:%; 191, 192; 191, 193; 192, string:">=%s,<%s"; 193, tuple; 193, 194; 193, 199; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:package_version; 197, identifier:next_minor; 198, argument_list; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:package_version; 202, identifier:next_major; 203, argument_list; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:minor_updates; 209, identifier:append; 210, argument_list; 210, 211; 211, dictionary; 211, 212; 211, 215; 212, pair; 212, 213; 212, 214; 213, string:'version'; 214, identifier:release; 215, pair; 215, 216; 215, 217; 216, string:'upload_time'; 217, identifier:upload_time; 218, elif_clause; 218, 219; 218, 239; 219, comparison_operator:in; 219, 220; 219, 221; 220, identifier:release_version; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:semantic_version; 224, identifier:Spec; 225, argument_list; 225, 226; 226, binary_operator:%; 226, 227; 226, 228; 227, string:">=%s,<%s"; 228, tuple; 228, 229; 228, 234; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:package_version; 232, identifier:next_patch; 233, argument_list; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:package_version; 237, identifier:next_minor; 238, argument_list; 239, block; 239, 240; 240, expression_statement; 240, 241; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:patch_updates; 244, identifier:append; 245, argument_list; 245, 246; 246, dictionary; 246, 247; 246, 250; 247, pair; 247, 248; 247, 249; 248, string:'version'; 249, identifier:release; 250, pair; 250, 251; 250, 252; 251, string:'upload_time'; 252, identifier:upload_time; 253, else_clause; 253, 254; 254, block; 254, 255; 255, expression_statement; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:pre_releases; 259, identifier:append; 260, argument_list; 260, 261; 261, dictionary; 261, 262; 261, 265; 262, pair; 262, 263; 262, 264; 263, string:'version'; 264, identifier:release; 265, pair; 265, 266; 265, 267; 266, string:'upload_time'; 267, identifier:upload_time; 268, except_clause; 268, 269; 268, 270; 269, identifier:ValueError; 270, block; 270, 271; 271, expression_statement; 271, 272; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:non_semantic_versions; 275, identifier:append; 276, argument_list; 276, 277; 277, dictionary; 277, 278; 277, 281; 278, pair; 278, 279; 278, 280; 279, string:'version'; 280, identifier:release; 281, pair; 281, 282; 281, 283; 282, string:'upload_time'; 283, identifier:upload_time; 284, if_statement; 284, 285; 284, 286; 285, identifier:version_data; 286, block; 286, 287; 286, 295; 287, expression_statement; 287, 288; 288, assignment; 288, 289; 288, 290; 289, identifier:current_release; 290, subscript; 290, 291; 290, 294; 291, subscript; 291, 292; 291, 293; 292, identifier:version_data; 293, string:'info'; 294, string:'version'; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:current_release_license; 298, conditional_expression:if; 298, 299; 298, 304; 298, 309; 299, subscript; 299, 300; 299, 303; 300, subscript; 300, 301; 300, 302; 301, identifier:version_data; 302, string:'info'; 303, string:'license'; 304, subscript; 304, 305; 304, 308; 305, subscript; 305, 306; 305, 307; 306, identifier:version_data; 307, string:'info'; 308, string:'license'; 309, string:''; 310, expression_statement; 310, 311; 311, assignment; 311, 312; 311, 313; 312, identifier:newer_releases; 313, call; 313, 314; 313, 315; 314, identifier:len; 315, argument_list; 315, 316; 316, binary_operator:+; 316, 317; 316, 320; 317, binary_operator:+; 317, 318; 317, 319; 318, identifier:major_updates; 319, identifier:minor_updates; 320, identifier:patch_updates; 321, return_statement; 321, 322; 322, dictionary; 322, 323; 322, 326; 322, 329; 322, 332; 322, 335; 322, 338; 322, 344; 322, 368; 322, 392; 322, 416; 322, 440; 323, pair; 323, 324; 323, 325; 324, string:'current_release'; 325, identifier:current_release; 326, pair; 326, 327; 326, 328; 327, string:'current_release_license'; 328, identifier:current_release_license; 329, pair; 329, 330; 329, 331; 330, string:'latest_release'; 331, identifier:latest_release; 332, pair; 332, 333; 332, 334; 333, string:'latest_release_license'; 334, identifier:latest_release_license; 335, pair; 335, 336; 335, 337; 336, string:'newer_releases'; 337, identifier:newer_releases; 338, pair; 338, 339; 338, 340; 339, string:'pre_releases'; 340, call; 340, 341; 340, 342; 341, identifier:len; 342, argument_list; 342, 343; 343, identifier:pre_releases; 344, pair; 344, 345; 344, 346; 345, string:'major_updates'; 346, call; 346, 347; 346, 348; 347, identifier:sorted; 348, argument_list; 348, 349; 348, 350; 348, 365; 349, identifier:major_updates; 350, keyword_argument; 350, 351; 350, 352; 351, identifier:key; 352, lambda; 352, 353; 352, 355; 353, lambda_parameters; 353, 354; 354, identifier:x; 355, call; 355, 356; 355, 361; 356, attribute; 356, 357; 356, 360; 357, attribute; 357, 358; 357, 359; 358, identifier:semantic_version; 359, identifier:Version; 360, identifier:coerce; 361, argument_list; 361, 362; 362, subscript; 362, 363; 362, 364; 363, identifier:x; 364, string:'version'; 365, keyword_argument; 365, 366; 365, 367; 366, identifier:reverse; 367, True; 368, pair; 368, 369; 368, 370; 369, string:'minor_updates'; 370, call; 370, 371; 370, 372; 371, identifier:sorted; 372, argument_list; 372, 373; 372, 374; 372, 389; 373, identifier:minor_updates; 374, keyword_argument; 374, 375; 374, 376; 375, identifier:key; 376, lambda; 376, 377; 376, 379; 377, lambda_parameters; 377, 378; 378, identifier:x; 379, call; 379, 380; 379, 385; 380, attribute; 380, 381; 380, 384; 381, attribute; 381, 382; 381, 383; 382, identifier:semantic_version; 383, identifier:Version; 384, identifier:coerce; 385, argument_list; 385, 386; 386, subscript; 386, 387; 386, 388; 387, identifier:x; 388, string:'version'; 389, keyword_argument; 389, 390; 389, 391; 390, identifier:reverse; 391, True; 392, pair; 392, 393; 392, 394; 393, string:'patch_updates'; 394, call; 394, 395; 394, 396; 395, identifier:sorted; 396, argument_list; 396, 397; 396, 398; 396, 413; 397, identifier:patch_updates; 398, keyword_argument; 398, 399; 398, 400; 399, identifier:key; 400, lambda; 400, 401; 400, 403; 401, lambda_parameters; 401, 402; 402, identifier:x; 403, call; 403, 404; 403, 409; 404, attribute; 404, 405; 404, 408; 405, attribute; 405, 406; 405, 407; 406, identifier:semantic_version; 407, identifier:Version; 408, identifier:coerce; 409, argument_list; 409, 410; 410, subscript; 410, 411; 410, 412; 411, identifier:x; 412, string:'version'; 413, keyword_argument; 413, 414; 413, 415; 414, identifier:reverse; 415, True; 416, pair; 416, 417; 416, 418; 417, string:'pre_release_updates'; 418, call; 418, 419; 418, 420; 419, identifier:sorted; 420, argument_list; 420, 421; 420, 422; 420, 437; 421, identifier:pre_releases; 422, keyword_argument; 422, 423; 422, 424; 423, identifier:key; 424, lambda; 424, 425; 424, 427; 425, lambda_parameters; 425, 426; 426, identifier:x; 427, call; 427, 428; 427, 433; 428, attribute; 428, 429; 428, 432; 429, attribute; 429, 430; 429, 431; 430, identifier:semantic_version; 431, identifier:Version; 432, identifier:coerce; 433, argument_list; 433, 434; 434, subscript; 434, 435; 434, 436; 435, identifier:x; 436, string:'version'; 437, keyword_argument; 437, 438; 437, 439; 438, identifier:reverse; 439, True; 440, pair; 440, 441; 440, 442; 441, string:'non_semantic_versions'; 442, identifier:non_semantic_versions | def get_package_update_list(package_name, version):
package_version = semantic_version.Version.coerce(version)
package_data = get_pypi_package_data(package_name)
version_data = get_pypi_package_data(package_name, version)
current_release = ''
current_release_license = ''
latest_release = ''
latest_release_license = ''
major_updates = []
minor_updates = []
patch_updates = []
pre_releases = []
non_semantic_versions = []
if package_data:
latest_release = package_data['info']['version']
latest_release_license = package_data['info']['license'] if package_data['info']['license'] else ''
for release, info in package_data['releases'].items():
parsed_release = parse(release)
upload_time = None
if info:
upload_time = datetime.strptime(info[0]['upload_time'], "%Y-%m-%dT%H:%M:%S")
try:
release_version = semantic_version.Version.coerce(release)
if not parsed_release.is_prerelease:
if release_version in semantic_version.Spec(">=%s" % package_version.next_major()):
major_updates.append({
'version': release,
'upload_time': upload_time,
})
elif release_version in semantic_version.Spec(">=%s,<%s" % (package_version.next_minor(), package_version.next_major())):
minor_updates.append({
'version': release,
'upload_time': upload_time,
})
elif release_version in semantic_version.Spec(">=%s,<%s" % (package_version.next_patch(), package_version.next_minor())):
patch_updates.append({
'version': release,
'upload_time': upload_time,
})
else:
pre_releases.append({
'version': release,
'upload_time': upload_time
})
except ValueError:
non_semantic_versions.append({'version': release, 'upload_time': upload_time})
if version_data:
current_release = version_data['info']['version']
current_release_license = version_data['info']['license'] if version_data['info']['license'] else ''
newer_releases = len(major_updates + minor_updates + patch_updates)
return {
'current_release': current_release,
'current_release_license': current_release_license,
'latest_release': latest_release,
'latest_release_license': latest_release_license,
'newer_releases': newer_releases,
'pre_releases': len(pre_releases),
'major_updates': sorted(major_updates, key=lambda x: semantic_version.Version.coerce(x['version']), reverse=True),
'minor_updates': sorted(minor_updates, key=lambda x: semantic_version.Version.coerce(x['version']), reverse=True),
'patch_updates': sorted(patch_updates, key=lambda x: semantic_version.Version.coerce(x['version']), reverse=True),
'pre_release_updates': sorted(pre_releases, key=lambda x: semantic_version.Version.coerce(x['version']), reverse=True),
'non_semantic_versions': non_semantic_versions,
} |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:page_location_template; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 16; 5, 26; 5, 38; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:cycle; 9, attribute; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:election_day; 14, identifier:cycle; 15, identifier:name; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:model_class; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:model_type; 24, identifier:model_class; 25, argument_list; 26, if_statement; 26, 27; 26, 30; 27, comparison_operator:==; 27, 28; 27, 29; 28, identifier:model_class; 29, identifier:ElectionDay; 30, block; 30, 31; 31, return_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, string:"/{}/"; 35, identifier:format; 36, argument_list; 36, 37; 37, identifier:cycle; 38, if_statement; 38, 39; 38, 42; 38, 84; 38, 182; 38, 194; 39, comparison_operator:==; 39, 40; 39, 41; 40, identifier:model_class; 41, identifier:Office; 42, block; 42, 43; 43, if_statement; 43, 44; 43, 47; 43, 75; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:jurisdiction; 47, block; 47, 48; 48, if_statement; 48, 49; 48, 58; 48, 66; 49, comparison_operator:==; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:division_level; 54, identifier:name; 55, attribute; 55, 56; 55, 57; 56, identifier:DivisionLevel; 57, identifier:STATE; 58, block; 58, 59; 59, return_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, string:"/{}/president/{{state}}"; 63, identifier:format; 64, argument_list; 64, 65; 65, identifier:cycle; 66, else_clause; 66, 67; 67, block; 67, 68; 68, return_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, string:"/{}/president/"; 72, identifier:format; 73, argument_list; 73, 74; 74, identifier:cycle; 75, else_clause; 75, 76; 76, block; 76, 77; 77, return_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, string:"/{}/{{state}}/governor/"; 81, identifier:format; 82, argument_list; 82, 83; 83, identifier:cycle; 84, elif_clause; 84, 85; 84, 88; 85, comparison_operator:==; 85, 86; 85, 87; 86, identifier:model_class; 87, identifier:Body; 88, block; 88, 89; 89, if_statement; 89, 90; 89, 97; 89, 139; 90, comparison_operator:==; 90, 91; 90, 96; 91, attribute; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:body; 95, identifier:slug; 96, string:"senate"; 97, block; 97, 98; 98, if_statement; 98, 99; 98, 102; 98, 130; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:jurisdiction; 102, block; 102, 103; 103, if_statement; 103, 104; 103, 113; 103, 121; 104, comparison_operator:==; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:division_level; 109, identifier:name; 110, attribute; 110, 111; 110, 112; 111, identifier:DivisionLevel; 112, identifier:STATE; 113, block; 113, 114; 114, return_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, string:"/{}/senate/{{state}}/"; 118, identifier:format; 119, argument_list; 119, 120; 120, identifier:cycle; 121, else_clause; 121, 122; 122, block; 122, 123; 123, return_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, string:"/{}/senate/"; 127, identifier:format; 128, argument_list; 128, 129; 129, identifier:cycle; 130, else_clause; 130, 131; 131, block; 131, 132; 132, return_statement; 132, 133; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, string:"/{}/{{state}}/senate/"; 136, identifier:format; 137, argument_list; 137, 138; 138, identifier:cycle; 139, else_clause; 139, 140; 140, block; 140, 141; 141, if_statement; 141, 142; 141, 145; 141, 173; 142, attribute; 142, 143; 142, 144; 143, identifier:self; 144, identifier:jurisdiction; 145, block; 145, 146; 146, if_statement; 146, 147; 146, 156; 146, 164; 147, comparison_operator:==; 147, 148; 147, 153; 148, attribute; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:division_level; 152, identifier:name; 153, attribute; 153, 154; 153, 155; 154, identifier:DivisionLevel; 155, identifier:STATE; 156, block; 156, 157; 157, return_statement; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, string:"/{}/house/{{state}}/"; 161, identifier:format; 162, argument_list; 162, 163; 163, identifier:cycle; 164, else_clause; 164, 165; 165, block; 165, 166; 166, return_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, string:"/{}/house/"; 170, identifier:format; 171, argument_list; 171, 172; 172, identifier:cycle; 173, else_clause; 173, 174; 174, block; 174, 175; 175, return_statement; 175, 176; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, string:"/{}/{{state}}/house/"; 179, identifier:format; 180, argument_list; 180, 181; 181, identifier:cycle; 182, elif_clause; 182, 183; 182, 186; 183, comparison_operator:==; 183, 184; 183, 185; 184, identifier:model_class; 185, identifier:Division; 186, block; 186, 187; 187, return_statement; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, string:"/{}/{{state}}/"; 191, identifier:format; 192, argument_list; 192, 193; 193, identifier:cycle; 194, else_clause; 194, 195; 195, block; 195, 196; 196, return_statement; 196, 197; 197, string:"ORPHAN TYPE" | def page_location_template(self):
cycle = self.election_day.cycle.name
model_class = self.model_type.model_class()
if model_class == ElectionDay:
return "/{}/".format(cycle)
if model_class == Office:
if self.jurisdiction:
if self.division_level.name == DivisionLevel.STATE:
return "/{}/president/{{state}}".format(cycle)
else:
return "/{}/president/".format(cycle)
else:
return "/{}/{{state}}/governor/".format(cycle)
elif model_class == Body:
if self.body.slug == "senate":
if self.jurisdiction:
if self.division_level.name == DivisionLevel.STATE:
return "/{}/senate/{{state}}/".format(cycle)
else:
return "/{}/senate/".format(cycle)
else:
return "/{}/{{state}}/senate/".format(cycle)
else:
if self.jurisdiction:
if self.division_level.name == DivisionLevel.STATE:
return "/{}/house/{{state}}/".format(cycle)
else:
return "/{}/house/".format(cycle)
else:
return "/{}/{{state}}/house/".format(cycle)
elif model_class == Division:
return "/{}/{{state}}/".format(cycle)
else:
return "ORPHAN TYPE" |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_ask; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:answers; 6, block; 6, 7; 6, 38; 7, if_statement; 7, 8; 7, 15; 7, 28; 8, call; 8, 9; 8, 10; 9, identifier:isinstance; 10, argument_list; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:validator; 14, identifier:list; 15, block; 15, 16; 16, for_statement; 16, 17; 16, 18; 16, 21; 17, identifier:v; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:validator; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:v; 26, identifier:answers; 27, identifier:answers; 28, else_clause; 28, 29; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:validator; 36, identifier:answers; 37, identifier:answers; 38, while_statement; 38, 39; 38, 41; 39, parenthesized_expression; 39, 40; 40, True; 41, block; 41, 42; 41, 50; 41, 69; 41, 128; 41, 139; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:q; 45, binary_operator:%; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:question; 49, identifier:answers; 50, if_statement; 50, 51; 50, 57; 51, not_operator; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:choices; 56, argument_list; 57, block; 57, 58; 57, 67; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:logger; 62, identifier:warn; 63, argument_list; 63, 64; 64, binary_operator:%; 64, 65; 64, 66; 65, string:'No choices were supplied for "%s"'; 66, identifier:q; 67, return_statement; 67, 68; 68, None; 69, if_statement; 69, 70; 69, 75; 69, 115; 70, comparison_operator:in; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:value; 74, identifier:answers; 75, block; 75, 76; 75, 89; 75, 102; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:default; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:Validator; 82, identifier:stringify; 83, argument_list; 83, 84; 84, subscript; 84, 85; 84, 86; 85, identifier:answers; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:value; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:answer; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:_get_input; 96, argument_list; 96, 97; 97, binary_operator:%; 97, 98; 97, 99; 98, string:"%s [%s]: "; 99, tuple; 99, 100; 99, 101; 100, identifier:q; 101, identifier:default; 102, if_statement; 102, 103; 102, 106; 103, comparison_operator:==; 103, 104; 103, 105; 104, identifier:answer; 105, string:''; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:answer; 110, subscript; 110, 111; 110, 112; 111, identifier:answers; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:value; 115, else_clause; 115, 116; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:answer; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:_get_input; 124, argument_list; 124, 125; 125, binary_operator:%; 125, 126; 125, 127; 126, string:"%s: "; 127, identifier:q; 128, if_statement; 128, 129; 128, 136; 129, boolean_operator:and; 129, 130; 129, 133; 130, comparison_operator:==; 130, 131; 130, 132; 131, identifier:answer; 132, string:'.'; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:multiple; 136, block; 136, 137; 137, return_statement; 137, 138; 138, None; 139, if_statement; 139, 140; 139, 146; 139, 153; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:validate; 144, argument_list; 144, 145; 145, identifier:answer; 146, block; 146, 147; 147, return_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:answer; 152, argument_list; 153, else_clause; 153, 154; 154, block; 154, 155; 155, if_statement; 155, 156; 155, 163; 155, 188; 156, call; 156, 157; 156, 158; 157, identifier:isinstance; 158, argument_list; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:validator; 162, identifier:list; 163, block; 163, 164; 164, for_statement; 164, 165; 164, 166; 164, 169; 165, identifier:v; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:validator; 169, block; 169, 170; 170, if_statement; 170, 171; 170, 178; 171, comparison_operator:!=; 171, 172; 171, 177; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:v; 175, identifier:error; 176, argument_list; 177, string:''; 178, block; 178, 179; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 182; 181, identifier:print; 182, argument_list; 182, 183; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:v; 186, identifier:error; 187, argument_list; 188, else_clause; 188, 189; 189, block; 189, 190; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 193; 192, identifier:print; 193, argument_list; 193, 194; 194, call; 194, 195; 194, 200; 195, attribute; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:validator; 199, identifier:error; 200, argument_list | def _ask(self, answers):
if isinstance(self.validator, list):
for v in self.validator:
v.answers = answers
else:
self.validator.answers = answers
while(True):
q = self.question % answers
if not self.choices():
logger.warn('No choices were supplied for "%s"' % q)
return None
if self.value in answers:
default = Validator.stringify(answers[self.value])
answer = self._get_input("%s [%s]: " % (q, default))
if answer == '':
answer = answers[self.value]
else:
answer = self._get_input("%s: " % q)
if answer == '.' and self.multiple:
return None
if self.validate(answer):
return self.answer()
else:
if isinstance(self.validator, list):
for v in self.validator:
if v.error() != '':
print(v.error())
else:
print(self.validator.error()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:_annotate_fn_args; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 11; 4, identifier:stack; 5, identifier:fn_opname; 6, identifier:nargs; 7, default_parameter; 7, 8; 7, 9; 8, identifier:nkw; 9, unary_operator:-; 9, 10; 10, integer:1; 11, default_parameter; 11, 12; 11, 13; 12, identifier:consume_fn_name; 13, True; 14, block; 14, 15; 14, 19; 14, 148; 14, 342; 14, 456; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:kwarg_names; 18, list:[]; 19, if_statement; 19, 20; 19, 24; 20, comparison_operator:==; 20, 21; 20, 22; 21, identifier:nkw; 22, unary_operator:-; 22, 23; 23, integer:1; 24, block; 24, 25; 25, if_statement; 25, 26; 25, 33; 25, 48; 26, comparison_operator:<; 26, 27; 26, 32; 27, subscript; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:sys; 30, identifier:version_info; 31, integer:0; 32, integer:3; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 39; 36, pattern_list; 36, 37; 36, 38; 37, identifier:nargs; 38, identifier:nkw; 39, tuple; 39, 40; 39, 43; 40, binary_operator:%; 40, 41; 40, 42; 41, identifier:nargs; 42, integer:256; 43, binary_operator://; 43, 44; 43, 47; 44, binary_operator:*; 44, 45; 44, 46; 45, integer:2; 46, identifier:nargs; 47, integer:256; 48, else_clause; 48, 49; 49, block; 49, 50; 50, if_statement; 50, 51; 50, 54; 50, 142; 51, comparison_operator:==; 51, 52; 51, 53; 52, identifier:fn_opname; 53, string:'CALL_FUNCTION_KW'; 54, block; 54, 55; 54, 74; 54, 91; 54, 99; 54, 111; 54, 118; 54, 125; 54, 129; 55, if_statement; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:qj; 58, identifier:_DEBUG_QJ; 59, block; 59, 60; 60, assert_statement; 60, 61; 61, boolean_operator:and; 61, 62; 61, 66; 62, call; 62, 63; 62, 64; 63, identifier:len; 64, argument_list; 64, 65; 65, identifier:stack; 66, comparison_operator:==; 66, 67; 66, 73; 67, attribute; 67, 68; 67, 72; 68, subscript; 68, 69; 68, 70; 69, identifier:stack; 70, unary_operator:-; 70, 71; 71, integer:1; 72, identifier:opname; 73, string:'LOAD_CONST'; 74, if_statement; 74, 75; 74, 89; 75, boolean_operator:or; 75, 76; 75, 81; 76, not_operator; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:len; 79, argument_list; 79, 80; 80, identifier:stack; 81, comparison_operator:!=; 81, 82; 81, 88; 82, attribute; 82, 83; 82, 87; 83, subscript; 83, 84; 83, 85; 84, identifier:stack; 85, unary_operator:-; 85, 86; 86, integer:1; 87, identifier:opname; 88, string:'LOAD_CONST'; 89, block; 89, 90; 90, return_statement; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:se; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:stack; 97, identifier:pop; 98, argument_list; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:kwarg_names; 102, subscript; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:se; 105, identifier:oparg_repr; 106, slice; 106, 107; 106, 108; 106, 109; 107, colon; 108, colon; 109, unary_operator:-; 109, 110; 110, integer:1; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:se; 115, identifier:oparg_repr; 116, list:['']; 116, 117; 117, string:''; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:nkw; 121, call; 121, 122; 121, 123; 122, identifier:len; 123, argument_list; 123, 124; 124, identifier:kwarg_names; 125, expression_statement; 125, 126; 126, augmented_assignment:-=; 126, 127; 126, 128; 127, identifier:nargs; 128, identifier:nkw; 129, if_statement; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:qj; 132, identifier:_DEBUG_QJ; 133, block; 133, 134; 134, assert_statement; 134, 135; 135, boolean_operator:and; 135, 136; 135, 139; 136, comparison_operator:>=; 136, 137; 136, 138; 137, identifier:nargs; 138, integer:0; 139, comparison_operator:>; 139, 140; 139, 141; 140, identifier:nkw; 141, integer:0; 142, else_clause; 142, 143; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:nkw; 147, integer:0; 148, for_statement; 148, 149; 148, 150; 148, 154; 149, identifier:i; 150, call; 150, 151; 150, 152; 151, identifier:range; 152, argument_list; 152, 153; 153, identifier:nkw; 154, block; 154, 155; 154, 163; 154, 189; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:se; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:stack; 161, identifier:pop; 162, argument_list; 163, if_statement; 163, 164; 163, 187; 164, boolean_operator:and; 164, 165; 164, 170; 165, comparison_operator:==; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:se; 168, identifier:stack_depth; 169, integer:0; 170, parenthesized_expression; 170, 171; 171, boolean_operator:or; 171, 172; 171, 180; 172, comparison_operator:==; 172, 173; 172, 179; 173, call; 173, 174; 173, 175; 174, identifier:len; 175, argument_list; 175, 176; 176, attribute; 176, 177; 176, 178; 177, identifier:se; 178, identifier:oparg_repr; 179, integer:0; 180, comparison_operator:==; 180, 181; 180, 186; 181, subscript; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:se; 184, identifier:oparg_repr; 185, integer:0; 186, string:''; 187, block; 187, 188; 188, continue_statement; 189, if_statement; 189, 190; 189, 203; 189, 229; 190, boolean_operator:and; 190, 191; 190, 196; 191, comparison_operator:==; 191, 192; 191, 195; 192, binary_operator:%; 192, 193; 192, 194; 193, identifier:i; 194, integer:2; 195, integer:1; 196, comparison_operator:<; 196, 197; 196, 202; 197, subscript; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:sys; 200, identifier:version_info; 201, integer:0; 202, integer:3; 203, block; 203, 204; 203, 215; 204, if_statement; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:qj; 207, identifier:_DEBUG_QJ; 208, block; 208, 209; 209, assert_statement; 209, 210; 210, comparison_operator:==; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:se; 213, identifier:opname; 214, string:'LOAD_CONST'; 215, if_statement; 215, 216; 215, 221; 216, comparison_operator:==; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:se; 219, identifier:opname; 220, string:'LOAD_CONST'; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, augmented_assignment:+=; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:se; 226, identifier:oparg_repr; 227, list:['=']; 227, 228; 228, string:'='; 229, else_clause; 229, 230; 230, block; 230, 231; 230, 235; 230, 262; 230, 286; 230, 306; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 234; 233, identifier:pops; 234, list:[]; 235, if_statement; 235, 236; 235, 244; 236, call; 236, 237; 236, 242; 237, attribute; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:se; 240, identifier:opname; 241, identifier:startswith; 242, argument_list; 242, 243; 243, string:'CALL_FUNCTION'; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 248; 247, identifier:_annotate_fn_args; 248, argument_list; 248, 249; 248, 253; 248, 256; 248, 259; 248, 261; 249, subscript; 249, 250; 249, 251; 250, identifier:stack; 251, slice; 251, 252; 252, colon; 253, attribute; 253, 254; 253, 255; 254, identifier:se; 255, identifier:opname; 256, attribute; 256, 257; 256, 258; 257, identifier:se; 258, identifier:oparg; 259, unary_operator:-; 259, 260; 260, integer:1; 261, True; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:pops; 265, call; 265, 266; 265, 267; 266, identifier:_collect_pops; 267, argument_list; 267, 268; 267, 269; 267, 284; 267, 285; 268, identifier:stack; 269, conditional_expression:if; 269, 270; 269, 275; 269, 283; 270, binary_operator:-; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:se; 273, identifier:stack_depth; 274, integer:1; 275, call; 275, 276; 275, 281; 276, attribute; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:se; 279, identifier:opname; 280, identifier:startswith; 281, argument_list; 281, 282; 282, string:'CALL_FUNCTION'; 283, integer:0; 284, list:[]; 285, False; 286, if_statement; 286, 287; 286, 295; 287, boolean_operator:and; 287, 288; 287, 291; 288, comparison_operator:>; 288, 289; 288, 290; 289, identifier:i; 290, integer:1; 291, call; 291, 292; 291, 293; 292, identifier:len; 293, argument_list; 293, 294; 294, identifier:pops; 295, block; 295, 296; 296, expression_statement; 296, 297; 297, augmented_assignment:+=; 297, 298; 297, 304; 298, attribute; 298, 299; 298, 303; 299, subscript; 299, 300; 299, 301; 300, identifier:pops; 301, unary_operator:-; 301, 302; 302, integer:1; 303, identifier:oparg_repr; 304, list:[',']; 304, 305; 305, string:','; 306, if_statement; 306, 307; 306, 314; 307, comparison_operator:>=; 307, 308; 307, 313; 308, subscript; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:sys; 311, identifier:version_info; 312, integer:0; 313, integer:3; 314, block; 314, 315; 314, 328; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 318; 317, identifier:target_se; 318, conditional_expression:if; 318, 319; 318, 323; 318, 327; 319, subscript; 319, 320; 319, 321; 320, identifier:pops; 321, unary_operator:-; 321, 322; 322, integer:1; 323, call; 323, 324; 323, 325; 324, identifier:len; 325, argument_list; 325, 326; 326, identifier:pops; 327, identifier:se; 328, expression_statement; 328, 329; 329, assignment; 329, 330; 329, 333; 330, attribute; 330, 331; 330, 332; 331, identifier:target_se; 332, identifier:oparg_repr; 333, binary_operator:+; 333, 334; 333, 339; 334, list:[kwarg_names[i], '=']; 334, 335; 334, 338; 335, subscript; 335, 336; 335, 337; 336, identifier:kwarg_names; 337, identifier:i; 338, string:'='; 339, attribute; 339, 340; 339, 341; 340, identifier:target_se; 341, identifier:oparg_repr; 342, for_statement; 342, 343; 342, 344; 342, 348; 343, identifier:i; 344, call; 344, 345; 344, 346; 345, identifier:range; 346, argument_list; 346, 347; 347, identifier:nargs; 348, block; 348, 349; 348, 357; 349, expression_statement; 349, 350; 350, assignment; 350, 351; 350, 352; 351, identifier:se; 352, call; 352, 353; 352, 356; 353, attribute; 353, 354; 353, 355; 354, identifier:stack; 355, identifier:pop; 356, argument_list; 357, if_statement; 357, 358; 357, 366; 357, 381; 357, 417; 358, call; 358, 359; 358, 364; 359, attribute; 359, 360; 359, 363; 360, attribute; 360, 361; 360, 362; 361, identifier:se; 362, identifier:opname; 363, identifier:startswith; 364, argument_list; 364, 365; 365, string:'CALL_FUNCTION'; 366, block; 366, 367; 367, expression_statement; 367, 368; 368, call; 368, 369; 368, 370; 369, identifier:_annotate_fn_args; 370, argument_list; 370, 371; 370, 372; 370, 375; 370, 378; 370, 380; 371, identifier:stack; 372, attribute; 372, 373; 372, 374; 373, identifier:se; 374, identifier:opname; 375, attribute; 375, 376; 375, 377; 376, identifier:se; 377, identifier:oparg; 378, unary_operator:-; 378, 379; 379, integer:1; 380, True; 381, elif_clause; 381, 382; 381, 399; 382, boolean_operator:and; 382, 383; 382, 389; 383, call; 383, 384; 383, 385; 384, identifier:len; 385, argument_list; 385, 386; 386, attribute; 386, 387; 386, 388; 387, identifier:se; 388, identifier:oparg_repr; 389, comparison_operator:in; 389, 390; 389, 395; 390, subscript; 390, 391; 390, 394; 391, attribute; 391, 392; 391, 393; 392, identifier:se; 393, identifier:oparg_repr; 394, integer:0; 395, set; 395, 396; 395, 397; 395, 398; 396, string:']'; 397, string:'}'; 398, string:')'; 399, block; 399, 400; 400, if_statement; 400, 401; 400, 409; 401, parenthesized_expression; 401, 402; 402, boolean_operator:or; 402, 403; 402, 406; 403, comparison_operator:>; 403, 404; 403, 405; 404, identifier:i; 405, integer:0; 406, comparison_operator:>; 406, 407; 406, 408; 407, identifier:nkw; 408, integer:0; 409, block; 409, 410; 410, expression_statement; 410, 411; 411, augmented_assignment:+=; 411, 412; 411, 415; 412, attribute; 412, 413; 412, 414; 413, identifier:se; 414, identifier:oparg_repr; 415, list:[',']; 415, 416; 416, string:','; 417, else_clause; 417, 418; 418, block; 418, 419; 418, 431; 419, expression_statement; 419, 420; 420, assignment; 420, 421; 420, 422; 421, identifier:pops; 422, call; 422, 423; 422, 424; 423, identifier:_collect_pops; 424, argument_list; 424, 425; 424, 426; 424, 429; 424, 430; 425, identifier:stack; 426, attribute; 426, 427; 426, 428; 427, identifier:se; 428, identifier:stack_depth; 429, list:[]; 430, False; 431, if_statement; 431, 432; 431, 445; 432, boolean_operator:and; 432, 433; 432, 441; 433, parenthesized_expression; 433, 434; 434, boolean_operator:or; 434, 435; 434, 438; 435, comparison_operator:>; 435, 436; 435, 437; 436, identifier:i; 437, integer:0; 438, comparison_operator:>; 438, 439; 438, 440; 439, identifier:nkw; 440, integer:0; 441, call; 441, 442; 441, 443; 442, identifier:len; 443, argument_list; 443, 444; 444, identifier:pops; 445, block; 445, 446; 446, expression_statement; 446, 447; 447, augmented_assignment:+=; 447, 448; 447, 454; 448, attribute; 448, 449; 448, 453; 449, subscript; 449, 450; 449, 451; 450, identifier:pops; 451, unary_operator:-; 451, 452; 452, integer:1; 453, identifier:oparg_repr; 454, list:[',']; 454, 455; 455, string:','; 456, if_statement; 456, 457; 456, 458; 457, identifier:consume_fn_name; 458, block; 458, 459; 459, expression_statement; 459, 460; 460, call; 460, 461; 460, 462; 461, identifier:_collect_pops; 462, argument_list; 462, 463; 462, 464; 462, 466; 462, 467; 463, identifier:stack; 464, unary_operator:-; 464, 465; 465, integer:1; 466, list:[]; 467, False | def _annotate_fn_args(stack, fn_opname, nargs, nkw=-1, consume_fn_name=True):
kwarg_names = []
if nkw == -1:
if sys.version_info[0] < 3:
nargs, nkw = (nargs % 256, 2 * nargs // 256)
else:
if fn_opname == 'CALL_FUNCTION_KW':
if qj._DEBUG_QJ:
assert len(stack) and stack[-1].opname == 'LOAD_CONST'
if not len(stack) or stack[-1].opname != 'LOAD_CONST':
return
se = stack.pop()
kwarg_names = se.oparg_repr[::-1]
se.oparg_repr = ['']
nkw = len(kwarg_names)
nargs -= nkw
if qj._DEBUG_QJ:
assert nargs >= 0 and nkw > 0
else:
nkw = 0
for i in range(nkw):
se = stack.pop()
if se.stack_depth == 0 and (len(se.oparg_repr) == 0 or se.oparg_repr[0] == ''):
continue
if i % 2 == 1 and sys.version_info[0] < 3:
if qj._DEBUG_QJ:
assert se.opname == 'LOAD_CONST'
if se.opname == 'LOAD_CONST':
se.oparg_repr += ['=']
else:
pops = []
if se.opname.startswith('CALL_FUNCTION'):
_annotate_fn_args(stack[:], se.opname, se.oparg, -1, True)
pops = _collect_pops(stack, se.stack_depth - 1 if se.opname.startswith('CALL_FUNCTION') else 0, [], False)
if i > 1 and len(pops):
pops[-1].oparg_repr += [',']
if sys.version_info[0] >= 3:
target_se = pops[-1] if len(pops) else se
target_se.oparg_repr = [kwarg_names[i], '='] + target_se.oparg_repr
for i in range(nargs):
se = stack.pop()
if se.opname.startswith('CALL_FUNCTION'):
_annotate_fn_args(stack, se.opname, se.oparg, -1, True)
elif len(se.oparg_repr) and se.oparg_repr[0] in {']', '}', ')'}:
if (i > 0 or nkw > 0):
se.oparg_repr += [',']
else:
pops = _collect_pops(stack, se.stack_depth, [], False)
if (i > 0 or nkw > 0) and len(pops):
pops[-1].oparg_repr += [',']
if consume_fn_name:
_collect_pops(stack, -1, [], False) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:generate_mediation_matrix; 3, parameters; 3, 4; 4, identifier:dsm; 5, block; 5, 6; 5, 12; 5, 18; 5, 26; 5, 37; 5, 52; 5, 70; 5, 385; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:cat; 9, attribute; 9, 10; 9, 11; 10, identifier:dsm; 11, identifier:categories; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:ent; 15, attribute; 15, 16; 15, 17; 16, identifier:dsm; 17, identifier:entities; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:size; 21, subscript; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:dsm; 24, identifier:size; 25, integer:0; 26, if_statement; 26, 27; 26, 29; 27, not_operator; 27, 28; 28, identifier:cat; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:cat; 33, binary_operator:*; 33, 34; 33, 36; 34, list:['appmodule']; 34, 35; 35, string:'appmodule'; 36, identifier:size; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:packages; 40, list_comprehension; 40, 41; 40, 49; 41, subscript; 41, 42; 41, 48; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:e; 45, identifier:split; 46, argument_list; 46, 47; 47, string:'.'; 48, integer:0; 49, for_in_clause; 49, 50; 49, 51; 50, identifier:e; 51, identifier:ent; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:mediation_matrix; 55, list_comprehension; 55, 56; 55, 64; 56, list_comprehension; 56, 57; 56, 58; 57, integer:0; 58, for_in_clause; 58, 59; 58, 60; 59, identifier:_; 60, call; 60, 61; 60, 62; 61, identifier:range; 62, argument_list; 62, 63; 63, identifier:size; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:_; 66, call; 66, 67; 66, 68; 67, identifier:range; 68, argument_list; 68, 69; 69, identifier:size; 70, for_statement; 70, 71; 70, 72; 70, 77; 71, identifier:i; 72, call; 72, 73; 72, 74; 73, identifier:range; 74, argument_list; 74, 75; 74, 76; 75, integer:0; 76, identifier:size; 77, block; 77, 78; 78, for_statement; 78, 79; 78, 80; 78, 85; 79, identifier:j; 80, call; 80, 81; 80, 82; 81, identifier:range; 82, argument_list; 82, 83; 82, 84; 83, integer:0; 84, identifier:size; 85, block; 85, 86; 86, if_statement; 86, 87; 86, 92; 86, 119; 86, 172; 86, 226; 86, 282; 86, 336; 86, 374; 87, comparison_operator:==; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:cat; 90, identifier:i; 91, string:'framework'; 92, block; 92, 93; 93, if_statement; 93, 94; 93, 99; 93, 109; 94, comparison_operator:==; 94, 95; 94, 98; 95, subscript; 95, 96; 95, 97; 96, identifier:cat; 97, identifier:j; 98, string:'framework'; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 107; 102, subscript; 102, 103; 102, 106; 103, subscript; 103, 104; 103, 105; 104, identifier:mediation_matrix; 105, identifier:i; 106, identifier:j; 107, unary_operator:-; 107, 108; 108, integer:1; 109, else_clause; 109, 110; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 118; 113, subscript; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:mediation_matrix; 116, identifier:i; 117, identifier:j; 118, integer:0; 119, elif_clause; 119, 120; 119, 125; 120, comparison_operator:==; 120, 121; 120, 124; 121, subscript; 121, 122; 121, 123; 122, identifier:cat; 123, identifier:i; 124, string:'corelib'; 125, block; 125, 126; 126, if_statement; 126, 127; 126, 152; 126, 162; 127, parenthesized_expression; 127, 128; 128, boolean_operator:or; 128, 129; 128, 149; 129, boolean_operator:or; 129, 130; 129, 137; 130, comparison_operator:in; 130, 131; 130, 134; 131, subscript; 131, 132; 131, 133; 132, identifier:cat; 133, identifier:j; 134, tuple; 134, 135; 134, 136; 135, string:'framework'; 136, string:'corelib'; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:ent; 141, identifier:i; 142, identifier:startswith; 143, argument_list; 143, 144; 144, binary_operator:+; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:packages; 147, identifier:j; 148, string:'.'; 149, comparison_operator:==; 149, 150; 149, 151; 150, identifier:i; 151, identifier:j; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 160; 155, subscript; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:mediation_matrix; 158, identifier:i; 159, identifier:j; 160, unary_operator:-; 160, 161; 161, integer:1; 162, else_clause; 162, 163; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 171; 166, subscript; 166, 167; 166, 170; 167, subscript; 167, 168; 167, 169; 168, identifier:mediation_matrix; 169, identifier:i; 170, identifier:j; 171, integer:0; 172, elif_clause; 172, 173; 172, 178; 173, comparison_operator:==; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:cat; 176, identifier:i; 177, string:'applib'; 178, block; 178, 179; 179, if_statement; 179, 180; 179, 206; 179, 216; 180, parenthesized_expression; 180, 181; 181, boolean_operator:or; 181, 182; 181, 203; 182, boolean_operator:or; 182, 183; 182, 191; 183, comparison_operator:in; 183, 184; 183, 187; 184, subscript; 184, 185; 184, 186; 185, identifier:cat; 186, identifier:j; 187, tuple; 187, 188; 187, 189; 187, 190; 188, string:'framework'; 189, string:'corelib'; 190, string:'applib'; 191, call; 191, 192; 191, 197; 192, attribute; 192, 193; 192, 196; 193, subscript; 193, 194; 193, 195; 194, identifier:ent; 195, identifier:i; 196, identifier:startswith; 197, argument_list; 197, 198; 198, binary_operator:+; 198, 199; 198, 202; 199, subscript; 199, 200; 199, 201; 200, identifier:packages; 201, identifier:j; 202, string:'.'; 203, comparison_operator:==; 203, 204; 203, 205; 204, identifier:i; 205, identifier:j; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 214; 209, subscript; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:mediation_matrix; 212, identifier:i; 213, identifier:j; 214, unary_operator:-; 214, 215; 215, integer:1; 216, else_clause; 216, 217; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 225; 220, subscript; 220, 221; 220, 224; 221, subscript; 221, 222; 221, 223; 222, identifier:mediation_matrix; 223, identifier:i; 224, identifier:j; 225, integer:0; 226, elif_clause; 226, 227; 226, 232; 227, comparison_operator:==; 227, 228; 227, 231; 228, subscript; 228, 229; 228, 230; 229, identifier:cat; 230, identifier:i; 231, string:'appmodule'; 232, block; 232, 233; 233, if_statement; 233, 234; 233, 262; 233, 272; 234, parenthesized_expression; 234, 235; 235, boolean_operator:or; 235, 236; 235, 259; 236, boolean_operator:or; 236, 237; 236, 247; 237, comparison_operator:in; 237, 238; 237, 241; 238, subscript; 238, 239; 238, 240; 239, identifier:cat; 240, identifier:j; 241, tuple; 241, 242; 241, 243; 241, 244; 241, 245; 241, 246; 242, string:'framework'; 243, string:'corelib'; 244, string:'applib'; 245, string:'broker'; 246, string:'data'; 247, call; 247, 248; 247, 253; 248, attribute; 248, 249; 248, 252; 249, subscript; 249, 250; 249, 251; 250, identifier:ent; 251, identifier:i; 252, identifier:startswith; 253, argument_list; 253, 254; 254, binary_operator:+; 254, 255; 254, 258; 255, subscript; 255, 256; 255, 257; 256, identifier:packages; 257, identifier:j; 258, string:'.'; 259, comparison_operator:==; 259, 260; 259, 261; 260, identifier:i; 261, identifier:j; 262, block; 262, 263; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 270; 265, subscript; 265, 266; 265, 269; 266, subscript; 266, 267; 266, 268; 267, identifier:mediation_matrix; 268, identifier:i; 269, identifier:j; 270, unary_operator:-; 270, 271; 271, integer:1; 272, else_clause; 272, 273; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 281; 276, subscript; 276, 277; 276, 280; 277, subscript; 277, 278; 277, 279; 278, identifier:mediation_matrix; 279, identifier:i; 280, identifier:j; 281, integer:0; 282, elif_clause; 282, 283; 282, 288; 283, comparison_operator:==; 283, 284; 283, 287; 284, subscript; 284, 285; 284, 286; 285, identifier:cat; 286, identifier:i; 287, string:'broker'; 288, block; 288, 289; 289, if_statement; 289, 290; 289, 316; 289, 326; 290, parenthesized_expression; 290, 291; 291, boolean_operator:or; 291, 292; 291, 313; 292, boolean_operator:or; 292, 293; 292, 301; 293, comparison_operator:in; 293, 294; 293, 297; 294, subscript; 294, 295; 294, 296; 295, identifier:cat; 296, identifier:j; 297, tuple; 297, 298; 297, 299; 297, 300; 298, string:'appmodule'; 299, string:'corelib'; 300, string:'framework'; 301, call; 301, 302; 301, 307; 302, attribute; 302, 303; 302, 306; 303, subscript; 303, 304; 303, 305; 304, identifier:ent; 305, identifier:i; 306, identifier:startswith; 307, argument_list; 307, 308; 308, binary_operator:+; 308, 309; 308, 312; 309, subscript; 309, 310; 309, 311; 310, identifier:packages; 311, identifier:j; 312, string:'.'; 313, comparison_operator:==; 313, 314; 313, 315; 314, identifier:i; 315, identifier:j; 316, block; 316, 317; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 324; 319, subscript; 319, 320; 319, 323; 320, subscript; 320, 321; 320, 322; 321, identifier:mediation_matrix; 322, identifier:i; 323, identifier:j; 324, unary_operator:-; 324, 325; 325, integer:1; 326, else_clause; 326, 327; 327, block; 327, 328; 328, expression_statement; 328, 329; 329, assignment; 329, 330; 329, 335; 330, subscript; 330, 331; 330, 334; 331, subscript; 331, 332; 331, 333; 332, identifier:mediation_matrix; 333, identifier:i; 334, identifier:j; 335, integer:0; 336, elif_clause; 336, 337; 336, 342; 337, comparison_operator:==; 337, 338; 337, 341; 338, subscript; 338, 339; 338, 340; 339, identifier:cat; 340, identifier:i; 341, string:'data'; 342, block; 342, 343; 343, if_statement; 343, 344; 343, 354; 343, 364; 344, parenthesized_expression; 344, 345; 345, boolean_operator:or; 345, 346; 345, 351; 346, comparison_operator:==; 346, 347; 346, 350; 347, subscript; 347, 348; 347, 349; 348, identifier:cat; 349, identifier:j; 350, string:'framework'; 351, comparison_operator:==; 351, 352; 351, 353; 352, identifier:i; 353, identifier:j; 354, block; 354, 355; 355, expression_statement; 355, 356; 356, assignment; 356, 357; 356, 362; 357, subscript; 357, 358; 357, 361; 358, subscript; 358, 359; 358, 360; 359, identifier:mediation_matrix; 360, identifier:i; 361, identifier:j; 362, unary_operator:-; 362, 363; 363, integer:1; 364, else_clause; 364, 365; 365, block; 365, 366; 366, expression_statement; 366, 367; 367, assignment; 367, 368; 367, 373; 368, subscript; 368, 369; 368, 372; 369, subscript; 369, 370; 369, 371; 370, identifier:mediation_matrix; 371, identifier:i; 372, identifier:j; 373, integer:0; 374, else_clause; 374, 375; 375, block; 375, 376; 376, raise_statement; 376, 377; 377, call; 377, 378; 377, 379; 378, identifier:DesignStructureMatrixError; 379, argument_list; 379, 380; 380, binary_operator:%; 380, 381; 380, 382; 381, string:'Mediation matrix value NOT generated for %s:%s'; 382, tuple; 382, 383; 382, 384; 383, identifier:i; 384, identifier:j; 385, return_statement; 385, 386; 386, identifier:mediation_matrix | def generate_mediation_matrix(dsm):
cat = dsm.categories
ent = dsm.entities
size = dsm.size[0]
if not cat:
cat = ['appmodule'] * size
packages = [e.split('.')[0] for e in ent]
mediation_matrix = [[0 for _ in range(size)]
for _ in range(size)]
for i in range(0, size):
for j in range(0, size):
if cat[i] == 'framework':
if cat[j] == 'framework':
mediation_matrix[i][j] = -1
else:
mediation_matrix[i][j] = 0
elif cat[i] == 'corelib':
if (cat[j] in ('framework', 'corelib') or
ent[i].startswith(packages[j] + '.') or
i == j):
mediation_matrix[i][j] = -1
else:
mediation_matrix[i][j] = 0
elif cat[i] == 'applib':
if (cat[j] in ('framework', 'corelib', 'applib') or
ent[i].startswith(packages[j] + '.') or
i == j):
mediation_matrix[i][j] = -1
else:
mediation_matrix[i][j] = 0
elif cat[i] == 'appmodule':
if (cat[j] in ('framework', 'corelib',
'applib', 'broker', 'data') or
ent[i].startswith(packages[j] + '.') or
i == j):
mediation_matrix[i][j] = -1
else:
mediation_matrix[i][j] = 0
elif cat[i] == 'broker':
if (cat[j] in (
'appmodule', 'corelib', 'framework') or
ent[i].startswith(packages[j] + '.') or
i == j):
mediation_matrix[i][j] = -1
else:
mediation_matrix[i][j] = 0
elif cat[i] == 'data':
if (cat[j] == 'framework' or
i == j):
mediation_matrix[i][j] = -1
else:
mediation_matrix[i][j] = 0
else:
raise DesignStructureMatrixError(
'Mediation matrix value NOT generated for %s:%s' % (
i, j))
return mediation_matrix |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:check; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:dsm; 6, default_parameter; 6, 7; 6, 8; 7, identifier:independence_factor; 8, integer:5; 9, dictionary_splat_pattern; 9, 10; 10, identifier:kwargs; 11, block; 11, 12; 11, 16; 11, 20; 11, 26; 11, 32; 11, 40; 11, 51; 11, 55; 11, 106; 11, 132; 11, 180; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:least_common_mechanism; 15, False; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:message; 19, string:''; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:data; 23, attribute; 23, 24; 23, 25; 24, identifier:dsm; 25, identifier:data; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:categories; 29, attribute; 29, 30; 29, 31; 30, identifier:dsm; 31, identifier:categories; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:dsm_size; 35, subscript; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:dsm; 38, identifier:size; 39, integer:0; 40, if_statement; 40, 41; 40, 43; 41, not_operator; 41, 42; 42, identifier:categories; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:categories; 47, binary_operator:*; 47, 48; 47, 50; 48, list:['appmodule']; 48, 49; 49, string:'appmodule'; 50, identifier:dsm_size; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:dependent_module_number; 54, list:[]; 55, for_statement; 55, 56; 55, 57; 55, 62; 56, identifier:j; 57, call; 57, 58; 57, 59; 58, identifier:range; 59, argument_list; 59, 60; 59, 61; 60, integer:0; 61, identifier:dsm_size; 62, block; 62, 63; 62, 70; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:dependent_module_number; 67, identifier:append; 68, argument_list; 68, 69; 69, integer:0; 70, for_statement; 70, 71; 70, 72; 70, 77; 71, identifier:i; 72, call; 72, 73; 72, 74; 73, identifier:range; 74, argument_list; 74, 75; 74, 76; 75, integer:0; 76, identifier:dsm_size; 77, block; 77, 78; 78, if_statement; 78, 79; 78, 99; 79, parenthesized_expression; 79, 80; 80, boolean_operator:and; 80, 81; 80, 92; 81, boolean_operator:and; 81, 82; 81, 87; 82, comparison_operator:!=; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:categories; 85, identifier:i; 86, string:'framework'; 87, comparison_operator:!=; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:categories; 90, identifier:j; 91, string:'framework'; 92, comparison_operator:>; 92, 93; 92, 98; 93, subscript; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:data; 96, identifier:i; 97, identifier:j; 98, integer:0; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, augmented_assignment:+=; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:dependent_module_number; 104, identifier:j; 105, integer:1; 106, for_statement; 106, 107; 106, 110; 106, 116; 107, pattern_list; 107, 108; 107, 109; 108, identifier:index; 109, identifier:item; 110, call; 110, 111; 110, 112; 111, identifier:enumerate; 112, argument_list; 112, 113; 113, attribute; 113, 114; 113, 115; 114, identifier:dsm; 115, identifier:categories; 116, block; 116, 117; 117, if_statement; 117, 118; 117, 125; 118, boolean_operator:or; 118, 119; 118, 122; 119, comparison_operator:==; 119, 120; 119, 121; 120, identifier:item; 121, string:'broker'; 122, comparison_operator:==; 122, 123; 122, 124; 123, identifier:item; 124, string:'applib'; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 131; 128, subscript; 128, 129; 128, 130; 129, identifier:dependent_module_number; 130, identifier:index; 131, integer:0; 132, if_statement; 132, 133; 132, 141; 132, 146; 133, comparison_operator:<=; 133, 134; 133, 138; 134, call; 134, 135; 134, 136; 135, identifier:max; 136, argument_list; 136, 137; 137, identifier:dependent_module_number; 138, binary_operator:/; 138, 139; 138, 140; 139, identifier:dsm_size; 140, identifier:independence_factor; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:least_common_mechanism; 145, True; 146, else_clause; 146, 147; 147, block; 147, 148; 147, 155; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:maximum; 151, call; 151, 152; 151, 153; 152, identifier:max; 153, argument_list; 153, 154; 154, identifier:dependent_module_number; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:message; 158, parenthesized_expression; 158, 159; 159, binary_operator:%; 159, 160; 159, 163; 160, concatenated_string; 160, 161; 160, 162; 161, string:'Dependencies to %s (%s) > matrix size (%s) / '; 162, string:'independence factor (%s) = %s'; 163, tuple; 163, 164; 163, 174; 163, 175; 163, 176; 163, 177; 164, subscript; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:dsm; 167, identifier:entities; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:dependent_module_number; 171, identifier:index; 172, argument_list; 172, 173; 173, identifier:maximum; 174, identifier:maximum; 175, identifier:dsm_size; 176, identifier:independence_factor; 177, binary_operator:/; 177, 178; 177, 179; 178, identifier:dsm_size; 179, identifier:independence_factor; 180, return_statement; 180, 181; 181, expression_list; 181, 182; 181, 183; 182, identifier:least_common_mechanism; 183, identifier:message | def check(self, dsm, independence_factor=5, **kwargs):
least_common_mechanism = False
message = ''
data = dsm.data
categories = dsm.categories
dsm_size = dsm.size[0]
if not categories:
categories = ['appmodule'] * dsm_size
dependent_module_number = []
for j in range(0, dsm_size):
dependent_module_number.append(0)
for i in range(0, dsm_size):
if (categories[i] != 'framework' and
categories[j] != 'framework' and
data[i][j] > 0):
dependent_module_number[j] += 1
for index, item in enumerate(dsm.categories):
if item == 'broker' or item == 'applib':
dependent_module_number[index] = 0
if max(dependent_module_number) <= dsm_size / independence_factor:
least_common_mechanism = True
else:
maximum = max(dependent_module_number)
message = (
'Dependencies to %s (%s) > matrix size (%s) / '
'independence factor (%s) = %s' % (
dsm.entities[dependent_module_number.index(maximum)],
maximum, dsm_size, independence_factor,
dsm_size / independence_factor))
return least_common_mechanism, message |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:abstract; 3, parameters; 3, 4; 4, identifier:class_; 5, block; 5, 6; 5, 20; 5, 24; 5, 31; 5, 63; 5, 69; 6, if_statement; 6, 7; 6, 14; 7, not_operator; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:inspect; 11, identifier:isclass; 12, argument_list; 12, 13; 13, identifier:class_; 14, block; 14, 15; 15, raise_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:TypeError; 18, argument_list; 18, 19; 19, string:"@abstract can only be applied to classes"; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:abc_meta; 23, None; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:class_meta; 27, call; 27, 28; 27, 29; 28, identifier:type; 29, argument_list; 29, 30; 30, identifier:class_; 31, if_statement; 31, 32; 31, 37; 32, comparison_operator:not; 32, 33; 32, 34; 33, identifier:class_meta; 34, tuple; 34, 35; 34, 36; 35, identifier:_ABCMetaclass; 36, identifier:_ABCObjectMetaclass; 37, block; 37, 38; 38, if_statement; 38, 39; 38, 42; 38, 47; 38, 56; 39, comparison_operator:is; 39, 40; 39, 41; 40, identifier:class_meta; 41, identifier:type; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:abc_meta; 46, identifier:_ABCMetaclass; 47, elif_clause; 47, 48; 47, 51; 48, comparison_operator:is; 48, 49; 48, 50; 49, identifier:class_meta; 50, identifier:ObjectMetaclass; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:abc_meta; 55, identifier:_ABCObjectMetaclass; 56, else_clause; 56, 57; 57, block; 57, 58; 58, raise_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:ValueError; 61, argument_list; 61, 62; 62, string:"@abstract cannot be applied to classes with custom metaclass"; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:class_; 67, identifier:__abstract__; 68, True; 69, return_statement; 69, 70; 70, conditional_expression:if; 70, 71; 70, 78; 70, 79; 71, call; 71, 72; 71, 76; 72, call; 72, 73; 72, 74; 73, identifier:metaclass; 74, argument_list; 74, 75; 75, identifier:abc_meta; 76, argument_list; 76, 77; 77, identifier:class_; 78, identifier:abc_meta; 79, identifier:class_ | def abstract(class_):
if not inspect.isclass(class_):
raise TypeError("@abstract can only be applied to classes")
abc_meta = None
class_meta = type(class_)
if class_meta not in (_ABCMetaclass, _ABCObjectMetaclass):
if class_meta is type:
abc_meta = _ABCMetaclass
elif class_meta is ObjectMetaclass:
abc_meta = _ABCObjectMetaclass
else:
raise ValueError(
"@abstract cannot be applied to classes with custom metaclass")
class_.__abstract__ = True
return metaclass(abc_meta)(class_) if abc_meta else class_ |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:final; 3, parameters; 3, 4; 4, identifier:arg; 5, block; 5, 6; 5, 41; 5, 54; 5, 60; 6, if_statement; 6, 7; 6, 13; 6, 29; 7, call; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:inspect; 10, identifier:isclass; 11, argument_list; 11, 12; 12, identifier:arg; 13, block; 13, 14; 14, if_statement; 14, 15; 14, 21; 15, not_operator; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:isinstance; 18, argument_list; 18, 19; 18, 20; 19, identifier:arg; 20, identifier:ObjectMetaclass; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:ValueError; 25, argument_list; 25, 26; 26, concatenated_string; 26, 27; 26, 28; 27, string:"@final can only be applied to a class "; 28, string:"that is a subclass of Object"; 29, elif_clause; 29, 30; 29, 35; 30, not_operator; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:is_method; 33, argument_list; 33, 34; 34, identifier:arg; 35, block; 35, 36; 36, raise_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:TypeError; 39, argument_list; 39, 40; 40, string:"@final can only be applied to classes or methods"; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:method; 44, conditional_expression:if; 44, 45; 44, 48; 44, 53; 45, attribute; 45, 46; 45, 47; 46, identifier:arg; 47, identifier:method; 48, call; 48, 49; 48, 50; 49, identifier:isinstance; 50, argument_list; 50, 51; 50, 52; 51, identifier:arg; 52, identifier:_WrappedMethod; 53, identifier:arg; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:method; 58, identifier:__final__; 59, True; 60, return_statement; 60, 61; 61, identifier:arg | def final(arg):
if inspect.isclass(arg):
if not isinstance(arg, ObjectMetaclass):
raise ValueError("@final can only be applied to a class "
"that is a subclass of Object")
elif not is_method(arg):
raise TypeError("@final can only be applied to classes or methods")
method = arg.method if isinstance(arg, _WrappedMethod) else arg
method.__final__ = True
return arg |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:override; 3, parameters; 3, 4; 4, default_parameter; 4, 5; 4, 6; 5, identifier:base; 6, identifier:ABSENT; 7, block; 7, 8; 7, 12; 7, 45; 7, 55; 7, 71; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:arg; 11, identifier:base; 12, if_statement; 12, 13; 12, 25; 13, boolean_operator:or; 13, 14; 13, 20; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:inspect; 17, identifier:isfunction; 18, argument_list; 18, 19; 19, identifier:arg; 20, call; 20, 21; 20, 22; 21, identifier:isinstance; 22, argument_list; 22, 23; 22, 24; 23, identifier:arg; 24, identifier:NonInstanceMethod; 25, block; 25, 26; 25, 33; 25, 40; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:_OverrideDecorator; 30, identifier:maybe_signal_classmethod; 31, argument_list; 31, 32; 32, identifier:arg; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:decorator; 36, call; 36, 37; 36, 38; 37, identifier:_OverrideDecorator; 38, argument_list; 38, 39; 39, None; 40, return_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:decorator; 43, argument_list; 43, 44; 44, identifier:arg; 45, if_statement; 45, 46; 45, 49; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:arg; 48, identifier:ABSENT; 49, block; 49, 50; 50, return_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:_OverrideDecorator; 53, argument_list; 53, 54; 54, None; 55, if_statement; 55, 56; 55, 65; 56, boolean_operator:or; 56, 57; 56, 61; 57, call; 57, 58; 57, 59; 58, identifier:is_class; 59, argument_list; 59, 60; 60, identifier:arg; 61, call; 61, 62; 61, 63; 62, identifier:is_string; 63, argument_list; 63, 64; 64, identifier:arg; 65, block; 65, 66; 66, return_statement; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:_OverrideDecorator; 69, argument_list; 69, 70; 70, identifier:arg; 71, raise_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:TypeError; 74, argument_list; 74, 75; 75, concatenated_string; 75, 76; 75, 77; 76, string:"explicit base class for @override "; 77, string:"must be either a string or a class object" | def override(base=ABSENT):
arg = base
if inspect.isfunction(arg) or isinstance(arg, NonInstanceMethod):
_OverrideDecorator.maybe_signal_classmethod(arg)
decorator = _OverrideDecorator(None)
return decorator(arg)
if arg is ABSENT:
return _OverrideDecorator(None)
if is_class(arg) or is_string(arg):
return _OverrideDecorator(arg)
raise TypeError("explicit base class for @override "
"must be either a string or a class object") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_index; 3, parameters; 3, 4; 3, 6; 4, list_splat_pattern; 4, 5; 5, identifier:args; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 19; 8, 29; 8, 143; 8, 150; 8, 164; 8, 168; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:start; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:kwargs; 15, identifier:pop; 16, argument_list; 16, 17; 16, 18; 17, string:'start'; 18, integer:0; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:step; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:kwargs; 25, identifier:pop; 26, argument_list; 26, 27; 26, 28; 27, string:'step'; 28, integer:1; 29, if_statement; 29, 30; 29, 36; 29, 57; 30, comparison_operator:==; 30, 31; 30, 35; 31, call; 31, 32; 31, 33; 32, identifier:len; 33, argument_list; 33, 34; 34, identifier:args; 35, integer:2; 36, block; 36, 37; 36, 43; 36, 48; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 42; 39, pattern_list; 39, 40; 39, 41; 40, identifier:elem; 41, identifier:list_; 42, identifier:args; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:ensure_sequence; 46, argument_list; 46, 47; 47, identifier:list_; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:predicate; 51, lambda; 51, 52; 51, 54; 52, lambda_parameters; 52, 53; 53, identifier:item; 54, comparison_operator:==; 54, 55; 54, 56; 55, identifier:item; 56, identifier:elem; 57, else_clause; 57, 58; 58, block; 58, 59; 58, 73; 58, 87; 58, 103; 58, 112; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:ensure_keyword_args; 62, argument_list; 62, 63; 62, 64; 62, 68; 63, identifier:kwargs; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:mandatory; 66, tuple; 66, 67; 67, string:'in_'; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:optional; 70, tuple; 70, 71; 70, 72; 71, string:'of'; 72, string:'where'; 73, if_statement; 73, 74; 73, 81; 74, boolean_operator:and; 74, 75; 74, 78; 75, comparison_operator:in; 75, 76; 75, 77; 76, string:'of'; 77, identifier:kwargs; 78, comparison_operator:in; 78, 79; 78, 80; 79, string:'where'; 80, identifier:kwargs; 81, block; 81, 82; 82, raise_statement; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:TypeError; 85, argument_list; 85, 86; 86, string:"either an item or predicate must be supplied, not both"; 87, if_statement; 87, 88; 87, 97; 88, not_operator; 88, 89; 89, parenthesized_expression; 89, 90; 90, boolean_operator:or; 90, 91; 90, 94; 91, comparison_operator:in; 91, 92; 91, 93; 92, string:'of'; 93, identifier:kwargs; 94, comparison_operator:in; 94, 95; 94, 96; 95, string:'where'; 96, identifier:kwargs; 97, block; 97, 98; 98, raise_statement; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:TypeError; 101, argument_list; 101, 102; 102, string:"an item or predicate must be supplied"; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:list_; 106, call; 106, 107; 106, 108; 107, identifier:ensure_sequence; 108, argument_list; 108, 109; 109, subscript; 109, 110; 109, 111; 110, identifier:kwargs; 111, string:'in_'; 112, if_statement; 112, 113; 112, 116; 112, 126; 113, comparison_operator:in; 113, 114; 113, 115; 114, string:'where'; 115, identifier:kwargs; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:predicate; 120, call; 120, 121; 120, 122; 121, identifier:ensure_callable; 122, argument_list; 122, 123; 123, subscript; 123, 124; 123, 125; 124, identifier:kwargs; 125, string:'where'; 126, else_clause; 126, 127; 127, block; 127, 128; 127, 134; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:elem; 131, subscript; 131, 132; 131, 133; 132, identifier:kwargs; 133, string:'of'; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:predicate; 137, lambda; 137, 138; 137, 140; 138, lambda_parameters; 138, 139; 139, identifier:item; 140, comparison_operator:==; 140, 141; 140, 142; 141, identifier:item; 142, identifier:elem; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:len_; 146, call; 146, 147; 146, 148; 147, identifier:len; 148, argument_list; 148, 149; 149, identifier:list_; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:start; 153, call; 153, 154; 153, 155; 154, identifier:max; 155, argument_list; 155, 156; 155, 157; 156, integer:0; 157, call; 157, 158; 157, 159; 158, identifier:min; 159, argument_list; 159, 160; 159, 163; 160, binary_operator:-; 160, 161; 160, 162; 161, identifier:len_; 162, integer:1; 163, identifier:start; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:i; 167, identifier:start; 168, while_statement; 168, 169; 168, 173; 168, 190; 169, comparison_operator:<=; 169, 170; 169, 171; 169, 172; 170, integer:0; 171, identifier:i; 172, identifier:len_; 173, block; 173, 174; 173, 186; 174, if_statement; 174, 175; 174, 181; 175, call; 175, 176; 175, 177; 176, identifier:predicate; 177, argument_list; 177, 178; 178, subscript; 178, 179; 178, 180; 179, identifier:list_; 180, identifier:i; 181, block; 181, 182; 182, return_statement; 182, 183; 183, expression_list; 183, 184; 183, 185; 184, identifier:list_; 185, identifier:i; 186, expression_statement; 186, 187; 187, augmented_assignment:+=; 187, 188; 187, 189; 188, identifier:i; 189, identifier:step; 190, else_clause; 190, 191; 191, block; 191, 192; 192, return_statement; 192, 193; 193, expression_list; 193, 194; 193, 195; 194, identifier:list_; 195, unary_operator:-; 195, 196; 196, integer:1 | def _index(*args, **kwargs):
start = kwargs.pop('start', 0)
step = kwargs.pop('step', 1)
if len(args) == 2:
elem, list_ = args
ensure_sequence(list_)
predicate = lambda item: item == elem
else:
ensure_keyword_args(kwargs,
mandatory=('in_',), optional=('of', 'where'))
if 'of' in kwargs and 'where' in kwargs:
raise TypeError(
"either an item or predicate must be supplied, not both")
if not ('of' in kwargs or 'where' in kwargs):
raise TypeError("an item or predicate must be supplied")
list_ = ensure_sequence(kwargs['in_'])
if 'where' in kwargs:
predicate = ensure_callable(kwargs['where'])
else:
elem = kwargs['of']
predicate = lambda item: item == elem
len_ = len(list_)
start = max(0, min(len_ - 1, start))
i = start
while 0 <= i < len_:
if predicate(list_[i]):
return list_, i
i += step
else:
return list_, -1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:tally_poll; 3, parameters; 3, 4; 4, identifier:args; 5, block; 5, 6; 5, 14; 5, 26; 5, 35; 5, 45; 5, 52; 5, 63; 5, 87; 5, 104; 5, 113; 5, 130; 5, 170; 5, 176; 5, 185; 5, 211; 5, 218; 5, 226; 6, if_statement; 6, 7; 6, 11; 7, not_operator; 7, 8; 8, attribute; 8, 9; 8, 10; 9, identifier:args; 10, identifier:msg; 11, block; 11, 12; 12, return_statement; 12, 13; 13, string:"Syntax: !vote tally <pollnum>"; 14, if_statement; 14, 15; 14, 23; 15, not_operator; 15, 16; 16, call; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:args; 20, identifier:msg; 21, identifier:isdigit; 22, argument_list; 23, block; 23, 24; 24, return_statement; 24, 25; 25, string:"Not A Valid Positive Integer."; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:pid; 29, call; 29, 30; 29, 31; 30, identifier:int; 31, argument_list; 31, 32; 32, attribute; 32, 33; 32, 34; 33, identifier:args; 34, identifier:msg; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:poll; 38, call; 38, 39; 38, 40; 39, identifier:get_open_poll; 40, argument_list; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:args; 43, identifier:session; 44, identifier:pid; 45, if_statement; 45, 46; 45, 49; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:poll; 48, None; 49, block; 49, 50; 50, return_statement; 50, 51; 51, string:"That poll doesn't exist or was deleted. Use !poll list to see valid polls"; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:state; 55, conditional_expression:if; 55, 56; 55, 57; 55, 62; 56, string:"Active"; 57, comparison_operator:==; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:poll; 60, identifier:active; 61, integer:1; 62, string:"Closed"; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:votes; 66, call; 66, 67; 66, 86; 67, attribute; 67, 68; 67, 85; 68, call; 68, 69; 68, 79; 69, attribute; 69, 70; 69, 78; 70, call; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:args; 74, identifier:session; 75, identifier:query; 76, argument_list; 76, 77; 77, identifier:Poll_responses; 78, identifier:filter; 79, argument_list; 79, 80; 80, comparison_operator:==; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:Poll_responses; 83, identifier:pid; 84, identifier:pid; 85, identifier:all; 86, argument_list; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:args; 91, identifier:send; 92, argument_list; 92, 93; 93, binary_operator:%; 93, 94; 93, 95; 94, string:"%s poll: %s, %d total votes"; 95, tuple; 95, 96; 95, 97; 95, 100; 96, identifier:state; 97, attribute; 97, 98; 97, 99; 98, identifier:poll; 99, identifier:question; 100, call; 100, 101; 100, 102; 101, identifier:len; 102, argument_list; 102, 103; 103, identifier:votes; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:votemap; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:collections; 110, identifier:defaultdict; 111, argument_list; 111, 112; 112, identifier:list; 113, for_statement; 113, 114; 113, 115; 113, 116; 114, identifier:v; 115, identifier:votes; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 126; 119, attribute; 119, 120; 119, 125; 120, subscript; 120, 121; 120, 122; 121, identifier:votemap; 122, attribute; 122, 123; 122, 124; 123, identifier:v; 124, identifier:response; 125, identifier:append; 126, argument_list; 126, 127; 127, attribute; 127, 128; 127, 129; 128, identifier:v; 129, identifier:voter; 130, for_statement; 130, 131; 130, 132; 130, 140; 131, identifier:x; 132, call; 132, 133; 132, 134; 133, identifier:sorted; 134, argument_list; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:votemap; 138, identifier:keys; 139, argument_list; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:args; 145, identifier:send; 146, argument_list; 146, 147; 146, 165; 147, binary_operator:%; 147, 148; 147, 149; 148, string:"%s: %d -- %s"; 149, tuple; 149, 150; 149, 151; 149, 157; 150, identifier:x; 151, call; 151, 152; 151, 153; 152, identifier:len; 153, argument_list; 153, 154; 154, subscript; 154, 155; 154, 156; 155, identifier:votemap; 156, identifier:x; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, string:", "; 160, identifier:join; 161, argument_list; 161, 162; 162, subscript; 162, 163; 162, 164; 163, identifier:votemap; 164, identifier:x; 165, keyword_argument; 165, 166; 165, 167; 166, identifier:target; 167, attribute; 167, 168; 167, 169; 168, identifier:args; 169, identifier:nick; 170, if_statement; 170, 171; 170, 173; 171, not_operator; 171, 172; 172, identifier:votemap; 173, block; 173, 174; 174, return_statement; 174, 175; 175, string:""; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:ranking; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:collections; 182, identifier:defaultdict; 183, argument_list; 183, 184; 184, identifier:list; 185, for_statement; 185, 186; 185, 187; 185, 192; 186, identifier:x; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:votemap; 190, identifier:keys; 191, argument_list; 192, block; 192, 193; 192, 202; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:num; 196, call; 196, 197; 196, 198; 197, identifier:len; 198, argument_list; 198, 199; 199, subscript; 199, 200; 199, 201; 200, identifier:votemap; 201, identifier:x; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 209; 204, attribute; 204, 205; 204, 208; 205, subscript; 205, 206; 205, 207; 206, identifier:ranking; 207, identifier:num; 208, identifier:append; 209, argument_list; 209, 210; 210, identifier:x; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:high; 214, call; 214, 215; 214, 216; 215, identifier:max; 216, argument_list; 216, 217; 217, identifier:ranking; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:winners; 221, tuple; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:ranking; 224, identifier:high; 225, identifier:high; 226, if_statement; 226, 227; 226, 235; 226, 250; 227, comparison_operator:==; 227, 228; 227, 234; 228, call; 228, 229; 228, 230; 229, identifier:len; 230, argument_list; 230, 231; 231, subscript; 231, 232; 231, 233; 232, identifier:winners; 233, integer:0; 234, integer:1; 235, block; 235, 236; 235, 246; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 239; 238, identifier:winners; 239, tuple; 239, 240; 239, 245; 240, subscript; 240, 241; 240, 244; 241, subscript; 241, 242; 241, 243; 242, identifier:winners; 243, integer:0; 244, integer:0; 245, identifier:high; 246, return_statement; 246, 247; 247, binary_operator:%; 247, 248; 247, 249; 248, string:"The winner is %s with %d votes."; 249, identifier:winners; 250, else_clause; 250, 251; 251, block; 251, 252; 251, 265; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:winners; 255, tuple; 255, 256; 255, 264; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, string:", "; 259, identifier:join; 260, argument_list; 260, 261; 261, subscript; 261, 262; 261, 263; 262, identifier:winners; 263, integer:0; 264, identifier:high; 265, return_statement; 265, 266; 266, binary_operator:%; 266, 267; 266, 268; 267, string:"Tie between %s with %d votes."; 268, identifier:winners | def tally_poll(args):
if not args.msg:
return "Syntax: !vote tally <pollnum>"
if not args.msg.isdigit():
return "Not A Valid Positive Integer."
pid = int(args.msg)
poll = get_open_poll(args.session, pid)
if poll is None:
return "That poll doesn't exist or was deleted. Use !poll list to see valid polls"
state = "Active" if poll.active == 1 else "Closed"
votes = args.session.query(Poll_responses).filter(Poll_responses.pid == pid).all()
args.send("%s poll: %s, %d total votes" % (state, poll.question, len(votes)))
votemap = collections.defaultdict(list)
for v in votes:
votemap[v.response].append(v.voter)
for x in sorted(votemap.keys()):
args.send("%s: %d -- %s" % (x, len(votemap[x]), ", ".join(votemap[x])), target=args.nick)
if not votemap:
return ""
ranking = collections.defaultdict(list)
for x in votemap.keys():
num = len(votemap[x])
ranking[num].append(x)
high = max(ranking)
winners = (ranking[high], high)
if len(winners[0]) == 1:
winners = (winners[0][0], high)
return "The winner is %s with %d votes." % winners
else:
winners = (", ".join(winners[0]), high)
return "Tie between %s with %d votes." % winners |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_setup_pages; 3, parameters; 3, 4; 3, 5; 4, identifier:cls; 5, identifier:config; 6, block; 6, 7; 6, 13; 6, 19; 6, 25; 6, 31; 6, 38; 6, 42; 6, 46; 6, 80; 6, 90; 6, 102; 7, import_from_statement; 7, 8; 7, 11; 8, dotted_name; 8, 9; 8, 10; 9, identifier:cms; 10, identifier:exceptions; 11, dotted_name; 11, 12; 12, identifier:NoHomeFound; 13, import_from_statement; 13, 14; 13, 17; 14, dotted_name; 14, 15; 14, 16; 15, identifier:cms; 16, identifier:models; 17, dotted_name; 17, 18; 18, identifier:Page; 19, import_from_statement; 19, 20; 19, 23; 20, dotted_name; 20, 21; 20, 22; 21, identifier:cms; 22, identifier:utils; 23, dotted_name; 23, 24; 24, identifier:get_language_list; 25, import_from_statement; 25, 26; 25, 29; 26, dotted_name; 26, 27; 26, 28; 27, identifier:django; 28, identifier:conf; 29, dotted_name; 29, 30; 30, identifier:settings; 31, import_from_statement; 31, 32; 31, 36; 32, dotted_name; 32, 33; 32, 34; 32, 35; 33, identifier:django; 34, identifier:utils; 35, identifier:translation; 36, dotted_name; 36, 37; 37, identifier:override; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:app_page; 41, None; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:get_url; 45, False; 46, if_statement; 46, 47; 46, 53; 47, call; 47, 48; 47, 49; 48, identifier:getattr; 49, argument_list; 49, 50; 49, 51; 49, 52; 50, identifier:settings; 51, string:'ALDRYN_SEARCH_CMS_PAGE'; 52, False; 53, block; 53, 54; 53, 60; 53, 68; 53, 74; 54, import_from_statement; 54, 55; 54, 58; 55, dotted_name; 55, 56; 55, 57; 56, identifier:aldryn_search; 57, identifier:search_indexes; 58, dotted_name; 58, 59; 59, identifier:TitleIndex; 60, function_definition; 60, 61; 60, 62; 60, 65; 61, function_name:fake_url; 62, parameters; 62, 63; 62, 64; 63, identifier:self; 64, identifier:obj; 65, block; 65, 66; 66, return_statement; 66, 67; 67, string:''; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:get_url; 71, attribute; 71, 72; 71, 73; 72, identifier:TitleIndex; 73, identifier:get_url; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:TitleIndex; 78, identifier:get_url; 79, identifier:fake_url; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:site; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:Site; 87, identifier:objects; 88, identifier:get_current; 89, argument_list; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:auto_sites; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:cls; 97, identifier:auto_setup; 98, identifier:get; 99, argument_list; 99, 100; 99, 101; 100, string:'sites'; 101, True; 102, if_statement; 102, 103; 102, 112; 103, boolean_operator:or; 103, 104; 103, 107; 104, comparison_operator:is; 104, 105; 104, 106; 105, identifier:auto_sites; 106, True; 107, comparison_operator:in; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:site; 110, identifier:pk; 111, identifier:auto_sites; 112, block; 112, 113; 112, 159; 112, 168; 113, if_statement; 113, 114; 113, 120; 114, call; 114, 115; 114, 116; 115, identifier:getattr; 116, argument_list; 116, 117; 116, 118; 116, 119; 117, identifier:cls; 118, string:'app_config'; 119, False; 120, block; 120, 121; 120, 133; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:configs; 124, call; 124, 125; 124, 132; 125, attribute; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:cls; 129, identifier:app_config; 130, identifier:objects; 131, identifier:all; 132, argument_list; 133, if_statement; 133, 134; 133, 140; 133, 149; 134, not_operator; 134, 135; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:configs; 138, identifier:exists; 139, argument_list; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:config; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:cls; 147, identifier:_create_config; 148, argument_list; 149, else_clause; 149, 150; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:config; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:configs; 157, identifier:first; 158, argument_list; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:langs; 162, call; 162, 163; 162, 164; 163, identifier:get_language_list; 164, argument_list; 164, 165; 165, attribute; 165, 166; 165, 167; 166, identifier:site; 167, identifier:pk; 168, if_statement; 168, 169; 168, 193; 169, not_operator; 169, 170; 170, call; 170, 171; 170, 192; 171, attribute; 171, 172; 171, 191; 172, call; 172, 173; 172, 185; 173, attribute; 173, 174; 173, 184; 174, call; 174, 175; 174, 180; 175, attribute; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:Page; 178, identifier:objects; 179, identifier:on_site; 180, argument_list; 180, 181; 181, attribute; 181, 182; 181, 183; 182, identifier:site; 183, identifier:pk; 184, identifier:filter; 185, argument_list; 185, 186; 186, keyword_argument; 186, 187; 186, 188; 187, identifier:application_urls; 188, attribute; 188, 189; 188, 190; 189, identifier:cls; 190, identifier:__name__; 191, identifier:exists; 192, argument_list; 193, block; 193, 194; 193, 325; 194, for_statement; 194, 195; 194, 196; 194, 197; 195, identifier:lang; 196, identifier:langs; 197, block; 197, 198; 198, with_statement; 198, 199; 198, 205; 199, with_clause; 199, 200; 200, with_item; 200, 201; 201, call; 201, 202; 201, 203; 202, identifier:override; 203, argument_list; 203, 204; 204, identifier:lang; 205, block; 205, 206; 205, 247; 205, 273; 205, 281; 205, 302; 206, if_statement; 206, 207; 206, 208; 206, 230; 206, 241; 207, identifier:config; 208, block; 208, 209; 208, 224; 209, if_statement; 209, 210; 209, 215; 210, subscript; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:cls; 213, identifier:auto_setup; 214, string:'config_translated_fields'; 215, block; 215, 216; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:cls; 220, identifier:_create_config_translation; 221, argument_list; 221, 222; 221, 223; 222, identifier:config; 223, identifier:lang; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:namespace; 227, attribute; 227, 228; 227, 229; 228, identifier:config; 229, identifier:namespace; 230, elif_clause; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:cls; 233, identifier:app_name; 234, block; 234, 235; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:namespace; 238, attribute; 238, 239; 238, 240; 239, identifier:cls; 240, identifier:app_name; 241, else_clause; 241, 242; 242, block; 242, 243; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:namespace; 246, None; 247, try_statement; 247, 248; 247, 266; 248, block; 248, 249; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:home; 252, call; 252, 253; 252, 265; 253, attribute; 253, 254; 253, 264; 254, call; 254, 255; 254, 260; 255, attribute; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:Page; 258, identifier:objects; 259, identifier:get_home; 260, argument_list; 260, 261; 261, attribute; 261, 262; 261, 263; 262, identifier:site; 263, identifier:pk; 264, identifier:get_draft_object; 265, argument_list; 266, except_clause; 266, 267; 266, 268; 267, identifier:NoHomeFound; 268, block; 268, 269; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:home; 272, None; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:set_home; 276, call; 276, 277; 276, 278; 277, identifier:hasattr; 278, argument_list; 278, 279; 278, 280; 279, identifier:Page; 280, string:'set_as_homepage'; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:home; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:cls; 287, identifier:_create_page; 288, argument_list; 288, 289; 288, 290; 288, 291; 288, 296; 288, 299; 289, identifier:home; 290, identifier:lang; 291, subscript; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:cls; 294, identifier:auto_setup; 295, string:'home title'; 296, keyword_argument; 296, 297; 296, 298; 297, identifier:site; 298, identifier:site; 299, keyword_argument; 299, 300; 299, 301; 300, identifier:set_home; 301, identifier:set_home; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 305; 304, identifier:app_page; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:cls; 308, identifier:_create_page; 309, argument_list; 309, 310; 309, 311; 309, 312; 309, 317; 309, 320; 309, 321; 309, 322; 310, identifier:app_page; 311, identifier:lang; 312, subscript; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:cls; 315, identifier:auto_setup; 316, string:'page title'; 317, attribute; 317, 318; 317, 319; 318, identifier:cls; 319, identifier:__name__; 320, identifier:home; 321, identifier:namespace; 322, keyword_argument; 322, 323; 322, 324; 323, identifier:site; 324, identifier:site; 325, if_statement; 325, 326; 325, 327; 326, identifier:get_url; 327, block; 327, 328; 328, expression_statement; 328, 329; 329, assignment; 329, 330; 329, 333; 330, attribute; 330, 331; 330, 332; 331, identifier:TitleIndex; 332, identifier:get_url; 333, identifier:get_url | def _setup_pages(cls, config):
from cms.exceptions import NoHomeFound
from cms.models import Page
from cms.utils import get_language_list
from django.conf import settings
from django.utils.translation import override
app_page = None
get_url = False
if getattr(settings, 'ALDRYN_SEARCH_CMS_PAGE', False):
from aldryn_search.search_indexes import TitleIndex
def fake_url(self, obj):
return ''
get_url = TitleIndex.get_url
TitleIndex.get_url = fake_url
site = Site.objects.get_current()
auto_sites = cls.auto_setup.get('sites', True)
if auto_sites is True or site.pk in auto_sites:
if getattr(cls, 'app_config', False):
configs = cls.app_config.objects.all()
if not configs.exists():
config = cls._create_config()
else:
config = configs.first()
langs = get_language_list(site.pk)
if not Page.objects.on_site(site.pk).filter(application_urls=cls.__name__).exists():
for lang in langs:
with override(lang):
if config:
if cls.auto_setup['config_translated_fields']:
cls._create_config_translation(config, lang)
namespace = config.namespace
elif cls.app_name:
namespace = cls.app_name
else:
namespace = None
try:
home = Page.objects.get_home(site.pk).get_draft_object()
except NoHomeFound:
home = None
set_home = hasattr(Page, 'set_as_homepage')
home = cls._create_page(
home, lang, cls.auto_setup['home title'], site=site, set_home=set_home
)
app_page = cls._create_page(
app_page, lang, cls.auto_setup['page title'], cls.__name__, home,
namespace, site=site
)
if get_url:
TitleIndex.get_url = get_url |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:pretty_description; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:description; 5, default_parameter; 5, 6; 5, 7; 6, identifier:wrap_at; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:indent; 10, integer:0; 11, block; 11, 12; 11, 45; 11, 51; 11, 71; 11, 75; 11, 101; 11, 111; 11, 123; 11, 139; 11, 143; 11, 239; 12, if_statement; 12, 13; 12, 20; 13, boolean_operator:or; 13, 14; 13, 17; 14, comparison_operator:is; 14, 15; 14, 16; 15, identifier:wrap_at; 16, None; 17, comparison_operator:<; 17, 18; 17, 19; 18, identifier:wrap_at; 19, integer:0; 20, block; 20, 21; 20, 30; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:width; 24, call; 24, 25; 24, 26; 25, identifier:console_width; 26, argument_list; 26, 27; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:default; 29, integer:79; 30, if_statement; 30, 31; 30, 34; 30, 39; 31, comparison_operator:is; 31, 32; 31, 33; 32, identifier:wrap_at; 33, None; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:wrap_at; 38, identifier:width; 39, else_clause; 39, 40; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, augmented_assignment:+=; 42, 43; 42, 44; 43, identifier:wrap_at; 44, identifier:width; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:indent; 48, binary_operator:*; 48, 49; 48, 50; 49, string:' '; 50, identifier:indent; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:text_wrapper; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:textwrap; 57, identifier:TextWrapper; 58, argument_list; 58, 59; 58, 62; 58, 65; 58, 68; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:width; 61, identifier:wrap_at; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:replace_whitespace; 64, False; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:initial_indent; 67, identifier:indent; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:subsequent_indent; 70, identifier:indent; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:new_desc; 74, list:[]; 75, for_statement; 75, 76; 75, 77; 75, 83; 76, identifier:line; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:description; 80, identifier:split; 81, argument_list; 81, 82; 82, string:'\n'; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:new_desc; 88, identifier:append; 89, argument_list; 89, 90; 90, call; 90, 91; 90, 100; 91, attribute; 91, 92; 91, 99; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:line; 95, identifier:replace; 96, argument_list; 96, 97; 96, 98; 97, string:'\n'; 98, string:''; 99, identifier:strip; 100, argument_list; 101, while_statement; 101, 102; 101, 106; 102, not_operator; 102, 103; 103, subscript; 103, 104; 103, 105; 104, identifier:new_desc; 105, integer:0; 106, block; 106, 107; 107, delete_statement; 107, 108; 108, subscript; 108, 109; 108, 110; 109, identifier:new_desc; 110, integer:0; 111, while_statement; 111, 112; 111, 117; 112, not_operator; 112, 113; 113, subscript; 113, 114; 113, 115; 114, identifier:new_desc; 115, unary_operator:-; 115, 116; 116, integer:1; 117, block; 117, 118; 118, delete_statement; 118, 119; 119, subscript; 119, 120; 119, 121; 120, identifier:new_desc; 121, unary_operator:-; 121, 122; 122, integer:1; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:separators; 126, list_comprehension; 126, 127; 126, 128; 126, 136; 127, identifier:i; 128, for_in_clause; 128, 129; 128, 132; 129, pattern_list; 129, 130; 129, 131; 130, identifier:i; 131, identifier:l; 132, call; 132, 133; 132, 134; 133, identifier:enumerate; 134, argument_list; 134, 135; 135, identifier:new_desc; 136, if_clause; 136, 137; 137, not_operator; 137, 138; 138, identifier:l; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:paragraphs; 142, list:[]; 143, if_statement; 143, 144; 143, 145; 144, identifier:separators; 145, block; 145, 146; 145, 156; 145, 168; 145, 206; 145, 219; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 151; 148, pattern_list; 148, 149; 148, 150; 149, identifier:start; 150, identifier:end; 151, expression_list; 151, 152; 151, 153; 152, integer:0; 153, subscript; 153, 154; 153, 155; 154, identifier:separators; 155, integer:0; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:paragraphs; 160, identifier:append; 161, argument_list; 161, 162; 162, subscript; 162, 163; 162, 164; 163, identifier:new_desc; 164, slice; 164, 165; 164, 166; 164, 167; 165, identifier:start; 166, colon; 167, identifier:end; 168, for_statement; 168, 169; 168, 170; 168, 179; 169, identifier:i; 170, call; 170, 171; 170, 172; 171, identifier:range; 172, argument_list; 172, 173; 173, binary_operator:-; 173, 174; 173, 178; 174, call; 174, 175; 174, 176; 175, identifier:len; 176, argument_list; 176, 177; 177, identifier:separators; 178, integer:1; 179, block; 179, 180; 179, 186; 179, 194; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:start; 183, binary_operator:+; 183, 184; 183, 185; 184, identifier:end; 185, integer:1; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:end; 189, subscript; 189, 190; 189, 191; 190, identifier:separators; 191, binary_operator:+; 191, 192; 191, 193; 192, identifier:i; 193, integer:1; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:paragraphs; 198, identifier:append; 199, argument_list; 199, 200; 200, subscript; 200, 201; 200, 202; 201, identifier:new_desc; 202, slice; 202, 203; 202, 204; 202, 205; 203, identifier:start; 204, colon; 205, identifier:end; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:paragraphs; 210, identifier:append; 211, argument_list; 211, 212; 212, subscript; 212, 213; 212, 214; 213, identifier:new_desc; 214, slice; 214, 215; 214, 218; 215, binary_operator:+; 215, 216; 215, 217; 216, identifier:end; 217, integer:1; 218, colon; 219, return_statement; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, string:'\n\n'; 223, identifier:join; 224, generator_expression; 224, 225; 224, 236; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:text_wrapper; 228, identifier:fill; 229, argument_list; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, string:' '; 233, identifier:join; 234, argument_list; 234, 235; 235, identifier:p; 236, for_in_clause; 236, 237; 236, 238; 237, identifier:p; 238, identifier:paragraphs; 239, return_statement; 239, 240; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:text_wrapper; 243, identifier:fill; 244, argument_list; 244, 245; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, string:' '; 248, identifier:join; 249, argument_list; 249, 250; 250, identifier:new_desc | def pretty_description(description, wrap_at=None, indent=0):
if wrap_at is None or wrap_at < 0:
width = console_width(default=79)
if wrap_at is None:
wrap_at = width
else:
wrap_at += width
indent = ' ' * indent
text_wrapper = textwrap.TextWrapper(
width=wrap_at, replace_whitespace=False,
initial_indent=indent, subsequent_indent=indent)
new_desc = []
for line in description.split('\n'):
new_desc.append(line.replace('\n', '').strip())
while not new_desc[0]:
del new_desc[0]
while not new_desc[-1]:
del new_desc[-1]
separators = [i for i, l in enumerate(new_desc) if not l]
paragraphs = []
if separators:
start, end = 0, separators[0]
paragraphs.append(new_desc[start:end])
for i in range(len(separators) - 1):
start = end + 1
end = separators[i + 1]
paragraphs.append(new_desc[start:end])
paragraphs.append(new_desc[end + 1:])
return '\n\n'.join(text_wrapper.fill(' '.join(p)) for p in paragraphs)
return text_wrapper.fill(' '.join(new_desc)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:search; 3, parameters; 3, 4; 3, 5; 3, 10; 3, 13; 3, 16; 4, identifier:term; 5, default_parameter; 5, 6; 5, 7; 6, identifier:category; 7, attribute; 7, 8; 7, 9; 8, identifier:Categories; 9, identifier:ALL; 10, default_parameter; 10, 11; 10, 12; 11, identifier:pages; 12, integer:1; 13, default_parameter; 13, 14; 13, 15; 14, identifier:sort; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:order; 18, None; 19, block; 19, 20; 19, 26; 19, 47; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:s; 23, call; 23, 24; 23, 25; 24, identifier:Search; 25, argument_list; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:s; 30, identifier:search; 31, argument_list; 31, 32; 31, 35; 31, 38; 31, 41; 31, 44; 32, keyword_argument; 32, 33; 32, 34; 33, identifier:term; 34, identifier:term; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:category; 37, identifier:category; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:pages; 40, identifier:pages; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:sort; 43, identifier:sort; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:order; 46, identifier:order; 47, return_statement; 47, 48; 48, identifier:s | def search(term, category=Categories.ALL, pages=1, sort=None, order=None):
s = Search()
s.search(term=term, category=category, pages=pages, sort=sort, order=order)
return s |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:popular; 3, parameters; 3, 4; 3, 7; 4, default_parameter; 4, 5; 4, 6; 5, identifier:category; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:sortOption; 9, string:"title"; 10, block; 10, 11; 10, 17; 10, 25; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:s; 14, call; 14, 15; 14, 16; 15, identifier:Search; 16, argument_list; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:s; 21, identifier:popular; 22, argument_list; 22, 23; 22, 24; 23, identifier:category; 24, identifier:sortOption; 25, return_statement; 25, 26; 26, identifier:s | def popular(category=None, sortOption = "title"):
s = Search()
s.popular(category, sortOption)
return s |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:recent; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 4, default_parameter; 4, 5; 4, 6; 5, identifier:category; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:pages; 9, integer:1; 10, default_parameter; 10, 11; 10, 12; 11, identifier:sort; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:order; 15, None; 16, block; 16, 17; 16, 23; 16, 33; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:s; 20, call; 20, 21; 20, 22; 21, identifier:Search; 22, argument_list; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:s; 27, identifier:recent; 28, argument_list; 28, 29; 28, 30; 28, 31; 28, 32; 29, identifier:category; 30, identifier:pages; 31, identifier:sort; 32, identifier:order; 33, return_statement; 33, 34; 34, identifier:s | def recent(category=None, pages=1, sort=None, order=None):
s = Search()
s.recent(category, pages, sort, order)
return s |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:pick_action_todo; 3, parameters; 4, block; 4, 5; 4, 67; 5, for_statement; 5, 6; 5, 9; 5, 13; 6, pattern_list; 6, 7; 6, 8; 7, identifier:ndx; 8, identifier:todo; 9, call; 9, 10; 9, 11; 10, identifier:enumerate; 11, argument_list; 11, 12; 12, identifier:things_to_do; 13, block; 13, 14; 14, if_statement; 14, 15; 14, 21; 15, call; 15, 16; 15, 17; 16, identifier:roll_dice; 17, argument_list; 17, 18; 18, subscript; 18, 19; 18, 20; 19, identifier:todo; 20, string:"chance"; 21, block; 21, 22; 21, 33; 21, 50; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:cur_act; 25, subscript; 25, 26; 25, 27; 26, identifier:actions; 27, call; 27, 28; 27, 29; 28, identifier:get_action_by_name; 29, argument_list; 29, 30; 30, subscript; 30, 31; 30, 32; 31, identifier:todo; 32, string:"name"; 33, if_statement; 33, 34; 33, 47; 34, boolean_operator:and; 34, 35; 34, 40; 35, comparison_operator:==; 35, 36; 35, 39; 36, subscript; 36, 37; 36, 38; 37, identifier:todo; 38, string:"WHERE_COL"; 39, string:"energy"; 40, comparison_operator:>; 40, 41; 40, 44; 41, subscript; 41, 42; 41, 43; 42, identifier:my_char; 43, string:"energy"; 44, subscript; 44, 45; 44, 46; 45, identifier:todo; 46, string:"WHERE_VAL"; 47, block; 47, 48; 48, return_statement; 48, 49; 49, identifier:cur_act; 50, if_statement; 50, 51; 50, 64; 51, boolean_operator:and; 51, 52; 51, 57; 52, comparison_operator:==; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:todo; 55, string:"WHERE_COL"; 56, string:"gold"; 57, comparison_operator:>; 57, 58; 57, 61; 58, subscript; 58, 59; 58, 60; 59, identifier:my_char; 60, string:"gold"; 61, subscript; 61, 62; 61, 63; 62, identifier:todo; 63, string:"WHERE_VAL"; 64, block; 64, 65; 65, return_statement; 65, 66; 66, identifier:cur_act; 67, return_statement; 67, 68; 68, subscript; 68, 69; 68, 70; 69, identifier:actions; 70, integer:3 | def pick_action_todo():
for ndx, todo in enumerate(things_to_do):
if roll_dice(todo["chance"]):
cur_act = actions[get_action_by_name(todo["name"])]
if todo["WHERE_COL"] == "energy" and my_char["energy"] > todo["WHERE_VAL"]:
return cur_act
if todo["WHERE_COL"] == "gold" and my_char["gold"] > todo["WHERE_VAL"]:
return cur_act
return actions[3] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:select; 3, parameters; 3, 4; 3, 5; 4, identifier:soup; 5, identifier:selector; 6, block; 6, 7; 6, 15; 6, 20; 6, 266; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:tokens; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:selector; 13, identifier:split; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:current_context; 18, list:[soup]; 18, 19; 19, identifier:soup; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:token; 22, identifier:tokens; 23, block; 23, 24; 23, 33; 23, 99; 23, 109; 23, 124; 23, 130; 23, 135; 23, 136; 23, 201; 23, 231; 23, 242; 23, 246; 23, 262; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:m; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:attribselect_re; 30, identifier:match; 31, argument_list; 31, 32; 32, identifier:token; 33, if_statement; 33, 34; 33, 35; 34, identifier:m; 35, block; 35, 36; 35, 48; 35, 56; 35, 65; 35, 69; 35, 94; 35, 98; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 43; 38, pattern_list; 38, 39; 38, 40; 38, 41; 38, 42; 39, identifier:tag; 40, identifier:attribute; 41, identifier:operator; 42, identifier:value; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:m; 46, identifier:groups; 47, argument_list; 48, if_statement; 48, 49; 48, 51; 49, not_operator; 49, 50; 50, identifier:tag; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:tag; 55, True; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:checker; 59, call; 59, 60; 59, 61; 60, identifier:attribute_checker; 61, argument_list; 61, 62; 61, 63; 61, 64; 62, identifier:operator; 63, identifier:attribute; 64, identifier:value; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:found; 68, list:[]; 69, for_statement; 69, 70; 69, 71; 69, 72; 70, identifier:context; 71, identifier:current_context; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:found; 77, identifier:extend; 78, argument_list; 78, 79; 79, list_comprehension; 79, 80; 79, 81; 79, 89; 80, identifier:el; 81, for_in_clause; 81, 82; 81, 83; 82, identifier:el; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:context; 86, identifier:findAll; 87, argument_list; 87, 88; 88, identifier:tag; 89, if_clause; 89, 90; 90, call; 90, 91; 90, 92; 91, identifier:checker; 92, argument_list; 92, 93; 93, identifier:el; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:current_context; 97, identifier:found; 98, continue_statement; 99, if_statement; 99, 100; 99, 101; 99, 104; 100, string:'
tag, id = token.split('; 101, ERROR; 101, 102; 102, not_operator; 102, 103; 103, identifier:tag; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:tag; 108, True; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:el; 112, call; 112, 113; 112, 118; 113, attribute; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:current_context; 116, integer:0; 117, identifier:find; 118, argument_list; 118, 119; 118, 120; 119, identifier:tag; 120, dictionary; 120, 121; 121, pair; 121, 122; 121, 123; 122, string:'id'; 123, identifier:id; 124, if_statement; 124, 125; 124, 127; 125, not_operator; 125, 126; 126, identifier:el; 127, block; 127, 128; 128, return_statement; 128, 129; 129, list:[]; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:current_context; 133, list:[el]; 133, 134; 134, identifier:el; 135, continue_statement; 136, if_statement; 136, 137; 136, 140; 137, comparison_operator:in; 137, 138; 137, 139; 138, string:'.'; 139, identifier:token; 140, block; 140, 141; 140, 153; 140, 161; 140, 165; 140, 196; 140, 200; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 146; 143, pattern_list; 143, 144; 143, 145; 144, identifier:tag; 145, identifier:klass; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:token; 149, identifier:split; 150, argument_list; 150, 151; 150, 152; 151, string:'.'; 152, integer:1; 153, if_statement; 153, 154; 153, 156; 154, not_operator; 154, 155; 155, identifier:tag; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:tag; 160, True; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:found; 164, list:[]; 165, for_statement; 165, 166; 165, 167; 165, 168; 166, identifier:context; 167, identifier:current_context; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:found; 173, identifier:extend; 174, argument_list; 174, 175; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:context; 178, identifier:findAll; 179, argument_list; 179, 180; 179, 181; 180, identifier:tag; 181, dictionary; 181, 182; 182, pair; 182, 183; 182, 184; 183, string:'class'; 184, lambda; 184, 185; 184, 187; 185, lambda_parameters; 185, 186; 186, identifier:attr; 187, boolean_operator:and; 187, 188; 187, 189; 188, identifier:attr; 189, comparison_operator:in; 189, 190; 189, 191; 190, identifier:klass; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:attr; 194, identifier:split; 195, argument_list; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:current_context; 199, identifier:found; 200, continue_statement; 201, if_statement; 201, 202; 201, 205; 202, comparison_operator:==; 202, 203; 202, 204; 203, identifier:token; 204, string:'*'; 205, block; 205, 206; 205, 210; 205, 226; 205, 230; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:found; 209, list:[]; 210, for_statement; 210, 211; 210, 212; 210, 213; 211, identifier:context; 212, identifier:current_context; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:found; 218, identifier:extend; 219, argument_list; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:context; 223, identifier:findAll; 224, argument_list; 224, 225; 225, True; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:current_context; 229, identifier:found; 230, continue_statement; 231, if_statement; 231, 232; 231, 239; 232, not_operator; 232, 233; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:tag_re; 236, identifier:match; 237, argument_list; 237, 238; 238, identifier:token; 239, block; 239, 240; 240, return_statement; 240, 241; 241, list:[]; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:found; 245, list:[]; 246, for_statement; 246, 247; 246, 248; 246, 249; 247, identifier:context; 248, identifier:current_context; 249, block; 249, 250; 250, expression_statement; 250, 251; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:found; 254, identifier:extend; 255, argument_list; 255, 256; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:context; 259, identifier:findAll; 260, argument_list; 260, 261; 261, identifier:token; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 265; 264, identifier:current_context; 265, identifier:found; 266, return_statement; 266, 267; 267, identifier:current_context | def select(soup, selector):
tokens = selector.split()
current_context = [soup]
for token in tokens:
m = attribselect_re.match(token)
if m:
tag, attribute, operator, value = m.groups()
if not tag:
tag = True
checker = attribute_checker(operator, attribute, value)
found = []
for context in current_context:
found.extend([el for el in context.findAll(tag) if checker(el)])
current_context = found
continue
if '
tag, id = token.split('
if not tag:
tag = True
el = current_context[0].find(tag, {'id': id})
if not el:
return []
current_context = [el]
continue
if '.' in token:
tag, klass = token.split('.', 1)
if not tag:
tag = True
found = []
for context in current_context:
found.extend(
context.findAll(tag,
{'class': lambda attr: attr and klass in attr.split()}
)
)
current_context = found
continue
if token == '*':
found = []
for context in current_context:
found.extend(context.findAll(True))
current_context = found
continue
if not tag_re.match(token):
return []
found = []
for context in current_context:
found.extend(context.findAll(token))
current_context = found
return current_context |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:try_; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:block; 5, default_parameter; 5, 6; 5, 7; 6, identifier:except_; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:else_; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:finally_; 13, None; 14, block; 14, 15; 14, 20; 14, 36; 14, 47; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:ensure_callable; 18, argument_list; 18, 19; 19, identifier:block; 20, if_statement; 20, 21; 20, 28; 21, not_operator; 21, 22; 22, parenthesized_expression; 22, 23; 23, boolean_operator:or; 23, 24; 23, 27; 24, boolean_operator:or; 24, 25; 24, 26; 25, identifier:except_; 26, identifier:else_; 27, identifier:finally_; 28, block; 28, 29; 29, raise_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:TypeError; 32, argument_list; 32, 33; 33, concatenated_string; 33, 34; 33, 35; 34, string:"at least one of `except_`, `else_` or `finally_` "; 35, string:"functions must be provided"; 36, if_statement; 36, 37; 36, 41; 37, boolean_operator:and; 37, 38; 37, 39; 38, identifier:else_; 39, not_operator; 39, 40; 40, identifier:except_; 41, block; 41, 42; 42, raise_statement; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:TypeError; 45, argument_list; 45, 46; 46, string:"`else_` can only be provided along with `except_`"; 47, if_statement; 47, 48; 47, 49; 47, 228; 48, identifier:except_; 49, block; 49, 50; 49, 89; 49, 126; 50, if_statement; 50, 51; 50, 55; 50, 63; 51, call; 51, 52; 51, 53; 52, identifier:callable; 53, argument_list; 53, 54; 54, identifier:except_; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:except_; 59, list:[(Exception, except_)]; 59, 60; 60, tuple; 60, 61; 60, 62; 61, identifier:Exception; 62, identifier:except_; 63, else_clause; 63, 64; 64, block; 64, 65; 64, 70; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:ensure_iterable; 68, argument_list; 68, 69; 69, identifier:except_; 70, if_statement; 70, 71; 70, 75; 71, call; 71, 72; 71, 73; 72, identifier:is_mapping; 73, argument_list; 73, 74; 74, identifier:except_; 75, block; 75, 76; 75, 81; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:ensure_ordered_mapping; 79, argument_list; 79, 80; 80, identifier:except_; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:except_; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:except_; 87, identifier:items; 88, argument_list; 89, function_definition; 89, 90; 89, 91; 89, 92; 90, function_name:handle_exception; 91, parameters; 92, block; 92, 93; 92, 107; 92, 125; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 98; 95, pattern_list; 95, 96; 95, 97; 96, identifier:exc_type; 97, identifier:exc_object; 98, subscript; 98, 99; 98, 104; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:sys; 102, identifier:exc_info; 103, argument_list; 104, slice; 104, 105; 104, 106; 105, colon; 106, integer:2; 107, for_statement; 107, 108; 107, 111; 107, 112; 108, pattern_list; 108, 109; 108, 110; 109, identifier:t; 110, identifier:handler; 111, identifier:except_; 112, block; 112, 113; 113, if_statement; 113, 114; 113, 119; 114, call; 114, 115; 114, 116; 115, identifier:issubclass; 116, argument_list; 116, 117; 116, 118; 117, identifier:exc_type; 118, identifier:t; 119, block; 119, 120; 120, return_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:handler; 123, argument_list; 123, 124; 124, identifier:exc_object; 125, raise_statement; 126, if_statement; 126, 127; 126, 128; 126, 186; 127, identifier:else_; 128, block; 128, 129; 128, 134; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:ensure_callable; 132, argument_list; 132, 133; 133, identifier:else_; 134, if_statement; 134, 135; 134, 136; 134, 166; 135, identifier:finally_; 136, block; 136, 137; 136, 142; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:ensure_callable; 140, argument_list; 140, 141; 141, identifier:finally_; 142, try_statement; 142, 143; 142, 148; 142, 154; 142, 160; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:block; 147, argument_list; 148, except_clause; 148, 149; 149, block; 149, 150; 150, return_statement; 150, 151; 151, call; 151, 152; 151, 153; 152, identifier:handle_exception; 153, argument_list; 154, else_clause; 154, 155; 155, block; 155, 156; 156, return_statement; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:else_; 159, argument_list; 160, finally_clause; 160, 161; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:finally_; 165, argument_list; 166, else_clause; 166, 167; 167, block; 167, 168; 168, try_statement; 168, 169; 168, 174; 168, 180; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:block; 173, argument_list; 174, except_clause; 174, 175; 175, block; 175, 176; 176, return_statement; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:handle_exception; 179, argument_list; 180, else_clause; 180, 181; 181, block; 181, 182; 182, return_statement; 182, 183; 183, call; 183, 184; 183, 185; 184, identifier:else_; 185, argument_list; 186, else_clause; 186, 187; 187, block; 187, 188; 188, if_statement; 188, 189; 188, 190; 188, 214; 189, identifier:finally_; 190, block; 190, 191; 190, 196; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 194; 193, identifier:ensure_callable; 194, argument_list; 194, 195; 195, identifier:finally_; 196, try_statement; 196, 197; 196, 202; 196, 208; 197, block; 197, 198; 198, return_statement; 198, 199; 199, call; 199, 200; 199, 201; 200, identifier:block; 201, argument_list; 202, except_clause; 202, 203; 203, block; 203, 204; 204, return_statement; 204, 205; 205, call; 205, 206; 205, 207; 206, identifier:handle_exception; 207, argument_list; 208, finally_clause; 208, 209; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 213; 212, identifier:finally_; 213, argument_list; 214, else_clause; 214, 215; 215, block; 215, 216; 216, try_statement; 216, 217; 216, 222; 217, block; 217, 218; 218, return_statement; 218, 219; 219, call; 219, 220; 219, 221; 220, identifier:block; 221, argument_list; 222, except_clause; 222, 223; 223, block; 223, 224; 224, return_statement; 224, 225; 225, call; 225, 226; 225, 227; 226, identifier:handle_exception; 227, argument_list; 228, elif_clause; 228, 229; 228, 230; 229, identifier:finally_; 230, block; 230, 231; 230, 236; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:ensure_callable; 234, argument_list; 234, 235; 235, identifier:finally_; 236, try_statement; 236, 237; 236, 242; 237, block; 237, 238; 238, return_statement; 238, 239; 239, call; 239, 240; 239, 241; 240, identifier:block; 241, argument_list; 242, finally_clause; 242, 243; 243, block; 243, 244; 244, expression_statement; 244, 245; 245, call; 245, 246; 245, 247; 246, identifier:finally_; 247, argument_list | def try_(block, except_=None, else_=None, finally_=None):
ensure_callable(block)
if not (except_ or else_ or finally_):
raise TypeError("at least one of `except_`, `else_` or `finally_` "
"functions must be provided")
if else_ and not except_:
raise TypeError("`else_` can only be provided along with `except_`")
if except_:
if callable(except_):
except_ = [(Exception, except_)]
else:
ensure_iterable(except_)
if is_mapping(except_):
ensure_ordered_mapping(except_)
except_ = except_.items()
def handle_exception():
exc_type, exc_object = sys.exc_info()[:2]
for t, handler in except_:
if issubclass(exc_type, t):
return handler(exc_object)
raise
if else_:
ensure_callable(else_)
if finally_:
ensure_callable(finally_)
try:
block()
except:
return handle_exception()
else:
return else_()
finally:
finally_()
else:
try:
block()
except:
return handle_exception()
else:
return else_()
else:
if finally_:
ensure_callable(finally_)
try:
return block()
except:
return handle_exception()
finally:
finally_()
else:
try:
return block()
except:
return handle_exception()
elif finally_:
ensure_callable(finally_)
try:
return block()
finally:
finally_() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:replace_u_end_day; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:day; 5, identifier:year; 6, identifier:month; 7, block; 7, 8; 7, 17; 7, 24; 7, 36; 7, 58; 7, 75; 7, 109; 7, 128; 7, 152; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:day; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:day; 14, identifier:lstrip; 15, argument_list; 15, 16; 16, string:'-'; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:year; 20, call; 20, 21; 20, 22; 21, identifier:int; 22, argument_list; 22, 23; 23, identifier:year; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:month; 27, call; 27, 28; 27, 29; 28, identifier:int; 29, argument_list; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:month; 33, identifier:lstrip; 34, argument_list; 34, 35; 35, string:'-'; 36, if_statement; 36, 37; 36, 44; 37, boolean_operator:or; 37, 38; 37, 41; 38, comparison_operator:==; 38, 39; 38, 40; 39, identifier:day; 40, string:'uu'; 41, comparison_operator:==; 41, 42; 41, 43; 42, identifier:day; 43, string:'3u'; 44, block; 44, 45; 45, return_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:str; 48, argument_list; 48, 49; 49, subscript; 49, 50; 49, 57; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:calendar; 53, identifier:monthrange; 54, argument_list; 54, 55; 54, 56; 55, identifier:year; 56, identifier:month; 57, integer:1; 58, if_statement; 58, 59; 58, 66; 59, boolean_operator:or; 59, 60; 59, 63; 60, comparison_operator:==; 60, 61; 60, 62; 61, identifier:day; 62, string:'0u'; 63, comparison_operator:==; 63, 64; 63, 65; 64, identifier:day; 65, string:'1u'; 66, block; 66, 67; 67, return_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:day; 71, identifier:replace; 72, argument_list; 72, 73; 72, 74; 73, string:'u'; 74, string:'9'; 75, if_statement; 75, 76; 75, 83; 76, boolean_operator:or; 76, 77; 76, 80; 77, comparison_operator:==; 77, 78; 77, 79; 78, identifier:day; 79, string:'2u'; 80, comparison_operator:==; 80, 81; 80, 82; 81, identifier:day; 82, string:'u9'; 83, block; 83, 84; 84, if_statement; 84, 85; 84, 95; 84, 98; 84, 105; 85, boolean_operator:or; 85, 86; 85, 89; 86, comparison_operator:!=; 86, 87; 86, 88; 87, identifier:month; 88, string:'02'; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:calendar; 92, identifier:isleap; 93, argument_list; 93, 94; 94, identifier:year; 95, block; 95, 96; 96, return_statement; 96, 97; 97, string:'29'; 98, elif_clause; 98, 99; 98, 102; 99, comparison_operator:==; 99, 100; 99, 101; 100, identifier:day; 101, string:'2u'; 102, block; 102, 103; 103, return_statement; 103, 104; 104, string:'28'; 105, else_clause; 105, 106; 106, block; 106, 107; 107, return_statement; 107, 108; 108, string:'19'; 109, if_statement; 109, 110; 109, 119; 110, comparison_operator:<; 110, 111; 110, 112; 110, 118; 111, integer:1; 112, call; 112, 113; 112, 114; 113, identifier:int; 114, argument_list; 114, 115; 115, subscript; 115, 116; 115, 117; 116, identifier:day; 117, integer:1; 118, integer:9; 119, block; 119, 120; 120, return_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:day; 124, identifier:replace; 125, argument_list; 125, 126; 125, 127; 126, string:'u'; 127, string:'2'; 128, if_statement; 128, 129; 128, 132; 129, comparison_operator:==; 129, 130; 129, 131; 130, identifier:day; 131, string:'u1'; 132, block; 132, 133; 133, if_statement; 133, 134; 133, 145; 133, 148; 134, comparison_operator:==; 134, 135; 134, 144; 135, subscript; 135, 136; 135, 143; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:calendar; 139, identifier:monthrange; 140, argument_list; 140, 141; 140, 142; 141, identifier:year; 142, identifier:month; 143, integer:1; 144, integer:31; 145, block; 145, 146; 146, return_statement; 146, 147; 147, string:'31'; 148, else_clause; 148, 149; 149, block; 149, 150; 150, return_statement; 150, 151; 151, string:'21'; 152, if_statement; 152, 153; 152, 156; 152, 172; 153, comparison_operator:==; 153, 154; 153, 155; 154, identifier:day; 155, string:'u0'; 156, block; 156, 157; 157, if_statement; 157, 158; 157, 169; 158, comparison_operator:>=; 158, 159; 158, 168; 159, subscript; 159, 160; 159, 167; 160, call; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:calendar; 163, identifier:monthrange; 164, argument_list; 164, 165; 164, 166; 165, identifier:year; 166, identifier:month; 167, integer:1; 168, integer:30; 169, block; 169, 170; 170, return_statement; 170, 171; 171, string:'30'; 172, else_clause; 172, 173; 173, block; 173, 174; 174, return_statement; 174, 175; 175, string:'20' | def replace_u_end_day(day, year, month):
day = day.lstrip('-')
year = int(year)
month = int(month.lstrip('-'))
if day == 'uu' or day == '3u':
return str(calendar.monthrange(year, month)[1])
if day == '0u' or day == '1u':
return day.replace('u', '9')
if day == '2u' or day == 'u9':
if month != '02' or calendar.isleap(year):
return '29'
elif day == '2u':
return '28'
else:
return '19'
if 1 < int(day[1]) < 9:
return day.replace('u', '2')
if day == 'u1':
if calendar.monthrange(year, month)[1] == 31:
return '31'
else:
return '21'
if day == 'u0':
if calendar.monthrange(year, month)[1] >= 30:
return '30'
else:
return '20' |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:zero_year_special_case; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:from_date; 5, identifier:to_date; 6, identifier:start; 7, identifier:end; 8, block; 8, 9; 9, if_statement; 9, 10; 9, 17; 9, 240; 9, 251; 10, boolean_operator:and; 10, 11; 10, 14; 11, comparison_operator:==; 11, 12; 11, 13; 12, identifier:start; 13, string:'pos'; 14, comparison_operator:==; 14, 15; 14, 16; 15, identifier:end; 16, string:'pos'; 17, block; 17, 18; 17, 36; 17, 54; 18, if_statement; 18, 19; 18, 33; 19, boolean_operator:and; 19, 20; 19, 26; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:from_date; 23, identifier:startswith; 24, argument_list; 24, 25; 25, string:'0000'; 26, not_operator; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:to_date; 30, identifier:startswith; 31, argument_list; 31, 32; 32, string:'0000'; 33, block; 33, 34; 34, return_statement; 34, 35; 35, True; 36, if_statement; 36, 37; 36, 51; 37, boolean_operator:and; 37, 38; 37, 45; 38, not_operator; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:from_date; 42, identifier:startswith; 43, argument_list; 43, 44; 44, string:'0000'; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:to_date; 48, identifier:startswith; 49, argument_list; 49, 50; 50, string:'0000'; 51, block; 51, 52; 52, return_statement; 52, 53; 53, False; 54, if_statement; 54, 55; 54, 68; 55, boolean_operator:and; 55, 56; 55, 62; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:from_date; 59, identifier:startswith; 60, argument_list; 60, 61; 61, string:'0000'; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:to_date; 65, identifier:startswith; 66, argument_list; 66, 67; 67, string:'0000'; 68, block; 68, 69; 68, 141; 68, 213; 68, 220; 69, if_statement; 69, 70; 69, 76; 69, 85; 69, 109; 70, comparison_operator:==; 70, 71; 70, 75; 71, call; 71, 72; 71, 73; 72, identifier:len; 73, argument_list; 73, 74; 74, identifier:from_date; 75, integer:4; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 82; 79, pattern_list; 79, 80; 79, 81; 80, identifier:fm; 81, identifier:fd; 82, expression_list; 82, 83; 82, 84; 83, integer:1; 84, integer:1; 85, elif_clause; 85, 86; 85, 92; 86, comparison_operator:==; 86, 87; 86, 91; 87, call; 87, 88; 87, 89; 88, identifier:len; 89, argument_list; 89, 90; 90, identifier:from_date; 91, integer:7; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 98; 95, pattern_list; 95, 96; 95, 97; 96, identifier:fm; 97, identifier:fd; 98, expression_list; 98, 99; 98, 108; 99, call; 99, 100; 99, 101; 100, identifier:int; 101, argument_list; 101, 102; 102, subscript; 102, 103; 102, 104; 103, identifier:from_date; 104, slice; 104, 105; 104, 106; 104, 107; 105, integer:5; 106, colon; 107, integer:7; 108, integer:1; 109, elif_clause; 109, 110; 109, 116; 110, comparison_operator:==; 110, 111; 110, 115; 111, call; 111, 112; 111, 113; 112, identifier:len; 113, argument_list; 113, 114; 114, identifier:from_date; 115, integer:10; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 122; 119, pattern_list; 119, 120; 119, 121; 120, identifier:fm; 121, identifier:fd; 122, expression_list; 122, 123; 122, 132; 123, call; 123, 124; 123, 125; 124, identifier:int; 125, argument_list; 125, 126; 126, subscript; 126, 127; 126, 128; 127, identifier:from_date; 128, slice; 128, 129; 128, 130; 128, 131; 129, integer:5; 130, colon; 131, integer:7; 132, call; 132, 133; 132, 134; 133, identifier:int; 134, argument_list; 134, 135; 135, subscript; 135, 136; 135, 137; 136, identifier:from_date; 137, slice; 137, 138; 137, 139; 137, 140; 138, integer:8; 139, colon; 140, integer:10; 141, if_statement; 141, 142; 141, 148; 141, 157; 141, 181; 142, comparison_operator:==; 142, 143; 142, 147; 143, call; 143, 144; 143, 145; 144, identifier:len; 145, argument_list; 145, 146; 146, identifier:to_date; 147, integer:4; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 154; 151, pattern_list; 151, 152; 151, 153; 152, identifier:tm; 153, identifier:td; 154, expression_list; 154, 155; 154, 156; 155, integer:1; 156, integer:1; 157, elif_clause; 157, 158; 157, 164; 158, comparison_operator:==; 158, 159; 158, 163; 159, call; 159, 160; 159, 161; 160, identifier:len; 161, argument_list; 161, 162; 162, identifier:to_date; 163, integer:7; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 170; 167, pattern_list; 167, 168; 167, 169; 168, identifier:tm; 169, identifier:td; 170, expression_list; 170, 171; 170, 180; 171, call; 171, 172; 171, 173; 172, identifier:int; 173, argument_list; 173, 174; 174, subscript; 174, 175; 174, 176; 175, identifier:to_date; 176, slice; 176, 177; 176, 178; 176, 179; 177, integer:5; 178, colon; 179, integer:7; 180, integer:1; 181, elif_clause; 181, 182; 181, 188; 182, comparison_operator:==; 182, 183; 182, 187; 183, call; 183, 184; 183, 185; 184, identifier:len; 185, argument_list; 185, 186; 186, identifier:to_date; 187, integer:10; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 194; 191, pattern_list; 191, 192; 191, 193; 192, identifier:tm; 193, identifier:td; 194, expression_list; 194, 195; 194, 204; 195, call; 195, 196; 195, 197; 196, identifier:int; 197, argument_list; 197, 198; 198, subscript; 198, 199; 198, 200; 199, identifier:to_date; 200, slice; 200, 201; 200, 202; 200, 203; 201, integer:5; 202, colon; 203, integer:7; 204, call; 204, 205; 204, 206; 205, identifier:int; 206, argument_list; 206, 207; 207, subscript; 207, 208; 207, 209; 208, identifier:to_date; 209, slice; 209, 210; 209, 211; 209, 212; 210, integer:8; 211, colon; 212, integer:10; 213, if_statement; 213, 214; 213, 217; 214, comparison_operator:==; 214, 215; 214, 216; 215, identifier:from_date; 216, identifier:to_date; 217, block; 217, 218; 218, return_statement; 218, 219; 219, True; 220, if_statement; 220, 221; 220, 224; 220, 236; 221, comparison_operator:<=; 221, 222; 221, 223; 222, identifier:fm; 223, identifier:tm; 224, block; 224, 225; 225, if_statement; 225, 226; 225, 229; 225, 232; 226, comparison_operator:<=; 226, 227; 226, 228; 227, identifier:fd; 228, identifier:td; 229, block; 229, 230; 230, return_statement; 230, 231; 231, True; 232, else_clause; 232, 233; 233, block; 233, 234; 234, return_statement; 234, 235; 235, False; 236, else_clause; 236, 237; 237, block; 237, 238; 238, return_statement; 238, 239; 239, False; 240, elif_clause; 240, 241; 240, 248; 241, boolean_operator:and; 241, 242; 241, 245; 242, comparison_operator:==; 242, 243; 242, 244; 243, identifier:start; 244, string:'neg'; 245, comparison_operator:==; 245, 246; 245, 247; 246, identifier:end; 247, string:'neg'; 248, block; 248, 249; 249, return_statement; 249, 250; 250, False; 251, elif_clause; 251, 252; 251, 259; 252, boolean_operator:and; 252, 253; 252, 256; 253, comparison_operator:==; 253, 254; 253, 255; 254, identifier:start; 255, string:'neg'; 256, comparison_operator:==; 256, 257; 256, 258; 257, identifier:end; 258, string:'pos'; 259, block; 259, 260; 260, if_statement; 260, 261; 260, 267; 260, 270; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:from_date; 264, identifier:startswith; 265, argument_list; 265, 266; 266, string:"0000"; 267, block; 267, 268; 268, return_statement; 268, 269; 269, False; 270, else_clause; 270, 271; 271, block; 271, 272; 272, return_statement; 272, 273; 273, True | def zero_year_special_case(from_date, to_date, start, end):
if start == 'pos' and end == 'pos':
if from_date.startswith('0000') and not to_date.startswith('0000'):
return True
if not from_date.startswith('0000') and to_date.startswith('0000'):
return False
if from_date.startswith('0000') and to_date.startswith('0000'):
if len(from_date) == 4:
fm, fd = 1, 1
elif len(from_date) == 7:
fm, fd = int(from_date[5:7]), 1
elif len(from_date) == 10:
fm, fd = int(from_date[5:7]), int(from_date[8:10])
if len(to_date) == 4:
tm, td = 1, 1
elif len(to_date) == 7:
tm, td = int(to_date[5:7]), 1
elif len(to_date) == 10:
tm, td = int(to_date[5:7]), int(to_date[8:10])
if from_date == to_date:
return True
if fm <= tm:
if fd <= td:
return True
else:
return False
else:
return False
elif start == 'neg' and end == 'neg':
return False
elif start == 'neg' and end == 'pos':
if from_date.startswith("0000"):
return False
else:
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:is_valid_interval; 3, parameters; 3, 4; 4, identifier:edtf_candidate; 5, block; 5, 6; 5, 10; 5, 14; 5, 22; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:from_date; 9, None; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:to_date; 13, None; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 19; 16, pattern_list; 16, 17; 16, 18; 17, identifier:end; 18, identifier:start; 19, expression_list; 19, 20; 19, 21; 20, string:'pos'; 21, string:'pos'; 22, if_statement; 22, 23; 22, 31; 22, 427; 23, comparison_operator:==; 23, 24; 23, 30; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:edtf_candidate; 27, identifier:count; 28, argument_list; 28, 29; 29, string:'/'; 30, integer:1; 31, block; 31, 32; 31, 40; 31, 51; 31, 60; 31, 86; 31, 112; 31, 123; 31, 154; 31, 180; 31, 206; 31, 232; 31, 258; 31, 305; 31, 350; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:edtf_candidate; 35, call; 35, 36; 35, 37; 36, identifier:replace_all; 37, argument_list; 37, 38; 37, 39; 38, identifier:edtf_candidate; 39, identifier:interval_replacements; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:edtf_candidate; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:re; 46, identifier:sub; 47, argument_list; 47, 48; 47, 49; 47, 50; 48, identifier:U_PATTERN; 49, identifier:replace_u; 50, identifier:edtf_candidate; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:parts; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:edtf_candidate; 57, identifier:split; 58, argument_list; 58, 59; 59, string:'/'; 60, if_statement; 60, 61; 60, 69; 61, call; 61, 62; 61, 67; 62, attribute; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:parts; 65, integer:0; 66, identifier:startswith; 67, argument_list; 67, 68; 68, string:"-"; 69, block; 69, 70; 69, 74; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:start; 73, string:'neg'; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:parts; 78, integer:0; 79, subscript; 79, 80; 79, 83; 80, subscript; 80, 81; 80, 82; 81, identifier:parts; 82, integer:0; 83, slice; 83, 84; 83, 85; 84, integer:1; 85, colon; 86, if_statement; 86, 87; 86, 95; 87, call; 87, 88; 87, 93; 88, attribute; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:parts; 91, integer:1; 92, identifier:startswith; 93, argument_list; 93, 94; 94, string:"-"; 95, block; 95, 96; 95, 100; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:end; 99, string:'neg'; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:parts; 104, integer:1; 105, subscript; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:parts; 108, integer:1; 109, slice; 109, 110; 109, 111; 110, integer:1; 111, colon; 112, if_statement; 112, 113; 112, 120; 113, boolean_operator:and; 113, 114; 113, 117; 114, comparison_operator:==; 114, 115; 114, 116; 115, identifier:start; 116, string:'pos'; 117, comparison_operator:==; 117, 118; 117, 119; 118, identifier:end; 119, string:'neg'; 120, block; 120, 121; 121, return_statement; 121, 122; 122, False; 123, if_statement; 123, 124; 123, 141; 124, boolean_operator:or; 124, 125; 124, 133; 125, call; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:parts; 129, integer:0; 130, identifier:startswith; 131, argument_list; 131, 132; 132, string:"0000"; 133, call; 133, 134; 133, 139; 134, attribute; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:parts; 137, integer:1; 138, identifier:startswith; 139, argument_list; 139, 140; 140, string:"0000"; 141, block; 141, 142; 142, return_statement; 142, 143; 143, call; 143, 144; 143, 145; 144, identifier:zero_year_special_case; 145, argument_list; 145, 146; 145, 149; 145, 152; 145, 153; 146, subscript; 146, 147; 146, 148; 147, identifier:parts; 148, integer:0; 149, subscript; 149, 150; 149, 151; 150, identifier:parts; 151, integer:1; 152, identifier:start; 153, identifier:end; 154, if_statement; 154, 155; 154, 165; 155, comparison_operator:==; 155, 156; 155, 164; 156, call; 156, 157; 156, 162; 157, attribute; 157, 158; 157, 161; 158, subscript; 158, 159; 158, 160; 159, identifier:parts; 160, integer:0; 161, identifier:count; 162, argument_list; 162, 163; 163, string:"-"; 164, integer:2; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:from_date; 169, call; 169, 170; 169, 175; 170, attribute; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:datetime; 173, identifier:datetime; 174, identifier:strptime; 175, argument_list; 175, 176; 175, 179; 176, subscript; 176, 177; 176, 178; 177, identifier:parts; 178, integer:0; 179, string:"%Y-%m-%d"; 180, if_statement; 180, 181; 180, 191; 181, comparison_operator:==; 181, 182; 181, 190; 182, call; 182, 183; 182, 188; 183, attribute; 183, 184; 183, 187; 184, subscript; 184, 185; 184, 186; 185, identifier:parts; 186, integer:1; 187, identifier:count; 188, argument_list; 188, 189; 189, string:"-"; 190, integer:2; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:to_date; 195, call; 195, 196; 195, 201; 196, attribute; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:datetime; 199, identifier:datetime; 200, identifier:strptime; 201, argument_list; 201, 202; 201, 205; 202, subscript; 202, 203; 202, 204; 203, identifier:parts; 204, integer:1; 205, string:"%Y-%m-%d"; 206, if_statement; 206, 207; 206, 217; 207, comparison_operator:==; 207, 208; 207, 216; 208, call; 208, 209; 208, 214; 209, attribute; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:parts; 212, integer:0; 213, identifier:count; 214, argument_list; 214, 215; 215, string:"-"; 216, integer:1; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:from_date; 221, call; 221, 222; 221, 227; 222, attribute; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:datetime; 225, identifier:datetime; 226, identifier:strptime; 227, argument_list; 227, 228; 227, 231; 228, subscript; 228, 229; 228, 230; 229, identifier:parts; 230, integer:0; 231, string:"%Y-%m"; 232, if_statement; 232, 233; 232, 243; 233, comparison_operator:==; 233, 234; 233, 242; 234, call; 234, 235; 234, 240; 235, attribute; 235, 236; 235, 239; 236, subscript; 236, 237; 236, 238; 237, identifier:parts; 238, integer:1; 239, identifier:count; 240, argument_list; 240, 241; 241, string:"-"; 242, integer:1; 243, block; 243, 244; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 247; 246, identifier:to_date; 247, call; 247, 248; 247, 253; 248, attribute; 248, 249; 248, 252; 249, attribute; 249, 250; 249, 251; 250, identifier:datetime; 251, identifier:datetime; 252, identifier:strptime; 253, argument_list; 253, 254; 253, 257; 254, subscript; 254, 255; 254, 256; 255, identifier:parts; 256, integer:1; 257, string:"%Y-%m"; 258, if_statement; 258, 259; 258, 269; 259, comparison_operator:==; 259, 260; 259, 268; 260, call; 260, 261; 260, 266; 261, attribute; 261, 262; 261, 265; 262, subscript; 262, 263; 262, 264; 263, identifier:parts; 264, integer:0; 265, identifier:count; 266, argument_list; 266, 267; 267, string:"-"; 268, integer:0; 269, block; 269, 270; 270, if_statement; 270, 271; 270, 276; 270, 289; 271, comparison_operator:==; 271, 272; 271, 275; 272, subscript; 272, 273; 272, 274; 273, identifier:parts; 274, integer:0; 275, string:'unknown'; 276, block; 276, 277; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:from_date; 280, call; 280, 281; 280, 286; 281, attribute; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:datetime; 284, identifier:datetime; 285, identifier:strptime; 286, argument_list; 286, 287; 286, 288; 287, string:"0001"; 288, string:"%Y"; 289, else_clause; 289, 290; 290, block; 290, 291; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:from_date; 294, call; 294, 295; 294, 300; 295, attribute; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:datetime; 298, identifier:datetime; 299, identifier:strptime; 300, argument_list; 300, 301; 300, 304; 301, subscript; 301, 302; 301, 303; 302, identifier:parts; 303, integer:0; 304, string:"%Y"; 305, if_statement; 305, 306; 305, 316; 306, comparison_operator:==; 306, 307; 306, 315; 307, call; 307, 308; 307, 313; 308, attribute; 308, 309; 308, 312; 309, subscript; 309, 310; 309, 311; 310, identifier:parts; 311, integer:1; 312, identifier:count; 313, argument_list; 313, 314; 314, string:"-"; 315, integer:0; 316, block; 316, 317; 317, if_statement; 317, 318; 317, 329; 317, 334; 318, boolean_operator:or; 318, 319; 318, 324; 319, comparison_operator:==; 319, 320; 319, 323; 320, subscript; 320, 321; 320, 322; 321, identifier:parts; 322, integer:1; 323, string:'open'; 324, comparison_operator:==; 324, 325; 324, 328; 325, subscript; 325, 326; 325, 327; 326, identifier:parts; 327, integer:1; 328, string:'unknown'; 329, block; 329, 330; 330, expression_statement; 330, 331; 331, assignment; 331, 332; 331, 333; 332, identifier:to_date; 333, string:'open'; 334, else_clause; 334, 335; 335, block; 335, 336; 336, expression_statement; 336, 337; 337, assignment; 337, 338; 337, 339; 338, identifier:to_date; 339, call; 339, 340; 339, 345; 340, attribute; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:datetime; 343, identifier:datetime; 344, identifier:strptime; 345, argument_list; 345, 346; 345, 349; 346, subscript; 346, 347; 346, 348; 347, identifier:parts; 348, integer:1; 349, string:"%Y"; 350, if_statement; 350, 351; 350, 358; 350, 361; 350, 381; 350, 403; 350, 423; 351, boolean_operator:and; 351, 352; 351, 355; 352, comparison_operator:==; 352, 353; 352, 354; 353, identifier:start; 354, string:'neg'; 355, comparison_operator:==; 355, 356; 355, 357; 356, identifier:end; 357, string:'pos'; 358, block; 358, 359; 359, return_statement; 359, 360; 360, True; 361, elif_clause; 361, 362; 361, 369; 362, boolean_operator:and; 362, 363; 362, 366; 363, comparison_operator:==; 363, 364; 363, 365; 364, identifier:start; 365, string:'neg'; 366, comparison_operator:==; 366, 367; 366, 368; 367, identifier:end; 368, string:'neg'; 369, block; 369, 370; 370, if_statement; 370, 371; 370, 378; 371, boolean_operator:and; 371, 372; 371, 377; 372, boolean_operator:and; 372, 373; 372, 376; 373, comparison_operator:>=; 373, 374; 373, 375; 374, identifier:from_date; 375, identifier:to_date; 376, identifier:from_date; 377, identifier:to_date; 378, block; 378, 379; 379, return_statement; 379, 380; 380, True; 381, elif_clause; 381, 382; 381, 400; 382, parenthesized_expression; 382, 383; 383, boolean_operator:or; 383, 384; 383, 395; 384, boolean_operator:or; 384, 385; 384, 390; 385, comparison_operator:==; 385, 386; 385, 389; 386, subscript; 386, 387; 386, 388; 387, identifier:parts; 388, integer:1; 389, string:'unknown'; 390, comparison_operator:==; 390, 391; 390, 394; 391, subscript; 391, 392; 391, 393; 392, identifier:parts; 393, integer:1; 394, string:'open'; 395, comparison_operator:==; 395, 396; 395, 399; 396, subscript; 396, 397; 396, 398; 397, identifier:parts; 398, integer:0; 399, string:'unknown'; 400, block; 400, 401; 401, return_statement; 401, 402; 402, True; 403, elif_clause; 403, 404; 403, 411; 404, boolean_operator:and; 404, 405; 404, 408; 405, comparison_operator:==; 405, 406; 405, 407; 406, identifier:start; 407, string:'pos'; 408, comparison_operator:==; 408, 409; 408, 410; 409, identifier:end; 410, string:'pos'; 411, block; 411, 412; 412, if_statement; 412, 413; 412, 420; 413, boolean_operator:and; 413, 414; 413, 419; 414, boolean_operator:and; 414, 415; 414, 418; 415, comparison_operator:<=; 415, 416; 415, 417; 416, identifier:from_date; 417, identifier:to_date; 418, identifier:from_date; 419, identifier:to_date; 420, block; 420, 421; 421, return_statement; 421, 422; 422, True; 423, else_clause; 423, 424; 424, block; 424, 425; 425, return_statement; 425, 426; 426, False; 427, else_clause; 427, 428; 428, block; 428, 429; 429, return_statement; 429, 430; 430, False | def is_valid_interval(edtf_candidate):
from_date = None
to_date = None
end, start = 'pos', 'pos'
if edtf_candidate.count('/') == 1:
edtf_candidate = replace_all(edtf_candidate, interval_replacements)
edtf_candidate = re.sub(U_PATTERN, replace_u, edtf_candidate)
parts = edtf_candidate.split('/')
if parts[0].startswith("-"):
start = 'neg'
parts[0] = parts[0][1:]
if parts[1].startswith("-"):
end = 'neg'
parts[1] = parts[1][1:]
if start == 'pos' and end == 'neg':
return False
if parts[0].startswith("0000") or parts[1].startswith("0000"):
return zero_year_special_case(parts[0], parts[1], start, end)
if parts[0].count("-") == 2:
from_date = datetime.datetime.strptime(parts[0], "%Y-%m-%d")
if parts[1].count("-") == 2:
to_date = datetime.datetime.strptime(parts[1], "%Y-%m-%d")
if parts[0].count("-") == 1:
from_date = datetime.datetime.strptime(parts[0], "%Y-%m")
if parts[1].count("-") == 1:
to_date = datetime.datetime.strptime(parts[1], "%Y-%m")
if parts[0].count("-") == 0:
if parts[0] == 'unknown':
from_date = datetime.datetime.strptime("0001", "%Y")
else:
from_date = datetime.datetime.strptime(parts[0], "%Y")
if parts[1].count("-") == 0:
if parts[1] == 'open' or parts[1] == 'unknown':
to_date = 'open'
else:
to_date = datetime.datetime.strptime(parts[1], "%Y")
if start == 'neg' and end == 'pos':
return True
elif start == 'neg' and end == 'neg':
if from_date >= to_date and from_date and to_date:
return True
elif (
parts[1] == 'unknown' or
parts[1] == 'open' or
parts[0] == 'unknown'
):
return True
elif start == 'pos' and end == 'pos':
if from_date <= to_date and from_date and to_date:
return True
else:
return False
else:
return False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:template; 3, parameters; 3, 4; 3, 7; 3, 10; 4, default_parameter; 4, 5; 4, 6; 5, identifier:page; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:layout; 9, None; 10, dictionary_splat_pattern; 10, 11; 11, identifier:kwargs; 12, block; 12, 13; 12, 17; 12, 236; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:pkey; 16, string:"_template_extends__"; 17, function_definition; 17, 18; 17, 19; 17, 21; 18, function_name:decorator; 19, parameters; 19, 20; 20, identifier:f; 21, block; 21, 22; 22, if_statement; 22, 23; 22, 29; 22, 147; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:inspect; 26, identifier:isclass; 27, argument_list; 27, 28; 28, identifier:f; 29, block; 29, 30; 29, 36; 29, 46; 29, 95; 29, 103; 29, 111; 29, 117; 29, 124; 29, 136; 29, 145; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:layout_; 33, boolean_operator:or; 33, 34; 33, 35; 34, identifier:layout; 35, identifier:page; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:extends; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:kwargs; 42, identifier:pop; 43, argument_list; 43, 44; 43, 45; 44, string:"extends"; 45, None; 46, if_statement; 46, 47; 46, 54; 47, boolean_operator:and; 47, 48; 47, 49; 48, identifier:extends; 49, call; 49, 50; 49, 51; 50, identifier:hasattr; 51, argument_list; 51, 52; 51, 53; 52, identifier:extends; 53, identifier:pkey; 54, block; 54, 55; 54, 67; 54, 81; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:items; 58, call; 58, 59; 58, 66; 59, attribute; 59, 60; 59, 65; 60, call; 60, 61; 60, 62; 61, identifier:getattr; 62, argument_list; 62, 63; 62, 64; 63, identifier:extends; 64, identifier:pkey; 65, identifier:items; 66, argument_list; 67, if_statement; 67, 68; 67, 71; 68, comparison_operator:in; 68, 69; 68, 70; 69, string:"layout"; 70, identifier:items; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:layout_; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:items; 78, identifier:pop; 79, argument_list; 79, 80; 80, string:"layout"; 81, for_statement; 81, 82; 81, 85; 81, 86; 82, pattern_list; 82, 83; 82, 84; 83, identifier:k; 84, identifier:v; 85, identifier:items; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:kwargs; 91, identifier:setdefault; 92, argument_list; 92, 93; 92, 94; 93, identifier:k; 94, identifier:v; 95, if_statement; 95, 96; 95, 98; 96, not_operator; 96, 97; 97, identifier:layout_; 98, block; 98, 99; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:layout_; 102, string:"layout.html"; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:kwargs; 107, identifier:setdefault; 108, argument_list; 108, 109; 108, 110; 109, string:"brand_name"; 110, string:""; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:kwargs; 115, string:"layout"; 116, identifier:layout_; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 120; 119, identifier:setattr; 120, argument_list; 120, 121; 120, 122; 120, 123; 121, identifier:f; 122, identifier:pkey; 123, identifier:kwargs; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 127; 126, identifier:setattr; 127, argument_list; 127, 128; 127, 129; 127, 130; 128, identifier:f; 129, string:"base_layout"; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:kwargs; 133, identifier:get; 134, argument_list; 134, 135; 135, string:"layout"; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:f; 140, identifier:g; 141, argument_list; 141, 142; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:TEMPLATE_CONTEXT; 144, identifier:kwargs; 145, return_statement; 145, 146; 146, identifier:f; 147, else_clause; 147, 148; 148, block; 148, 149; 148, 234; 149, decorated_definition; 149, 150; 149, 157; 150, decorator; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:functools; 154, identifier:wraps; 155, argument_list; 155, 156; 156, identifier:f; 157, function_definition; 157, 158; 157, 159; 157, 164; 158, function_name:wrap; 159, parameters; 159, 160; 159, 162; 160, list_splat_pattern; 160, 161; 161, identifier:args2; 162, dictionary_splat_pattern; 162, 163; 163, identifier:kwargs2; 164, block; 164, 165; 164, 175; 164, 232; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:response; 168, call; 168, 169; 168, 170; 169, identifier:f; 170, argument_list; 170, 171; 170, 173; 171, list_splat; 171, 172; 172, identifier:args2; 173, dictionary_splat; 173, 174; 174, identifier:kwargs2; 175, if_statement; 175, 176; 175, 185; 176, boolean_operator:or; 176, 177; 176, 182; 177, call; 177, 178; 177, 179; 178, identifier:isinstance; 179, argument_list; 179, 180; 179, 181; 180, identifier:response; 181, identifier:dict; 182, comparison_operator:is; 182, 183; 182, 184; 183, identifier:response; 184, None; 185, block; 185, 186; 185, 192; 185, 203; 185, 214; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:response; 189, boolean_operator:or; 189, 190; 189, 191; 190, identifier:response; 191, dictionary; 192, if_statement; 192, 193; 192, 194; 193, identifier:page; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:response; 199, identifier:setdefault; 200, argument_list; 200, 201; 200, 202; 201, string:"template_"; 202, identifier:page; 203, if_statement; 203, 204; 203, 205; 204, identifier:layout; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:response; 210, identifier:setdefault; 211, argument_list; 211, 212; 211, 213; 212, string:"layout_"; 213, identifier:layout; 214, for_statement; 214, 215; 214, 218; 214, 223; 215, pattern_list; 215, 216; 215, 217; 216, identifier:k; 217, identifier:v; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:kwargs; 221, identifier:items; 222, argument_list; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:response; 228, identifier:setdefault; 229, argument_list; 229, 230; 229, 231; 230, identifier:k; 231, identifier:v; 232, return_statement; 232, 233; 233, identifier:response; 234, return_statement; 234, 235; 235, identifier:wrap; 236, return_statement; 236, 237; 237, identifier:decorator | def template(page=None, layout=None, **kwargs):
pkey = "_template_extends__"
def decorator(f):
if inspect.isclass(f):
layout_ = layout or page
extends = kwargs.pop("extends", None)
if extends and hasattr(extends, pkey):
items = getattr(extends, pkey).items()
if "layout" in items:
layout_ = items.pop("layout")
for k, v in items:
kwargs.setdefault(k, v)
if not layout_:
layout_ = "layout.html"
kwargs.setdefault("brand_name", "")
kwargs["layout"] = layout_
setattr(f, pkey, kwargs)
setattr(f, "base_layout", kwargs.get("layout"))
f.g(TEMPLATE_CONTEXT=kwargs)
return f
else:
@functools.wraps(f)
def wrap(*args2, **kwargs2):
response = f(*args2, **kwargs2)
if isinstance(response, dict) or response is None:
response = response or {}
if page:
response.setdefault("template_", page)
if layout:
response.setdefault("layout_", layout)
for k, v in kwargs.items():
response.setdefault(k, v)
return response
return wrap
return decorator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:getargspec; 3, parameters; 3, 4; 4, identifier:obj; 5, block; 5, 6; 5, 18; 5, 122; 5, 135; 5, 200; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 13; 8, pattern_list; 8, 9; 8, 10; 8, 11; 8, 12; 9, identifier:argnames; 10, identifier:varargs; 11, identifier:varkw; 12, identifier:_defaults; 13, expression_list; 13, 14; 13, 15; 13, 16; 13, 17; 14, None; 15, None; 16, None; 17, None; 18, if_statement; 18, 19; 18, 32; 18, 46; 18, 93; 18, 115; 19, boolean_operator:or; 19, 20; 19, 26; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:inspect; 23, identifier:isfunction; 24, argument_list; 24, 25; 25, identifier:obj; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:inspect; 29, identifier:ismethod; 30, argument_list; 30, 31; 31, identifier:obj; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 40; 35, pattern_list; 35, 36; 35, 37; 35, 38; 35, 39; 36, identifier:argnames; 37, identifier:varargs; 38, identifier:varkw; 39, identifier:_defaults; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:inspect; 43, identifier:getargspec; 44, argument_list; 44, 45; 45, identifier:obj; 46, elif_clause; 46, 47; 46, 53; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:inspect; 50, identifier:isclass; 51, argument_list; 51, 52; 52, identifier:obj; 53, block; 53, 54; 54, if_statement; 54, 55; 54, 63; 54, 76; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:inspect; 58, identifier:ismethoddescriptor; 59, argument_list; 59, 60; 60, attribute; 60, 61; 60, 62; 61, identifier:obj; 62, identifier:__init__; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 71; 66, pattern_list; 66, 67; 66, 68; 66, 69; 66, 70; 67, identifier:argnames; 68, identifier:varargs; 69, identifier:varkw; 70, identifier:_defaults; 71, expression_list; 71, 72; 71, 73; 71, 74; 71, 75; 72, list:[]; 73, False; 74, False; 75, None; 76, else_clause; 76, 77; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 85; 80, pattern_list; 80, 81; 80, 82; 80, 83; 80, 84; 81, identifier:argnames; 82, identifier:varargs; 83, identifier:varkw; 84, identifier:_defaults; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:inspect; 88, identifier:getargspec; 89, argument_list; 89, 90; 90, attribute; 90, 91; 90, 92; 91, identifier:obj; 92, identifier:__init__; 93, elif_clause; 93, 94; 93, 99; 94, call; 94, 95; 94, 96; 95, identifier:hasattr; 96, argument_list; 96, 97; 96, 98; 97, identifier:obj; 98, string:'__call__'; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 107; 102, pattern_list; 102, 103; 102, 104; 102, 105; 102, 106; 103, identifier:argnames; 104, identifier:varargs; 105, identifier:varkw; 106, identifier:_defaults; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:inspect; 110, identifier:getargspec; 111, argument_list; 111, 112; 112, attribute; 112, 113; 112, 114; 113, identifier:obj; 114, identifier:__call__; 115, else_clause; 115, 116; 116, block; 116, 117; 117, raise_statement; 117, 118; 118, call; 118, 119; 118, 120; 119, identifier:TypeError; 120, argument_list; 120, 121; 121, string:"Object not callable?"; 122, if_statement; 122, 123; 122, 130; 123, boolean_operator:and; 123, 124; 123, 125; 124, identifier:argnames; 125, comparison_operator:==; 125, 126; 125, 129; 126, subscript; 126, 127; 126, 128; 127, identifier:argnames; 128, integer:0; 129, string:'self'; 130, block; 130, 131; 131, delete_statement; 131, 132; 132, subscript; 132, 133; 132, 134; 133, identifier:argnames; 134, integer:0; 135, if_statement; 135, 136; 135, 139; 135, 150; 136, comparison_operator:is; 136, 137; 136, 138; 137, identifier:_defaults; 138, None; 139, block; 139, 140; 139, 144; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:_defaults; 143, list:[]; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:defaults; 147, call; 147, 148; 147, 149; 148, identifier:dict; 149, argument_list; 150, else_clause; 150, 151; 151, block; 151, 152; 151, 158; 151, 165; 151, 171; 151, 177; 151, 194; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:defaults; 155, call; 155, 156; 155, 157; 156, identifier:dict; 157, argument_list; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:_defaults; 161, call; 161, 162; 161, 163; 162, identifier:list; 163, argument_list; 163, 164; 164, identifier:_defaults; 165, expression_statement; 165, 166; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:_defaults; 169, identifier:reverse; 170, argument_list; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:argnames; 175, identifier:reverse; 176, argument_list; 177, for_statement; 177, 178; 177, 181; 177, 185; 178, pattern_list; 178, 179; 178, 180; 179, identifier:i; 180, identifier:default; 181, call; 181, 182; 181, 183; 182, identifier:enumerate; 183, argument_list; 183, 184; 184, identifier:_defaults; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 193; 188, subscript; 188, 189; 188, 190; 189, identifier:defaults; 190, subscript; 190, 191; 190, 192; 191, identifier:argnames; 192, identifier:i; 193, identifier:default; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:argnames; 198, identifier:reverse; 199, argument_list; 200, return_statement; 200, 201; 201, expression_list; 201, 202; 201, 203; 201, 204; 201, 208; 202, identifier:argnames; 203, identifier:defaults; 204, conditional_expression:if; 204, 205; 204, 206; 204, 207; 205, True; 206, identifier:varargs; 207, False; 208, conditional_expression:if; 208, 209; 208, 210; 208, 211; 209, True; 210, identifier:varkw; 211, False | def getargspec(obj):
argnames, varargs, varkw, _defaults = None, None, None, None
if inspect.isfunction(obj) or inspect.ismethod(obj):
argnames, varargs, varkw, _defaults = inspect.getargspec(obj)
elif inspect.isclass(obj):
if inspect.ismethoddescriptor(obj.__init__):
argnames, varargs, varkw, _defaults = [], False, False, None
else:
argnames, varargs, varkw, _defaults = inspect.getargspec(obj.__init__)
elif hasattr(obj, '__call__'):
argnames, varargs, varkw, _defaults = inspect.getargspec(obj.__call__)
else:
raise TypeError("Object not callable?")
if argnames and argnames[0] == 'self':
del argnames[0]
if _defaults is None:
_defaults = []
defaults = dict()
else:
defaults = dict()
_defaults = list(_defaults)
_defaults.reverse()
argnames.reverse()
for i, default in enumerate(_defaults):
defaults[argnames[i]] = default
argnames.reverse()
return argnames, defaults, True if varargs else False, True if varkw else False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_find_overlap; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:queries; 5, identifier:client; 6, identifier:find_method; 7, identifier:get_method; 8, identifier:overlap_function; 9, block; 9, 10; 9, 14; 9, 69; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:results; 13, list:[]; 14, for_statement; 14, 15; 14, 16; 14, 17; 15, identifier:query; 16, identifier:queries; 17, block; 17, 18; 17, 30; 17, 44; 17, 62; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:candidates; 21, await; 21, 22; 22, call; 22, 23; 22, 28; 23, call; 23, 24; 23, 25; 24, identifier:getattr; 25, argument_list; 25, 26; 25, 27; 26, identifier:client; 27, identifier:find_method; 28, argument_list; 28, 29; 29, identifier:query; 30, if_statement; 30, 31; 30, 33; 31, not_operator; 31, 32; 32, identifier:candidates; 33, block; 33, 34; 34, raise_statement; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:ValueError; 37, argument_list; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, string:'no result found for {!r}'; 41, identifier:format; 42, argument_list; 42, 43; 43, identifier:query; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:result; 47, await; 47, 48; 48, call; 48, 49; 48, 54; 49, call; 49, 50; 49, 51; 50, identifier:getattr; 51, argument_list; 51, 52; 51, 53; 52, identifier:client; 53, identifier:get_method; 54, argument_list; 54, 55; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:id_; 57, attribute; 57, 58; 57, 61; 58, subscript; 58, 59; 58, 60; 59, identifier:candidates; 60, integer:0; 61, identifier:id_; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:results; 66, identifier:append; 67, argument_list; 67, 68; 68, identifier:result; 69, return_statement; 69, 70; 70, await; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:overlap_function; 73, argument_list; 73, 74; 73, 75; 74, identifier:results; 75, identifier:client | async def _find_overlap(queries, client, find_method, get_method,
overlap_function):
results = []
for query in queries:
candidates = await getattr(client, find_method)(query)
if not candidates:
raise ValueError('no result found for {!r}'.format(query))
result = await getattr(client, get_method)(id_=candidates[0].id_)
results.append(result)
return await overlap_function(results, client) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:power; 3, parameters; 3, 4; 4, identifier:set_; 5, block; 5, 6; 5, 11; 5, 35; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:ensure_countable; 9, argument_list; 9, 10; 10, identifier:set_; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:result; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:chain; 17, identifier:from_iterable; 18, generator_expression; 18, 19; 18, 24; 19, call; 19, 20; 19, 21; 20, identifier:combinations; 21, argument_list; 21, 22; 21, 23; 22, identifier:set_; 23, identifier:r; 24, for_in_clause; 24, 25; 24, 26; 25, identifier:r; 26, call; 26, 27; 26, 28; 27, identifier:xrange; 28, argument_list; 28, 29; 29, binary_operator:+; 29, 30; 29, 34; 30, call; 30, 31; 30, 32; 31, identifier:len; 32, argument_list; 32, 33; 33, identifier:set_; 34, integer:1; 35, return_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:_harmonize_subset_types; 38, argument_list; 38, 39; 38, 40; 39, identifier:set_; 40, identifier:result | def power(set_):
ensure_countable(set_)
result = chain.from_iterable(combinations(set_, r)
for r in xrange(len(set_) + 1))
return _harmonize_subset_types(set_, result) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:generate_pws_in_order; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:n; 6, default_parameter; 6, 7; 6, 8; 7, identifier:filter_func; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:N_max; 11, float:1e6; 12, block; 12, 13; 12, 23; 12, 32; 12, 36; 12, 42; 12, 48; 12, 286; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:states; 16, list:[(-1.0, helper.START)]; 16, 17; 17, tuple; 17, 18; 17, 20; 18, unary_operator:-; 18, 19; 19, float:1.0; 20, attribute; 20, 21; 20, 22; 21, identifier:helper; 22, identifier:START; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:p_min; 26, binary_operator:/; 26, 27; 26, 28; 27, float:1e-9; 28, parenthesized_expression; 28, 29; 29, binary_operator:**; 29, 30; 29, 31; 30, identifier:n; 31, integer:2; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:ret; 35, list:[]; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:done; 39, call; 39, 40; 39, 41; 40, identifier:set; 41, argument_list; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:already_added_in_heap; 45, call; 45, 46; 45, 47; 46, identifier:set; 47, argument_list; 48, while_statement; 48, 49; 48, 62; 49, boolean_operator:and; 49, 50; 49, 56; 50, comparison_operator:<; 50, 51; 50, 55; 51, call; 51, 52; 51, 53; 52, identifier:len; 53, argument_list; 53, 54; 54, identifier:ret; 55, identifier:n; 56, comparison_operator:>; 56, 57; 56, 61; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, identifier:states; 61, integer:0; 62, block; 62, 63; 62, 74; 62, 84; 62, 90; 62, 104; 62, 214; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, pattern_list; 65, 66; 65, 67; 66, identifier:p; 67, identifier:s; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:heapq; 71, identifier:heappop; 72, argument_list; 72, 73; 73, identifier:states; 74, if_statement; 74, 75; 74, 78; 75, comparison_operator:<; 75, 76; 75, 77; 76, identifier:p; 77, integer:0; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:p; 82, unary_operator:-; 82, 83; 83, identifier:p; 84, if_statement; 84, 85; 84, 88; 85, comparison_operator:in; 85, 86; 85, 87; 86, identifier:s; 87, identifier:done; 88, block; 88, 89; 89, continue_statement; 90, assert_statement; 90, 91; 90, 98; 91, comparison_operator:==; 91, 92; 91, 95; 92, subscript; 92, 93; 92, 94; 93, identifier:s; 94, integer:0; 95, attribute; 95, 96; 95, 97; 96, identifier:helper; 97, identifier:START; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, string:"Broken s: {!r}"; 101, identifier:format; 102, argument_list; 102, 103; 103, identifier:s; 104, if_statement; 104, 105; 104, 113; 104, 150; 105, comparison_operator:==; 105, 106; 105, 110; 106, subscript; 106, 107; 106, 108; 107, identifier:s; 108, unary_operator:-; 108, 109; 109, integer:1; 110, attribute; 110, 111; 110, 112; 111, identifier:helper; 112, identifier:END; 113, block; 113, 114; 113, 121; 113, 131; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:done; 118, identifier:add; 119, argument_list; 119, 120; 120, identifier:s; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:clean_s; 124, subscript; 124, 125; 124, 126; 125, identifier:s; 126, slice; 126, 127; 126, 128; 126, 129; 127, integer:1; 128, colon; 129, unary_operator:-; 129, 130; 130, integer:1; 131, if_statement; 131, 132; 131, 140; 132, boolean_operator:or; 132, 133; 132, 136; 133, comparison_operator:is; 133, 134; 133, 135; 134, identifier:filter_func; 135, None; 136, call; 136, 137; 136, 138; 137, identifier:filter_func; 138, argument_list; 138, 139; 139, identifier:clean_s; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:ret; 145, identifier:append; 146, argument_list; 146, 147; 147, tuple; 147, 148; 147, 149; 148, identifier:clean_s; 149, identifier:p; 150, else_clause; 150, 151; 151, block; 151, 152; 152, for_statement; 152, 153; 152, 156; 152, 166; 153, pattern_list; 153, 154; 153, 155; 154, identifier:c; 155, identifier:f; 156, call; 156, 157; 156, 165; 157, attribute; 157, 158; 157, 164; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:_get_next; 162, argument_list; 162, 163; 163, identifier:s; 164, identifier:items; 165, argument_list; 166, block; 166, 167; 166, 190; 166, 199; 167, if_statement; 167, 168; 167, 188; 168, parenthesized_expression; 168, 169; 169, boolean_operator:or; 169, 170; 169, 182; 170, boolean_operator:or; 170, 171; 170, 176; 171, comparison_operator:<; 171, 172; 171, 175; 172, binary_operator:*; 172, 173; 172, 174; 173, identifier:f; 174, identifier:p; 175, identifier:p_min; 176, comparison_operator:in; 176, 177; 176, 181; 177, parenthesized_expression; 177, 178; 178, binary_operator:+; 178, 179; 178, 180; 179, identifier:s; 180, identifier:c; 181, identifier:done; 182, comparison_operator:in; 182, 183; 182, 187; 183, parenthesized_expression; 183, 184; 184, binary_operator:+; 184, 185; 184, 186; 185, identifier:s; 186, identifier:c; 187, identifier:already_added_in_heap; 188, block; 188, 189; 189, continue_statement; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:already_added_in_heap; 194, identifier:add; 195, argument_list; 195, 196; 196, binary_operator:+; 196, 197; 196, 198; 197, identifier:s; 198, identifier:c; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:heapq; 203, identifier:heappush; 204, argument_list; 204, 205; 204, 206; 205, identifier:states; 206, tuple; 206, 207; 206, 211; 207, binary_operator:*; 207, 208; 207, 210; 208, unary_operator:-; 208, 209; 209, identifier:f; 210, identifier:p; 211, binary_operator:+; 211, 212; 211, 213; 212, identifier:s; 213, identifier:c; 214, if_statement; 214, 215; 214, 225; 215, comparison_operator:>; 215, 216; 215, 220; 216, call; 216, 217; 216, 218; 217, identifier:len; 218, argument_list; 218, 219; 219, identifier:states; 220, binary_operator:/; 220, 221; 220, 224; 221, binary_operator:*; 221, 222; 221, 223; 222, identifier:N_max; 223, integer:3; 224, integer:2; 225, block; 225, 226; 225, 245; 225, 264; 225, 281; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 229; 228, identifier:print; 229, argument_list; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, string:"Heap size: {}. ret={}. (expected: {}) s={!r}"; 233, identifier:format; 234, argument_list; 234, 235; 234, 239; 234, 243; 234, 244; 235, call; 235, 236; 235, 237; 236, identifier:len; 237, argument_list; 237, 238; 238, identifier:states; 239, call; 239, 240; 239, 241; 240, identifier:len; 241, argument_list; 241, 242; 242, identifier:ret; 243, identifier:n; 244, identifier:s; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 248; 247, identifier:print; 248, argument_list; 248, 249; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, string:"The size of states={}. Still need={} pws. Truncating"; 252, identifier:format; 253, argument_list; 253, 254; 253, 258; 254, call; 254, 255; 254, 256; 255, identifier:len; 256, argument_list; 256, 257; 257, identifier:states; 258, binary_operator:-; 258, 259; 258, 260; 259, identifier:n; 260, call; 260, 261; 260, 262; 261, identifier:len; 262, argument_list; 262, 263; 263, identifier:ret; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:states; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:heapq; 270, identifier:nsmallest; 271, argument_list; 271, 272; 271, 280; 272, call; 272, 273; 272, 274; 273, identifier:int; 274, argument_list; 274, 275; 275, binary_operator:/; 275, 276; 275, 279; 276, binary_operator:*; 276, 277; 276, 278; 277, identifier:N_max; 278, integer:3; 279, integer:4; 280, identifier:states; 281, expression_statement; 281, 282; 282, call; 282, 283; 282, 284; 283, identifier:print; 284, argument_list; 284, 285; 285, string:"Done"; 286, return_statement; 286, 287; 287, identifier:ret | def generate_pws_in_order(self, n, filter_func=None, N_max=1e6):
states = [(-1.0, helper.START)]
p_min = 1e-9 / (n**2)
ret = []
done = set()
already_added_in_heap = set()
while len(ret) < n and len(states) > 0:
p, s = heapq.heappop(states)
if p < 0:
p = -p
if s in done: continue
assert s[0] == helper.START, "Broken s: {!r}".format(s)
if s[-1] == helper.END:
done.add(s)
clean_s = s[1:-1]
if filter_func is None or filter_func(clean_s):
ret.append((clean_s, p))
else:
for c, f in self._get_next(s).items():
if (f*p < p_min or (s+c) in done or
(s+c) in already_added_in_heap):
continue
already_added_in_heap.add(s+c)
heapq.heappush(states, (-f*p, s+c))
if len(states) > N_max * 3 / 2:
print("Heap size: {}. ret={}. (expected: {}) s={!r}"
.format(len(states), len(ret), n, s))
print("The size of states={}. Still need={} pws. Truncating"
.format(len(states), n - len(ret)))
states = heapq.nsmallest(int(N_max * 3/4), states)
print("Done")
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:expand_seed; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:start_seed; 6, identifier:num_iterations; 7, identifier:val; 8, block; 8, 9; 8, 24; 8, 34; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:grd; 15, identifier:set_tile; 16, argument_list; 16, 17; 16, 20; 16, 23; 17, subscript; 17, 18; 17, 19; 18, identifier:start_seed; 19, integer:0; 20, subscript; 20, 21; 20, 22; 21, identifier:start_seed; 22, integer:1; 23, identifier:val; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:cur_pos; 27, list:[start_seed[0], start_seed[1]]; 27, 28; 27, 31; 28, subscript; 28, 29; 28, 30; 29, identifier:start_seed; 30, integer:0; 31, subscript; 31, 32; 31, 33; 32, identifier:start_seed; 33, integer:1; 34, while_statement; 34, 35; 34, 38; 35, comparison_operator:>; 35, 36; 35, 37; 36, identifier:num_iterations; 37, integer:0; 38, block; 38, 39; 38, 43; 38, 144; 38, 158; 38, 172; 38, 187; 38, 202; 38, 217; 38, 232; 39, expression_statement; 39, 40; 40, augmented_assignment:-=; 40, 41; 40, 42; 41, identifier:num_iterations; 42, integer:1; 43, for_statement; 43, 44; 43, 45; 43, 66; 44, identifier:y; 45, call; 45, 46; 45, 47; 46, identifier:range; 47, argument_list; 47, 48; 47, 57; 48, binary_operator:-; 48, 49; 48, 52; 49, subscript; 49, 50; 49, 51; 50, identifier:cur_pos; 51, integer:0; 52, call; 52, 53; 52, 54; 53, identifier:randint; 54, argument_list; 54, 55; 54, 56; 55, integer:0; 56, integer:2; 57, binary_operator:+; 57, 58; 57, 61; 58, subscript; 58, 59; 58, 60; 59, identifier:cur_pos; 60, integer:0; 61, call; 61, 62; 61, 63; 62, identifier:randint; 63, argument_list; 63, 64; 63, 65; 64, integer:0; 65, integer:2; 66, block; 66, 67; 67, for_statement; 67, 68; 67, 69; 67, 90; 68, identifier:x; 69, call; 69, 70; 69, 71; 70, identifier:range; 71, argument_list; 71, 72; 71, 81; 72, binary_operator:-; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:cur_pos; 75, integer:1; 76, call; 76, 77; 76, 78; 77, identifier:randint; 78, argument_list; 78, 79; 78, 80; 79, integer:0; 80, integer:2; 81, binary_operator:+; 81, 82; 81, 85; 82, subscript; 82, 83; 82, 84; 83, identifier:cur_pos; 84, integer:1; 85, call; 85, 86; 85, 87; 86, identifier:randint; 87, argument_list; 87, 88; 87, 89; 88, integer:0; 89, integer:2; 90, block; 90, 91; 91, if_statement; 91, 92; 91, 115; 92, boolean_operator:and; 92, 93; 92, 108; 93, boolean_operator:and; 93, 94; 93, 105; 94, boolean_operator:and; 94, 95; 94, 102; 95, comparison_operator:<; 95, 96; 95, 97; 96, identifier:x; 97, attribute; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:grd; 101, identifier:grid_width; 102, comparison_operator:>=; 102, 103; 102, 104; 103, identifier:x; 104, integer:0; 105, comparison_operator:>=; 105, 106; 105, 107; 106, identifier:y; 107, integer:0; 108, comparison_operator:<; 108, 109; 108, 110; 109, identifier:y; 110, attribute; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:grd; 114, identifier:grid_height; 115, block; 115, 116; 116, if_statement; 116, 117; 116, 128; 117, comparison_operator:!=; 117, 118; 117, 127; 118, call; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:grd; 123, identifier:get_tile; 124, argument_list; 124, 125; 124, 126; 125, identifier:y; 126, identifier:x; 127, identifier:val; 128, block; 128, 129; 128, 140; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 136; 131, attribute; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:grd; 135, identifier:set_tile; 136, argument_list; 136, 137; 136, 138; 136, 139; 137, identifier:y; 138, identifier:x; 139, identifier:TERRAIN_LAND; 140, expression_statement; 140, 141; 141, augmented_assignment:-=; 141, 142; 141, 143; 142, identifier:num_iterations; 143, integer:1; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:new_x; 147, binary_operator:-; 147, 148; 147, 157; 148, binary_operator:+; 148, 149; 148, 152; 149, subscript; 149, 150; 149, 151; 150, identifier:cur_pos; 151, integer:0; 152, call; 152, 153; 152, 154; 153, identifier:randint; 154, argument_list; 154, 155; 154, 156; 155, integer:0; 156, integer:3; 157, integer:2; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:new_y; 161, binary_operator:-; 161, 162; 161, 171; 162, binary_operator:+; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:cur_pos; 165, integer:1; 166, call; 166, 167; 166, 168; 167, identifier:randint; 168, argument_list; 168, 169; 168, 170; 169, integer:0; 170, integer:3; 171, integer:2; 172, if_statement; 172, 173; 172, 182; 173, comparison_operator:>; 173, 174; 173, 175; 174, identifier:new_x; 175, binary_operator:-; 175, 176; 175, 181; 176, attribute; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:self; 179, identifier:grd; 180, identifier:grid_width; 181, integer:1; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:new_x; 186, integer:0; 187, if_statement; 187, 188; 187, 197; 188, comparison_operator:>; 188, 189; 188, 190; 189, identifier:new_y; 190, binary_operator:-; 190, 191; 190, 196; 191, attribute; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:self; 194, identifier:grd; 195, identifier:grid_height; 196, integer:1; 197, block; 197, 198; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:new_y; 201, integer:0; 202, if_statement; 202, 203; 202, 206; 203, comparison_operator:<; 203, 204; 203, 205; 204, identifier:new_x; 205, integer:0; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:new_x; 210, binary_operator:-; 210, 211; 210, 216; 211, attribute; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:self; 214, identifier:grd; 215, identifier:grid_width; 216, integer:1; 217, if_statement; 217, 218; 217, 221; 218, comparison_operator:<; 218, 219; 218, 220; 219, identifier:new_y; 220, integer:0; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:new_y; 225, binary_operator:-; 225, 226; 225, 231; 226, attribute; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:self; 229, identifier:grd; 230, identifier:grid_height; 231, integer:1; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:cur_pos; 235, list:[new_y, new_x]; 235, 236; 235, 237; 236, identifier:new_y; 237, identifier:new_x | def expand_seed(self, start_seed, num_iterations, val):
self.grd.set_tile(start_seed[0], start_seed[1], val)
cur_pos = [start_seed[0], start_seed[1]]
while num_iterations > 0:
num_iterations -= 1
for y in range(cur_pos[0]-randint(0,2), cur_pos[0] + randint(0,2)):
for x in range(cur_pos[1]-randint(0,2), cur_pos[1] + randint(0,2)):
if x < self.grd.grid_width and x >= 0 and y >= 0 and y < self.grd.grid_height:
if self.grd.get_tile(y,x) != val:
self.grd.set_tile(y, x, TERRAIN_LAND)
num_iterations -= 1
new_x = cur_pos[0] + randint(0,3)-2
new_y = cur_pos[1] + randint(0,3)-2
if new_x > self.grd.grid_width - 1:
new_x = 0
if new_y > self.grd.grid_height - 1:
new_y = 0
if new_x < 0:
new_x = self.grd.grid_width - 1
if new_y < 0:
new_y = self.grd.grid_height - 1
cur_pos = [new_y, new_x] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:denoise_grid; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:val; 6, default_parameter; 6, 7; 6, 8; 7, identifier:expand; 8, integer:1; 9, block; 9, 10; 9, 46; 9, 240; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:updated_grid; 13, list_comprehension; 13, 14; 13, 35; 13, 36; 14, list_comprehension; 14, 15; 14, 24; 14, 25; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:grd; 20, identifier:get_tile; 21, argument_list; 21, 22; 21, 23; 22, identifier:y; 23, identifier:x; 24, line_continuation:\; 25, for_in_clause; 25, 26; 25, 27; 26, identifier:x; 27, call; 27, 28; 27, 29; 28, identifier:range; 29, argument_list; 29, 30; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:grd; 34, identifier:grid_width; 35, line_continuation:\; 36, for_in_clause; 36, 37; 36, 38; 37, identifier:y; 38, call; 38, 39; 38, 40; 39, identifier:range; 40, argument_list; 40, 41; 41, attribute; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:grd; 45, identifier:grid_height; 46, for_statement; 46, 47; 46, 48; 46, 60; 47, identifier:row; 48, call; 48, 49; 48, 50; 49, identifier:range; 50, argument_list; 50, 51; 51, binary_operator:-; 51, 52; 51, 59; 52, call; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:grd; 57, identifier:get_grid_height; 58, argument_list; 59, identifier:expand; 60, block; 60, 61; 61, for_statement; 61, 62; 61, 63; 61, 75; 62, identifier:col; 63, call; 63, 64; 63, 65; 64, identifier:range; 65, argument_list; 65, 66; 66, binary_operator:-; 66, 67; 66, 74; 67, call; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:grd; 72, identifier:get_grid_width; 73, argument_list; 74, identifier:expand; 75, block; 75, 76; 75, 92; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 83; 78, subscript; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:updated_grid; 81, identifier:row; 82, identifier:col; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:grd; 88, identifier:get_tile; 89, argument_list; 89, 90; 89, 91; 90, identifier:row; 91, identifier:col; 92, if_statement; 92, 93; 92, 104; 93, comparison_operator:==; 93, 94; 93, 103; 94, call; 94, 95; 94, 100; 95, attribute; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:grd; 99, identifier:get_tile; 100, argument_list; 100, 101; 100, 102; 101, identifier:row; 102, identifier:col; 103, identifier:val; 104, block; 104, 105; 105, for_statement; 105, 106; 105, 107; 105, 113; 106, identifier:y; 107, call; 107, 108; 107, 109; 108, identifier:range; 109, argument_list; 109, 110; 109, 112; 110, unary_operator:-; 110, 111; 111, identifier:expand; 112, identifier:expand; 113, block; 113, 114; 114, for_statement; 114, 115; 114, 116; 114, 122; 115, identifier:x; 116, call; 116, 117; 116, 118; 117, identifier:range; 118, argument_list; 118, 119; 118, 121; 119, unary_operator:-; 119, 120; 120, identifier:expand; 121, identifier:expand; 122, block; 122, 123; 122, 129; 122, 135; 122, 144; 122, 153; 122, 178; 122, 203; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:new_x; 126, binary_operator:+; 126, 127; 126, 128; 127, identifier:col; 128, identifier:x; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:new_y; 132, binary_operator:+; 132, 133; 132, 134; 133, identifier:row; 134, identifier:y; 135, if_statement; 135, 136; 135, 139; 136, comparison_operator:<; 136, 137; 136, 138; 137, identifier:new_x; 138, integer:0; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:new_x; 143, integer:0; 144, if_statement; 144, 145; 144, 148; 145, comparison_operator:<; 145, 146; 145, 147; 146, identifier:new_y; 147, integer:0; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:new_y; 152, integer:0; 153, if_statement; 153, 154; 153, 165; 154, comparison_operator:>; 154, 155; 154, 156; 155, identifier:new_x; 156, binary_operator:-; 156, 157; 156, 164; 157, call; 157, 158; 157, 163; 158, attribute; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:grd; 162, identifier:get_grid_width; 163, argument_list; 164, integer:1; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:new_x; 169, binary_operator:-; 169, 170; 169, 177; 170, call; 170, 171; 170, 176; 171, attribute; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:self; 174, identifier:grd; 175, identifier:get_grid_width; 176, argument_list; 177, integer:1; 178, if_statement; 178, 179; 178, 190; 179, comparison_operator:>; 179, 180; 179, 181; 180, identifier:new_y; 181, binary_operator:-; 181, 182; 181, 189; 182, call; 182, 183; 182, 188; 183, attribute; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:self; 186, identifier:grd; 187, identifier:get_grid_height; 188, argument_list; 189, integer:1; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:new_y; 194, binary_operator:-; 194, 195; 194, 202; 195, call; 195, 196; 195, 201; 196, attribute; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:self; 199, identifier:grd; 200, identifier:get_grid_height; 201, argument_list; 202, integer:1; 203, if_statement; 203, 204; 203, 207; 203, 230; 204, comparison_operator:>; 204, 205; 204, 206; 205, identifier:expand; 206, integer:0; 207, block; 207, 208; 208, if_statement; 208, 209; 208, 221; 209, comparison_operator:>; 209, 210; 209, 217; 210, call; 210, 211; 210, 212; 211, identifier:randint; 212, argument_list; 212, 213; 212, 214; 213, integer:1; 214, binary_operator:*; 214, 215; 214, 216; 215, identifier:expand; 216, integer:2; 217, parenthesized_expression; 217, 218; 218, binary_operator:+; 218, 219; 218, 220; 219, identifier:expand; 220, integer:1; 221, block; 221, 222; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 229; 224, subscript; 224, 225; 224, 228; 225, subscript; 225, 226; 225, 227; 226, identifier:updated_grid; 227, identifier:new_y; 228, identifier:new_x; 229, identifier:val; 230, else_clause; 230, 231; 231, block; 231, 232; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 239; 234, subscript; 234, 235; 234, 238; 235, subscript; 235, 236; 235, 237; 236, identifier:updated_grid; 237, identifier:new_y; 238, identifier:new_x; 239, identifier:val; 240, expression_statement; 240, 241; 241, call; 241, 242; 241, 247; 242, attribute; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:grd; 246, identifier:replace_grid; 247, argument_list; 247, 248; 248, identifier:updated_grid | def denoise_grid(self, val, expand=1):
updated_grid = [[self.grd.get_tile(y,x) \
for x in range(self.grd.grid_width)] \
for y in range(self.grd.grid_height)]
for row in range(self.grd.get_grid_height() - expand):
for col in range(self.grd.get_grid_width() - expand):
updated_grid[row][col] = self.grd.get_tile(row,col)
if self.grd.get_tile(row,col) == val:
for y in range(-expand, expand):
for x in range(-expand, expand):
new_x = col+x
new_y = row+y
if new_x < 0: new_x = 0
if new_y < 0: new_y = 0
if new_x > self.grd.get_grid_width() - 1: new_x = self.grd.get_grid_width() - 1
if new_y > self.grd.get_grid_height() - 1: new_y = self.grd.get_grid_height() - 1
if expand > 0:
if randint(1,expand * 2) > (expand+1):
updated_grid[new_y][new_x] = val
else:
updated_grid[new_y][new_x] = val
self.grd.replace_grid(updated_grid) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:run; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:num_runs; 6, identifier:show_trails; 7, identifier:log_file_base; 8, block; 8, 9; 8, 14; 8, 33; 8, 58; 8, 78; 8, 84; 8, 131; 8, 268; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 12; 11, identifier:print; 12, argument_list; 12, 13; 13, string:"--------------------------------------------------"; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:print; 17, argument_list; 17, 18; 17, 19; 17, 26; 18, string:"Starting Simulation - target = "; 19, attribute; 19, 20; 19, 25; 20, subscript; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:agent_list; 24, integer:0; 25, identifier:target_y; 26, attribute; 26, 27; 26, 32; 27, subscript; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:agent_list; 31, integer:0; 32, identifier:target_x; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 42; 35, attribute; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:world; 40, identifier:grd; 41, identifier:set_tile; 42, argument_list; 42, 43; 42, 50; 42, 57; 43, attribute; 43, 44; 43, 49; 44, subscript; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:agent_list; 48, integer:0; 49, identifier:target_y; 50, attribute; 50, 51; 50, 56; 51, subscript; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:agent_list; 55, integer:0; 56, identifier:target_x; 57, string:'T'; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:highlight_cell_surroundings; 63, argument_list; 63, 64; 63, 71; 64, attribute; 64, 65; 64, 70; 65, subscript; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:agent_list; 69, integer:0; 70, identifier:target_y; 71, attribute; 71, 72; 71, 77; 72, subscript; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:agent_list; 76, integer:0; 77, identifier:target_x; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:start_all_agents; 83, argument_list; 84, try_statement; 84, 85; 84, 121; 85, block; 85, 86; 86, with_statement; 86, 87; 86, 99; 87, with_clause; 87, 88; 88, with_item; 88, 89; 89, as_pattern; 89, 90; 89, 97; 90, call; 90, 91; 90, 92; 91, identifier:open; 92, argument_list; 92, 93; 92, 96; 93, binary_operator:+; 93, 94; 93, 95; 94, identifier:log_file_base; 95, string:'__agents.txt'; 96, string:"w"; 97, as_pattern_target; 97, 98; 98, identifier:f; 99, block; 99, 100; 99, 107; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:f; 104, identifier:write; 105, argument_list; 105, 106; 106, string:"Starting World = \n"; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:f; 111, identifier:write; 112, argument_list; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:str; 115, argument_list; 115, 116; 116, attribute; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:world; 120, identifier:grd; 121, except_clause; 121, 122; 121, 123; 122, identifier:Exception; 123, block; 123, 124; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 127; 126, identifier:print; 127, argument_list; 127, 128; 128, binary_operator:+; 128, 129; 128, 130; 129, string:'Cant save log results to '; 130, identifier:log_file_base; 131, for_statement; 131, 132; 131, 133; 131, 138; 132, identifier:cur_run; 133, call; 133, 134; 133, 135; 134, identifier:range; 135, argument_list; 135, 136; 135, 137; 136, integer:0; 137, identifier:num_runs; 138, block; 138, 139; 138, 146; 138, 243; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 140, 144; 141, identifier:print; 142, ERROR; 142, 143; 143, identifier:WorldSimulation; 144, type; 144, 145; 145, identifier:run; 146, for_statement; 146, 147; 146, 150; 146, 156; 147, pattern_list; 147, 148; 147, 149; 148, identifier:num; 149, identifier:agt; 150, call; 150, 151; 150, 152; 151, identifier:enumerate; 152, argument_list; 152, 153; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:agent_list; 156, block; 156, 157; 156, 220; 156, 226; 157, if_statement; 157, 158; 157, 161; 158, comparison_operator:==; 158, 159; 158, 160; 159, identifier:show_trails; 160, string:'Y'; 161, block; 161, 162; 162, if_statement; 162, 163; 162, 180; 162, 198; 163, boolean_operator:or; 163, 164; 163, 172; 164, comparison_operator:==; 164, 165; 164, 171; 165, call; 165, 166; 165, 167; 166, identifier:len; 167, argument_list; 167, 168; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:agent_list; 171, integer:1; 172, comparison_operator:>; 172, 173; 172, 179; 173, call; 173, 174; 173, 175; 174, identifier:len; 175, argument_list; 175, 176; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:agent_list; 179, integer:9; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 190; 183, attribute; 183, 184; 183, 189; 184, attribute; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:world; 188, identifier:grd; 189, identifier:set_tile; 190, argument_list; 190, 191; 190, 194; 190, 197; 191, attribute; 191, 192; 191, 193; 192, identifier:agt; 193, identifier:current_y; 194, attribute; 194, 195; 194, 196; 195, identifier:agt; 196, identifier:current_x; 197, string:'o'; 198, else_clause; 198, 199; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 209; 202, attribute; 202, 203; 202, 208; 203, attribute; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:self; 206, identifier:world; 207, identifier:grd; 208, identifier:set_tile; 209, argument_list; 209, 210; 209, 213; 209, 216; 210, attribute; 210, 211; 210, 212; 211, identifier:agt; 212, identifier:current_y; 213, attribute; 213, 214; 213, 215; 214, identifier:agt; 215, identifier:current_x; 216, call; 216, 217; 216, 218; 217, identifier:str; 218, argument_list; 218, 219; 219, identifier:num; 220, expression_statement; 220, 221; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:agt; 224, identifier:do_your_job; 225, argument_list; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 235; 228, attribute; 228, 229; 228, 234; 229, attribute; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:self; 232, identifier:world; 233, identifier:grd; 234, identifier:set_tile; 235, argument_list; 235, 236; 235, 239; 235, 242; 236, attribute; 236, 237; 236, 238; 237, identifier:agt; 238, identifier:current_y; 239, attribute; 239, 240; 239, 241; 240, identifier:agt; 241, identifier:current_x; 242, string:'A'; 243, if_statement; 243, 244; 243, 247; 244, comparison_operator:!=; 244, 245; 244, 246; 245, identifier:log_file_base; 246, string:'N'; 247, block; 247, 248; 248, expression_statement; 248, 249; 249, call; 249, 250; 249, 257; 250, attribute; 250, 251; 250, 256; 251, attribute; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:self; 254, identifier:world; 255, identifier:grd; 256, identifier:save; 257, argument_list; 257, 258; 258, binary_operator:+; 258, 259; 258, 267; 259, binary_operator:+; 259, 260; 259, 263; 260, binary_operator:+; 260, 261; 260, 262; 261, identifier:log_file_base; 262, string:'_'; 263, call; 263, 264; 263, 265; 264, identifier:str; 265, argument_list; 265, 266; 266, identifier:cur_run; 267, string:'.log'; 268, with_statement; 268, 269; 268, 281; 269, with_clause; 269, 270; 270, with_item; 270, 271; 271, as_pattern; 271, 272; 271, 279; 272, call; 272, 273; 272, 274; 273, identifier:open; 274, argument_list; 274, 275; 274, 278; 275, binary_operator:+; 275, 276; 275, 277; 276, identifier:log_file_base; 277, string:'__agents.txt'; 278, string:"a"; 279, as_pattern_target; 279, 280; 280, identifier:f; 281, block; 281, 282; 281, 315; 281, 329; 281, 336; 282, expression_statement; 282, 283; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:f; 286, identifier:write; 287, argument_list; 287, 288; 288, binary_operator:+; 288, 289; 288, 314; 289, binary_operator:+; 289, 290; 289, 304; 290, binary_operator:+; 290, 291; 290, 303; 291, binary_operator:+; 291, 292; 291, 293; 292, string:"\nWorld tgt= ["; 293, call; 293, 294; 293, 295; 294, identifier:str; 295, argument_list; 295, 296; 296, attribute; 296, 297; 296, 302; 297, subscript; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:self; 300, identifier:agent_list; 301, integer:0; 302, identifier:target_y; 303, string:","; 304, call; 304, 305; 304, 306; 305, identifier:str; 306, argument_list; 306, 307; 307, attribute; 307, 308; 307, 313; 308, subscript; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:self; 311, identifier:agent_list; 312, integer:0; 313, identifier:target_x; 314, string:"]\n"; 315, expression_statement; 315, 316; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:f; 319, identifier:write; 320, argument_list; 320, 321; 321, call; 321, 322; 321, 323; 322, identifier:str; 323, argument_list; 323, 324; 324, attribute; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:self; 327, identifier:world; 328, identifier:grd; 329, expression_statement; 329, 330; 330, call; 330, 331; 330, 334; 331, attribute; 331, 332; 331, 333; 332, identifier:f; 333, identifier:write; 334, argument_list; 334, 335; 335, string:'\n\nAgent Name , starting, num Steps , num Climbs\n'; 336, for_statement; 336, 337; 336, 340; 336, 346; 337, pattern_list; 337, 338; 337, 339; 338, identifier:num; 339, identifier:agt; 340, call; 340, 341; 340, 342; 341, identifier:enumerate; 342, argument_list; 342, 343; 343, attribute; 343, 344; 343, 345; 344, identifier:self; 345, identifier:agent_list; 346, block; 346, 347; 346, 373; 346, 393; 346, 408; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 350; 349, identifier:res; 350, binary_operator:+; 350, 351; 350, 372; 351, binary_operator:+; 351, 352; 351, 366; 352, binary_operator:+; 352, 353; 352, 365; 353, binary_operator:+; 353, 354; 353, 359; 354, binary_operator:+; 354, 355; 354, 358; 355, attribute; 355, 356; 355, 357; 356, identifier:agt; 357, identifier:name; 358, string:' , ['; 359, call; 359, 360; 359, 361; 360, identifier:str; 361, argument_list; 361, 362; 362, attribute; 362, 363; 362, 364; 363, identifier:agt; 364, identifier:start_y; 365, string:', '; 366, call; 366, 367; 366, 368; 367, identifier:str; 368, argument_list; 368, 369; 369, attribute; 369, 370; 369, 371; 370, identifier:agt; 371, identifier:start_x; 372, string:'], '; 373, expression_statement; 373, 374; 374, augmented_assignment:+=; 374, 375; 374, 376; 375, identifier:res; 376, binary_operator:+; 376, 377; 376, 392; 377, binary_operator:+; 377, 378; 377, 386; 378, binary_operator:+; 378, 379; 378, 385; 379, call; 379, 380; 379, 381; 380, identifier:str; 381, argument_list; 381, 382; 382, attribute; 382, 383; 382, 384; 383, identifier:agt; 384, identifier:num_steps; 385, string:' , '; 386, call; 386, 387; 386, 388; 387, identifier:str; 388, argument_list; 388, 389; 389, attribute; 389, 390; 389, 391; 390, identifier:agt; 391, identifier:num_climbs; 392, string:' , '; 393, expression_statement; 393, 394; 394, augmented_assignment:+=; 394, 395; 394, 396; 395, identifier:res; 396, call; 396, 397; 396, 400; 397, attribute; 397, 398; 397, 399; 398, string:''; 399, identifier:join; 400, argument_list; 400, 401; 401, list_comprehension; 401, 402; 401, 403; 402, identifier:a; 403, for_in_clause; 403, 404; 403, 405; 404, identifier:a; 405, attribute; 405, 406; 405, 407; 406, identifier:agt; 407, identifier:results; 408, expression_statement; 408, 409; 409, call; 409, 410; 409, 413; 410, attribute; 410, 411; 410, 412; 411, identifier:f; 412, identifier:write; 413, argument_list; 413, 414; 414, binary_operator:+; 414, 415; 414, 416; 415, identifier:res; 416, string:'\n' | def run(self, num_runs, show_trails, log_file_base):
print("--------------------------------------------------")
print("Starting Simulation - target = ", self.agent_list[0].target_y, self.agent_list[0].target_x)
self.world.grd.set_tile(self.agent_list[0].target_y , self.agent_list[0].target_x , 'T')
self.highlight_cell_surroundings(self.agent_list[0].target_y, self.agent_list[0].target_x)
self.start_all_agents()
try:
with open (log_file_base + '__agents.txt', "w") as f:
f.write("Starting World = \n")
f.write(str(self.world.grd))
except Exception:
print('Cant save log results to ' + log_file_base)
for cur_run in range(0,num_runs):
print("WorldSimulation:run
for num, agt in enumerate(self.agent_list):
if show_trails == 'Y':
if len(self.agent_list) == 1 or len(self.agent_list) > 9:
self.world.grd.set_tile(agt.current_y, agt.current_x, 'o')
else:
self.world.grd.set_tile(agt.current_y, agt.current_x, str(num))
agt.do_your_job()
self.world.grd.set_tile(agt.current_y, agt.current_x, 'A')
if log_file_base != 'N':
self.world.grd.save(log_file_base + '_' + str(cur_run) + '.log')
with open (log_file_base + '__agents.txt', "a") as f:
f.write("\nWorld tgt= [" + str(self.agent_list[0].target_y) + "," + str(self.agent_list[0].target_x) + "]\n")
f.write(str(self.world.grd))
f.write('\n\nAgent Name , starting, num Steps , num Climbs\n')
for num, agt in enumerate(self.agent_list):
res = agt.name + ' , [' + str(agt.start_y) + ', ' + str(agt.start_x) + '], '
res += str(agt.num_steps) + ' , ' + str(agt.num_climbs) + ' , '
res += ''.join([a for a in agt.results])
f.write(res + '\n') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:merge; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:arg; 5, list_splat_pattern; 5, 6; 6, identifier:rest; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 19; 9, 25; 9, 37; 9, 41; 9, 71; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 13; 12, identifier:ensure_keyword_args; 13, argument_list; 13, 14; 13, 15; 14, identifier:kwargs; 15, keyword_argument; 15, 16; 15, 17; 16, identifier:optional; 17, tuple; 17, 18; 18, string:'default'; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:has_default; 22, comparison_operator:in; 22, 23; 22, 24; 23, string:'default'; 24, identifier:kwargs; 25, if_statement; 25, 26; 25, 27; 26, identifier:has_default; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:default; 31, call; 31, 32; 31, 33; 32, identifier:ensure_callable; 33, argument_list; 33, 34; 34, subscript; 34, 35; 34, 36; 35, identifier:kwargs; 36, string:'default'; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:unary_result; 40, True; 41, if_statement; 41, 42; 41, 43; 41, 65; 42, identifier:rest; 43, block; 43, 44; 43, 61; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:fs; 47, binary_operator:+; 47, 48; 47, 53; 48, tuple; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:ensure_callable; 51, argument_list; 51, 52; 52, identifier:arg; 53, call; 53, 54; 53, 55; 54, identifier:tuple; 55, argument_list; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:imap; 58, argument_list; 58, 59; 58, 60; 59, identifier:ensure_callable; 60, identifier:rest; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:unary_result; 64, False; 65, else_clause; 65, 66; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:fs; 70, identifier:arg; 71, if_statement; 71, 72; 71, 76; 71, 130; 72, call; 72, 73; 72, 74; 73, identifier:is_mapping; 74, argument_list; 74, 75; 75, identifier:fs; 76, block; 76, 77; 77, if_statement; 77, 78; 77, 79; 77, 106; 78, identifier:has_default; 79, block; 79, 80; 80, return_statement; 80, 81; 81, lambda; 81, 82; 81, 84; 82, lambda_parameters; 82, 83; 83, identifier:arg_; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:fs; 87, identifier:__class__; 88, generator_expression; 88, 89; 88, 103; 89, tuple; 89, 90; 89, 91; 90, identifier:k; 91, call; 91, 92; 91, 99; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:fs; 95, identifier:get; 96, argument_list; 96, 97; 96, 98; 97, identifier:k; 98, identifier:default; 99, argument_list; 99, 100; 100, subscript; 100, 101; 100, 102; 101, identifier:arg_; 102, identifier:k; 103, for_in_clause; 103, 104; 103, 105; 104, identifier:k; 105, identifier:arg_; 106, else_clause; 106, 107; 107, block; 107, 108; 108, return_statement; 108, 109; 109, lambda; 109, 110; 109, 112; 110, lambda_parameters; 110, 111; 111, identifier:arg_; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:fs; 115, identifier:__class__; 116, generator_expression; 116, 117; 116, 127; 117, tuple; 117, 118; 117, 119; 118, identifier:k; 119, call; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:fs; 122, identifier:k; 123, argument_list; 123, 124; 124, subscript; 124, 125; 124, 126; 125, identifier:arg_; 126, identifier:k; 127, for_in_clause; 127, 128; 127, 129; 128, identifier:k; 129, identifier:arg_; 130, else_clause; 130, 131; 131, block; 131, 132; 131, 137; 131, 201; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 135; 134, identifier:ensure_sequence; 135, argument_list; 135, 136; 136, identifier:fs; 137, if_statement; 137, 138; 137, 139; 137, 174; 138, identifier:has_default; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:func; 143, lambda; 143, 144; 143, 146; 144, lambda_parameters; 144, 145; 145, identifier:arg_; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:fs; 149, identifier:__class__; 150, generator_expression; 150, 151; 150, 166; 151, call; 151, 152; 151, 164; 152, parenthesized_expression; 152, 153; 153, conditional_expression:if; 153, 154; 153, 157; 153, 163; 154, subscript; 154, 155; 154, 156; 155, identifier:fs; 156, identifier:i; 157, comparison_operator:<; 157, 158; 157, 159; 158, identifier:i; 159, call; 159, 160; 159, 161; 160, identifier:len; 161, argument_list; 161, 162; 162, identifier:fs; 163, identifier:default; 164, argument_list; 164, 165; 165, identifier:x; 166, for_in_clause; 166, 167; 166, 170; 167, pattern_list; 167, 168; 167, 169; 168, identifier:i; 169, identifier:x; 170, call; 170, 171; 170, 172; 171, identifier:enumerate; 172, argument_list; 172, 173; 173, identifier:arg_; 174, else_clause; 174, 175; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:func; 179, lambda; 179, 180; 179, 182; 180, lambda_parameters; 180, 181; 181, identifier:arg_; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:fs; 185, identifier:__class__; 186, generator_expression; 186, 187; 186, 193; 187, call; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:fs; 190, identifier:i; 191, argument_list; 191, 192; 192, identifier:x; 193, for_in_clause; 193, 194; 193, 197; 194, pattern_list; 194, 195; 194, 196; 195, identifier:i; 196, identifier:x; 197, call; 197, 198; 197, 199; 198, identifier:enumerate; 199, argument_list; 199, 200; 200, identifier:arg_; 201, return_statement; 201, 202; 202, conditional_expression:if; 202, 203; 202, 204; 202, 205; 203, identifier:func; 204, identifier:unary_result; 205, lambda; 205, 206; 205, 209; 206, lambda_parameters; 206, 207; 207, list_splat_pattern; 207, 208; 208, identifier:args; 209, call; 209, 210; 209, 211; 210, identifier:func; 211, argument_list; 211, 212; 212, identifier:args | def merge(arg, *rest, **kwargs):
ensure_keyword_args(kwargs, optional=('default',))
has_default = 'default' in kwargs
if has_default:
default = ensure_callable(kwargs['default'])
unary_result = True
if rest:
fs = (ensure_callable(arg),) + tuple(imap(ensure_callable, rest))
unary_result = False
else:
fs = arg
if is_mapping(fs):
if has_default:
return lambda arg_: fs.__class__((k, fs.get(k, default)(arg_[k]))
for k in arg_)
else:
return lambda arg_: fs.__class__((k, fs[k](arg_[k]))
for k in arg_)
else:
ensure_sequence(fs)
if has_default:
func = lambda arg_: fs.__class__(
(fs[i] if i < len(fs) else default)(x)
for i, x in enumerate(arg_))
else:
func = lambda arg_: fs.__class__(fs[i](x)
for i, x in enumerate(arg_))
return func if unary_result else lambda *args: func(args) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:cmd; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:send; 5, identifier:msg; 6, identifier:args; 7, block; 7, 8; 7, 27; 7, 33; 7, 44; 7, 52; 7, 62; 7, 72; 7, 87; 7, 115; 8, if_statement; 8, 9; 8, 20; 9, not_operator; 9, 10; 10, call; 10, 11; 10, 18; 11, attribute; 11, 12; 11, 17; 12, subscript; 12, 13; 12, 16; 13, subscript; 13, 14; 13, 15; 14, identifier:args; 15, string:'config'; 16, string:'feature'; 17, identifier:getboolean; 18, argument_list; 18, 19; 19, string:'hooks'; 20, block; 20, 21; 20, 26; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:send; 24, argument_list; 24, 25; 25, string:"Hooks are disabled, and this command depends on hooks. Please contact the bot admin(s)."; 26, return_statement; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:session; 30, subscript; 30, 31; 30, 32; 31, identifier:args; 32, string:'db'; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:parser; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:arguments; 39, identifier:ArgParser; 40, argument_list; 40, 41; 41, subscript; 41, 42; 41, 43; 42, identifier:args; 43, string:'config'; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:group; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:parser; 50, identifier:add_mutually_exclusive_group; 51, argument_list; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:group; 56, identifier:add_argument; 57, argument_list; 57, 58; 57, 59; 58, string:'--high'; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:action; 61, string:'store_true'; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:group; 66, identifier:add_argument; 67, argument_list; 67, 68; 67, 69; 68, string:'--low'; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:action; 71, string:'store_true'; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:group; 76, identifier:add_argument; 77, argument_list; 77, 78; 77, 79; 77, 82; 78, string:'nick'; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:nargs; 81, string:'?'; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:action; 84, attribute; 84, 85; 84, 86; 85, identifier:arguments; 86, identifier:NickParser; 87, try_statement; 87, 88; 87, 98; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:cmdargs; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:parser; 95, identifier:parse_args; 96, argument_list; 96, 97; 97, identifier:msg; 98, except_clause; 98, 99; 98, 105; 99, as_pattern; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:arguments; 102, identifier:ArgumentException; 103, as_pattern_target; 103, 104; 104, identifier:e; 105, block; 105, 106; 105, 114; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:send; 109, argument_list; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:str; 112, argument_list; 112, 113; 113, identifier:e; 114, return_statement; 115, if_statement; 115, 116; 115, 119; 115, 171; 115, 223; 115, 359; 116, attribute; 116, 117; 116, 118; 117, identifier:cmdargs; 118, identifier:high; 119, block; 119, 120; 119, 149; 119, 154; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:data; 123, call; 123, 124; 123, 148; 124, attribute; 124, 125; 124, 147; 125, call; 125, 126; 125, 145; 126, attribute; 126, 127; 126, 144; 127, call; 127, 128; 127, 136; 128, attribute; 128, 129; 128, 135; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:session; 132, identifier:query; 133, argument_list; 133, 134; 134, identifier:Scores; 135, identifier:order_by; 136, argument_list; 136, 137; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:Scores; 141, identifier:score; 142, identifier:desc; 143, argument_list; 144, identifier:limit; 145, argument_list; 145, 146; 146, integer:3; 147, identifier:all; 148, argument_list; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:send; 152, argument_list; 152, 153; 153, string:'High Scores:'; 154, for_statement; 154, 155; 154, 156; 154, 157; 155, identifier:x; 156, identifier:data; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, call; 159, 160; 159, 161; 160, identifier:send; 161, argument_list; 161, 162; 162, binary_operator:%; 162, 163; 162, 164; 163, string:"%s: %s"; 164, tuple; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:x; 167, identifier:nick; 168, attribute; 168, 169; 168, 170; 169, identifier:x; 170, identifier:score; 171, elif_clause; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:cmdargs; 174, identifier:low; 175, block; 175, 176; 175, 201; 175, 206; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:data; 179, call; 179, 180; 179, 200; 180, attribute; 180, 181; 180, 199; 181, call; 181, 182; 181, 197; 182, attribute; 182, 183; 182, 196; 183, call; 183, 184; 183, 192; 184, attribute; 184, 185; 184, 191; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:session; 188, identifier:query; 189, argument_list; 189, 190; 190, identifier:Scores; 191, identifier:order_by; 192, argument_list; 192, 193; 193, attribute; 193, 194; 193, 195; 194, identifier:Scores; 195, identifier:score; 196, identifier:limit; 197, argument_list; 197, 198; 198, integer:3; 199, identifier:all; 200, argument_list; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:send; 204, argument_list; 204, 205; 205, string:'Low Scores:'; 206, for_statement; 206, 207; 206, 208; 206, 209; 207, identifier:x; 208, identifier:data; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 213; 212, identifier:send; 213, argument_list; 213, 214; 214, binary_operator:%; 214, 215; 214, 216; 215, string:"%s: %s"; 216, tuple; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:x; 219, identifier:nick; 220, attribute; 220, 221; 220, 222; 221, identifier:x; 222, identifier:score; 223, elif_clause; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:cmdargs; 226, identifier:nick; 227, block; 227, 228; 227, 238; 227, 249; 227, 271; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:name; 231, call; 231, 232; 231, 237; 232, attribute; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:cmdargs; 235, identifier:nick; 236, identifier:lower; 237, argument_list; 238, if_statement; 238, 239; 238, 242; 239, comparison_operator:==; 239, 240; 239, 241; 240, identifier:name; 241, string:'c'; 242, block; 242, 243; 242, 248; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 246; 245, identifier:send; 246, argument_list; 246, 247; 247, string:"We all know you love C better than anything else, so why rub it in?"; 248, return_statement; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:score; 252, call; 252, 253; 252, 270; 253, attribute; 253, 254; 253, 269; 254, call; 254, 255; 254, 263; 255, attribute; 255, 256; 255, 262; 256, call; 256, 257; 256, 260; 257, attribute; 257, 258; 257, 259; 258, identifier:session; 259, identifier:query; 260, argument_list; 260, 261; 261, identifier:Scores; 262, identifier:filter; 263, argument_list; 263, 264; 264, comparison_operator:==; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:Scores; 267, identifier:nick; 268, identifier:name; 269, identifier:scalar; 270, argument_list; 271, if_statement; 271, 272; 271, 275; 271, 350; 272, comparison_operator:is; 272, 273; 272, 274; 273, identifier:score; 274, None; 275, block; 275, 276; 275, 290; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:plural; 279, conditional_expression:if; 279, 280; 279, 281; 279, 289; 280, string:''; 281, comparison_operator:==; 281, 282; 281, 288; 282, call; 282, 283; 282, 284; 283, identifier:abs; 284, argument_list; 284, 285; 285, attribute; 285, 286; 285, 287; 286, identifier:score; 287, identifier:score; 288, integer:1; 289, string:'s'; 290, if_statement; 290, 291; 290, 300; 290, 336; 291, comparison_operator:==; 291, 292; 291, 293; 292, identifier:name; 293, call; 293, 294; 293, 299; 294, attribute; 294, 295; 294, 298; 295, subscript; 295, 296; 295, 297; 296, identifier:args; 297, string:'botnick'; 298, identifier:lower; 299, argument_list; 300, block; 300, 301; 300, 319; 300, 330; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 304; 303, identifier:emote; 304, conditional_expression:if; 304, 305; 304, 306; 304, 311; 305, string:':)'; 306, comparison_operator:>; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:score; 309, identifier:score; 310, integer:0; 311, conditional_expression:if; 311, 312; 311, 313; 311, 318; 312, string:':('; 313, comparison_operator:<; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:score; 316, identifier:score; 317, integer:0; 318, string:':|'; 319, expression_statement; 319, 320; 320, assignment; 320, 321; 320, 322; 321, identifier:output; 322, binary_operator:%; 322, 323; 322, 324; 323, string:'has %s point%s! %s'; 324, tuple; 324, 325; 324, 328; 324, 329; 325, attribute; 325, 326; 325, 327; 326, identifier:score; 327, identifier:score; 328, identifier:plural; 329, identifier:emote; 330, expression_statement; 330, 331; 331, call; 331, 332; 331, 333; 332, identifier:send; 333, argument_list; 333, 334; 333, 335; 334, identifier:output; 335, string:'action'; 336, else_clause; 336, 337; 337, block; 337, 338; 338, expression_statement; 338, 339; 339, call; 339, 340; 339, 341; 340, identifier:send; 341, argument_list; 341, 342; 342, binary_operator:%; 342, 343; 342, 344; 343, string:"%s has %i point%s!"; 344, tuple; 344, 345; 344, 346; 344, 349; 345, identifier:name; 346, attribute; 346, 347; 346, 348; 347, identifier:score; 348, identifier:score; 349, identifier:plural; 350, else_clause; 350, 351; 351, block; 351, 352; 352, expression_statement; 352, 353; 353, call; 353, 354; 353, 355; 354, identifier:send; 355, argument_list; 355, 356; 356, binary_operator:%; 356, 357; 356, 358; 357, string:"Nobody cares about %s"; 358, identifier:name; 359, else_clause; 359, 360; 360, block; 360, 361; 361, if_statement; 361, 362; 361, 374; 361, 380; 362, comparison_operator:==; 362, 363; 362, 373; 363, call; 363, 364; 363, 372; 364, attribute; 364, 365; 364, 371; 365, call; 365, 366; 365, 369; 366, attribute; 366, 367; 366, 368; 367, identifier:session; 368, identifier:query; 369, argument_list; 369, 370; 370, identifier:Scores; 371, identifier:count; 372, argument_list; 373, integer:0; 374, block; 374, 375; 375, expression_statement; 375, 376; 376, call; 376, 377; 376, 378; 377, identifier:send; 378, argument_list; 378, 379; 379, string:"Nobody cares about anything =("; 380, else_clause; 380, 381; 381, block; 381, 382; 381, 404; 381, 418; 382, expression_statement; 382, 383; 383, assignment; 383, 384; 383, 385; 384, identifier:query; 385, call; 385, 386; 385, 403; 386, attribute; 386, 387; 386, 402; 387, call; 387, 388; 387, 396; 388, attribute; 388, 389; 388, 395; 389, call; 389, 390; 389, 393; 390, attribute; 390, 391; 390, 392; 391, identifier:session; 392, identifier:query; 393, argument_list; 393, 394; 394, identifier:Scores; 395, identifier:order_by; 396, argument_list; 396, 397; 397, call; 397, 398; 397, 401; 398, attribute; 398, 399; 398, 400; 399, identifier:func; 400, identifier:random; 401, argument_list; 402, identifier:first; 403, argument_list; 404, expression_statement; 404, 405; 405, assignment; 405, 406; 405, 407; 406, identifier:plural; 407, conditional_expression:if; 407, 408; 407, 409; 407, 417; 408, string:''; 409, comparison_operator:==; 409, 410; 409, 416; 410, call; 410, 411; 410, 412; 411, identifier:abs; 412, argument_list; 412, 413; 413, attribute; 413, 414; 413, 415; 414, identifier:query; 415, identifier:score; 416, integer:1; 417, string:'s'; 418, expression_statement; 418, 419; 419, call; 419, 420; 419, 421; 420, identifier:send; 421, argument_list; 421, 422; 422, binary_operator:%; 422, 423; 422, 424; 423, string:"%s has %i point%s!"; 424, tuple; 424, 425; 424, 428; 424, 431; 425, attribute; 425, 426; 425, 427; 426, identifier:query; 427, identifier:nick; 428, attribute; 428, 429; 428, 430; 429, identifier:query; 430, identifier:score; 431, identifier:plural | def cmd(send, msg, args):
if not args['config']['feature'].getboolean('hooks'):
send("Hooks are disabled, and this command depends on hooks. Please contact the bot admin(s).")
return
session = args['db']
parser = arguments.ArgParser(args['config'])
group = parser.add_mutually_exclusive_group()
group.add_argument('--high', action='store_true')
group.add_argument('--low', action='store_true')
group.add_argument('nick', nargs='?', action=arguments.NickParser)
try:
cmdargs = parser.parse_args(msg)
except arguments.ArgumentException as e:
send(str(e))
return
if cmdargs.high:
data = session.query(Scores).order_by(Scores.score.desc()).limit(3).all()
send('High Scores:')
for x in data:
send("%s: %s" % (x.nick, x.score))
elif cmdargs.low:
data = session.query(Scores).order_by(Scores.score).limit(3).all()
send('Low Scores:')
for x in data:
send("%s: %s" % (x.nick, x.score))
elif cmdargs.nick:
name = cmdargs.nick.lower()
if name == 'c':
send("We all know you love C better than anything else, so why rub it in?")
return
score = session.query(Scores).filter(Scores.nick == name).scalar()
if score is not None:
plural = '' if abs(score.score) == 1 else 's'
if name == args['botnick'].lower():
emote = ':)' if score.score > 0 else ':(' if score.score < 0 else ':|'
output = 'has %s point%s! %s' % (score.score, plural, emote)
send(output, 'action')
else:
send("%s has %i point%s!" % (name, score.score, plural))
else:
send("Nobody cares about %s" % name)
else:
if session.query(Scores).count() == 0:
send("Nobody cares about anything =(")
else:
query = session.query(Scores).order_by(func.random()).first()
plural = '' if abs(query.score) == 1 else 's'
send("%s has %i point%s!" % (query.nick, query.score, plural)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:buildPrices; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:data; 5, default_parameter; 5, 6; 5, 7; 6, identifier:roles; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:regex; 10, identifier:default_price_regex; 11, default_parameter; 11, 12; 11, 13; 12, identifier:default; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:additional; 16, dictionary; 17, block; 17, 18; 17, 20; 18, expression_statement; 18, 19; 19, string:''' Create a dictionary with price information. Multiple ways are
supported.
:rtype: :obj:`dict`: keys are role as str, values are the prices as
cent count'''; 20, if_statement; 20, 21; 20, 26; 20, 63; 20, 142; 20, 184; 21, call; 21, 22; 21, 23; 22, identifier:isinstance; 23, argument_list; 23, 24; 23, 25; 24, identifier:data; 25, identifier:dict; 26, block; 26, 27; 26, 48; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:data; 30, list_comprehension; 30, 31; 30, 41; 31, tuple; 31, 32; 31, 35; 32, subscript; 32, 33; 32, 34; 33, identifier:item; 34, integer:0; 35, call; 35, 36; 35, 37; 36, identifier:convertPrice; 37, argument_list; 37, 38; 38, subscript; 38, 39; 38, 40; 39, identifier:item; 40, integer:1; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:item; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:data; 46, identifier:items; 47, argument_list; 48, return_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:dict; 51, argument_list; 51, 52; 52, list_comprehension; 52, 53; 52, 54; 52, 57; 53, identifier:v; 54, for_in_clause; 54, 55; 54, 56; 55, identifier:v; 56, identifier:data; 57, if_clause; 57, 58; 58, comparison_operator:is; 58, 59; 58, 62; 59, subscript; 59, 60; 59, 61; 60, identifier:v; 61, integer:1; 62, None; 63, elif_clause; 63, 64; 63, 79; 64, boolean_operator:and; 64, 65; 64, 73; 65, call; 65, 66; 65, 67; 66, identifier:isinstance; 67, argument_list; 67, 68; 67, 69; 68, identifier:data; 69, tuple; 69, 70; 69, 71; 69, 72; 70, identifier:str; 71, identifier:float; 72, identifier:int; 73, not_operator; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:isinstance; 76, argument_list; 76, 77; 76, 78; 77, identifier:data; 78, identifier:bool; 79, block; 79, 80; 79, 92; 79, 99; 79, 106; 79, 113; 79, 140; 80, if_statement; 80, 81; 80, 84; 81, comparison_operator:is; 81, 82; 81, 83; 82, identifier:default; 83, None; 84, block; 84, 85; 85, raise_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:ValueError; 88, argument_list; 88, 89; 89, concatenated_string; 89, 90; 89, 91; 90, string:'You have to call setAdditionalCharges '; 91, string:'before it is possible to pass a string as price'; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:basePrice; 95, call; 95, 96; 95, 97; 96, identifier:convertPrice; 97, argument_list; 97, 98; 98, identifier:data; 99, if_statement; 99, 100; 99, 103; 100, comparison_operator:is; 100, 101; 100, 102; 101, identifier:basePrice; 102, None; 103, block; 103, 104; 104, return_statement; 104, 105; 105, dictionary; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:prices; 109, dictionary; 109, 110; 110, pair; 110, 111; 110, 112; 111, identifier:default; 112, identifier:basePrice; 113, for_statement; 113, 114; 113, 115; 113, 116; 114, identifier:role; 115, identifier:additional; 116, block; 116, 117; 116, 126; 116, 132; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:extraCharge; 120, call; 120, 121; 120, 122; 121, identifier:convertPrice; 122, argument_list; 122, 123; 123, subscript; 123, 124; 123, 125; 124, identifier:additional; 125, identifier:role; 126, if_statement; 126, 127; 126, 130; 127, comparison_operator:is; 127, 128; 127, 129; 128, identifier:extraCharge; 129, None; 130, block; 130, 131; 131, continue_statement; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:prices; 136, identifier:role; 137, binary_operator:+; 137, 138; 137, 139; 138, identifier:basePrice; 139, identifier:extraCharge; 140, return_statement; 140, 141; 141, identifier:prices; 142, elif_clause; 142, 143; 142, 144; 143, identifier:roles; 144, block; 144, 145; 144, 149; 144, 156; 144, 182; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:prices; 148, dictionary; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:priceRoles; 152, call; 152, 153; 152, 154; 153, identifier:iter; 154, argument_list; 154, 155; 155, identifier:roles; 156, for_statement; 156, 157; 156, 158; 156, 159; 157, identifier:priceData; 158, identifier:data; 159, block; 159, 160; 159, 167; 159, 173; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:price; 163, call; 163, 164; 163, 165; 164, identifier:convertPrice; 165, argument_list; 165, 166; 166, identifier:priceData; 167, if_statement; 167, 168; 167, 171; 168, comparison_operator:is; 168, 169; 168, 170; 169, identifier:price; 170, None; 171, block; 171, 172; 172, continue_statement; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 181; 175, subscript; 175, 176; 175, 177; 176, identifier:prices; 177, call; 177, 178; 177, 179; 178, identifier:next; 179, argument_list; 179, 180; 180, identifier:priceRoles; 181, identifier:price; 182, return_statement; 182, 183; 183, identifier:prices; 184, else_clause; 184, 185; 185, block; 185, 186; 186, raise_statement; 186, 187; 187, call; 187, 188; 187, 189; 188, identifier:TypeError; 189, argument_list; 189, 190; 190, string:'This type is for prices not supported!' | def buildPrices(data, roles=None, regex=default_price_regex,
default=None, additional={}):
''' Create a dictionary with price information. Multiple ways are
supported.
:rtype: :obj:`dict`: keys are role as str, values are the prices as
cent count'''
if isinstance(data, dict):
data = [(item[0], convertPrice(item[1])) for item in data.items()]
return dict([v for v in data if v[1] is not None])
elif isinstance(data, (str, float, int)) and not isinstance(data, bool):
if default is None:
raise ValueError('You have to call setAdditionalCharges '
'before it is possible to pass a string as price')
basePrice = convertPrice(data)
if basePrice is None:
return {}
prices = {default: basePrice}
for role in additional:
extraCharge = convertPrice(additional[role])
if extraCharge is None:
continue
prices[role] = basePrice + extraCharge
return prices
elif roles:
prices = {}
priceRoles = iter(roles)
for priceData in data:
price = convertPrice(priceData)
if price is None:
continue
prices[next(priceRoles)] = price
return prices
else:
raise TypeError('This type is for prices not supported!') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:toTag; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:output; 6, block; 6, 7; 6, 9; 6, 18; 6, 41; 6, 64; 6, 87; 6, 110; 6, 133; 6, 155; 6, 178; 6, 207; 6, 308; 7, expression_statement; 7, 8; 8, string:''' This methods adds all data of this canteen as canteen xml tag
to the given xml Document.
:meth:`toXMLFeed` uses this method to create the XML Feed. So there is
normally no need to call it directly.
:param output: XML Document to which the data should be added
:type output: xml.dom.DOMImplementation.createDocument
'''; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:canteen; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:output; 15, identifier:createElement; 16, argument_list; 16, 17; 17, string:'canteen'; 18, if_statement; 18, 19; 18, 24; 19, comparison_operator:is; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_name; 23, None; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:canteen; 29, identifier:appendChild; 30, argument_list; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_buildStringTag; 35, argument_list; 35, 36; 35, 37; 35, 40; 36, string:'name'; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:_name; 40, identifier:output; 41, if_statement; 41, 42; 41, 47; 42, comparison_operator:is; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_address; 46, None; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:canteen; 52, identifier:appendChild; 53, argument_list; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:_buildStringTag; 58, argument_list; 58, 59; 58, 60; 58, 63; 59, string:'address'; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_address; 63, identifier:output; 64, if_statement; 64, 65; 64, 70; 65, comparison_operator:is; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:_city; 69, None; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:canteen; 75, identifier:appendChild; 76, argument_list; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_buildStringTag; 81, argument_list; 81, 82; 81, 83; 81, 86; 82, string:'city'; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:_city; 86, identifier:output; 87, if_statement; 87, 88; 87, 93; 88, comparison_operator:is; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:_phone; 92, None; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:canteen; 98, identifier:appendChild; 99, argument_list; 99, 100; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:_buildStringTag; 104, argument_list; 104, 105; 104, 106; 104, 109; 105, string:'phone'; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:_phone; 109, identifier:output; 110, if_statement; 110, 111; 110, 116; 111, comparison_operator:is; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:_email; 115, None; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:canteen; 121, identifier:appendChild; 122, argument_list; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:_buildStringTag; 127, argument_list; 127, 128; 127, 129; 127, 132; 128, string:'email'; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:_email; 132, identifier:output; 133, if_statement; 133, 134; 133, 139; 134, comparison_operator:is; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:_location; 138, None; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:canteen; 144, identifier:appendChild; 145, argument_list; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:_buildLocationTag; 150, argument_list; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:_location; 154, identifier:output; 155, if_statement; 155, 156; 155, 161; 156, comparison_operator:is; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:self; 159, identifier:_availability; 160, None; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:canteen; 166, identifier:appendChild; 167, argument_list; 167, 168; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:self; 171, identifier:_buildStringTag; 172, argument_list; 172, 173; 172, 174; 172, 177; 173, string:'availability'; 174, attribute; 174, 175; 174, 176; 175, identifier:self; 176, identifier:_availability; 177, identifier:output; 178, for_statement; 178, 179; 178, 180; 178, 194; 179, identifier:feed; 180, call; 180, 181; 180, 182; 181, identifier:sorted; 182, argument_list; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:feeds; 186, keyword_argument; 186, 187; 186, 188; 187, identifier:key; 188, lambda; 188, 189; 188, 191; 189, lambda_parameters; 189, 190; 190, identifier:v; 191, attribute; 191, 192; 191, 193; 192, identifier:v; 193, identifier:priority; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:canteen; 199, identifier:appendChild; 200, argument_list; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:feed; 204, identifier:toTag; 205, argument_list; 205, 206; 206, identifier:output; 207, for_statement; 207, 208; 207, 209; 207, 219; 208, identifier:date; 209, call; 209, 210; 209, 211; 210, identifier:sorted; 211, argument_list; 211, 212; 212, call; 212, 213; 212, 218; 213, attribute; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:self; 216, identifier:_days; 217, identifier:keys; 218, argument_list; 219, block; 219, 220; 219, 229; 219, 240; 219, 273; 219, 301; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:day; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:output; 226, identifier:createElement; 227, argument_list; 227, 228; 228, string:'day'; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:day; 233, identifier:setAttribute; 234, argument_list; 234, 235; 234, 236; 235, string:'date'; 236, call; 236, 237; 236, 238; 237, identifier:str; 238, argument_list; 238, 239; 239, identifier:date; 240, if_statement; 240, 241; 240, 248; 241, comparison_operator:is; 241, 242; 241, 247; 242, subscript; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:_days; 246, identifier:date; 247, False; 248, block; 248, 249; 248, 258; 248, 265; 248, 272; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:closed; 252, call; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:output; 255, identifier:createElement; 256, argument_list; 256, 257; 257, string:'closed'; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:day; 262, identifier:appendChild; 263, argument_list; 263, 264; 264, identifier:closed; 265, expression_statement; 265, 266; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:canteen; 269, identifier:appendChild; 270, argument_list; 270, 271; 271, identifier:day; 272, continue_statement; 273, for_statement; 273, 274; 273, 275; 273, 280; 274, identifier:categoryname; 275, subscript; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:self; 278, identifier:_days; 279, identifier:date; 280, block; 280, 281; 281, expression_statement; 281, 282; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:day; 285, identifier:appendChild; 286, argument_list; 286, 287; 287, call; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:self; 290, identifier:_buildCategoryTag; 291, argument_list; 291, 292; 291, 293; 291, 300; 292, identifier:categoryname; 293, subscript; 293, 294; 293, 299; 294, subscript; 294, 295; 294, 298; 295, attribute; 295, 296; 295, 297; 296, identifier:self; 297, identifier:_days; 298, identifier:date; 299, identifier:categoryname; 300, identifier:output; 301, expression_statement; 301, 302; 302, call; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:canteen; 305, identifier:appendChild; 306, argument_list; 306, 307; 307, identifier:day; 308, return_statement; 308, 309; 309, identifier:canteen | def toTag(self, output):
''' This methods adds all data of this canteen as canteen xml tag
to the given xml Document.
:meth:`toXMLFeed` uses this method to create the XML Feed. So there is
normally no need to call it directly.
:param output: XML Document to which the data should be added
:type output: xml.dom.DOMImplementation.createDocument
'''
canteen = output.createElement('canteen')
if self._name is not None:
canteen.appendChild(self._buildStringTag('name', self._name, output))
if self._address is not None:
canteen.appendChild(self._buildStringTag('address', self._address, output))
if self._city is not None:
canteen.appendChild(self._buildStringTag('city', self._city, output))
if self._phone is not None:
canteen.appendChild(self._buildStringTag('phone', self._phone, output))
if self._email is not None:
canteen.appendChild(self._buildStringTag('email', self._email, output))
if self._location is not None:
canteen.appendChild(self._buildLocationTag(self._location, output))
if self._availability is not None:
canteen.appendChild(self._buildStringTag('availability', self._availability, output))
for feed in sorted(self.feeds, key=lambda v: v.priority):
canteen.appendChild(feed.toTag(output))
for date in sorted(self._days.keys()):
day = output.createElement('day')
day.setAttribute('date', str(date))
if self._days[date] is False:
closed = output.createElement('closed')
day.appendChild(closed)
canteen.appendChild(day)
continue
for categoryname in self._days[date]:
day.appendChild(self._buildCategoryTag(
categoryname, self._days[date][categoryname], output))
canteen.appendChild(day)
return canteen |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 33; 2, function_name:AddAnalogShortIdMsecRecord; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 3, 30; 4, identifier:site_service; 5, identifier:tag; 6, identifier:time_value; 7, identifier:msec; 8, identifier:value; 9, default_parameter; 9, 10; 9, 11; 10, identifier:low_warn; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:high_warn; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:low_alarm; 17, False; 18, default_parameter; 18, 19; 18, 20; 19, identifier:high_alarm; 20, False; 21, default_parameter; 21, 22; 21, 23; 22, identifier:oor_low; 23, False; 24, default_parameter; 24, 25; 24, 26; 25, identifier:oor_high; 26, False; 27, default_parameter; 27, 28; 27, 29; 28, identifier:unreliable; 29, False; 30, default_parameter; 30, 31; 30, 32; 31, identifier:manual; 32, False; 33, block; 33, 34; 33, 46; 33, 58; 33, 68; 33, 75; 33, 85; 33, 95; 33, 105; 33, 115; 33, 125; 33, 135; 33, 145; 33, 155; 33, 162; 33, 183; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:szService; 37, call; 37, 38; 37, 39; 38, identifier:c_char_p; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:site_service; 43, identifier:encode; 44, argument_list; 44, 45; 45, string:'utf-8'; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:szPointId; 49, call; 49, 50; 49, 51; 50, identifier:c_char_p; 51, argument_list; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:tag; 55, identifier:encode; 56, argument_list; 56, 57; 57, string:'utf-8'; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:tTime; 61, call; 61, 62; 61, 63; 62, identifier:c_long; 63, argument_list; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:int; 66, argument_list; 66, 67; 67, identifier:time_value; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:dValue; 71, call; 71, 72; 71, 73; 72, identifier:c_double; 73, argument_list; 73, 74; 74, identifier:value; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:bLowWarning; 78, call; 78, 79; 78, 80; 79, identifier:c_int; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:int; 83, argument_list; 83, 84; 84, identifier:low_warn; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:bHighWarning; 88, call; 88, 89; 88, 90; 89, identifier:c_int; 90, argument_list; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:int; 93, argument_list; 93, 94; 94, identifier:high_warn; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:bLowAlarm; 98, call; 98, 99; 98, 100; 99, identifier:c_int; 100, argument_list; 100, 101; 101, call; 101, 102; 101, 103; 102, identifier:int; 103, argument_list; 103, 104; 104, identifier:low_alarm; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:bHighAlarm; 108, call; 108, 109; 108, 110; 109, identifier:c_int; 110, argument_list; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:int; 113, argument_list; 113, 114; 114, identifier:high_alarm; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:bOutOfRangeLow; 118, call; 118, 119; 118, 120; 119, identifier:c_int; 120, argument_list; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:int; 123, argument_list; 123, 124; 124, identifier:oor_low; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:bOutOfRangeHigh; 128, call; 128, 129; 128, 130; 129, identifier:c_int; 130, argument_list; 130, 131; 131, call; 131, 132; 131, 133; 132, identifier:int; 133, argument_list; 133, 134; 134, identifier:oor_high; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:bUnReliable; 138, call; 138, 139; 138, 140; 139, identifier:c_int; 140, argument_list; 140, 141; 141, call; 141, 142; 141, 143; 142, identifier:int; 143, argument_list; 143, 144; 144, identifier:unreliable; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:bManual; 148, call; 148, 149; 148, 150; 149, identifier:c_int; 150, argument_list; 150, 151; 151, call; 151, 152; 151, 153; 152, identifier:int; 153, argument_list; 153, 154; 154, identifier:manual; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:usMsec; 158, call; 158, 159; 158, 160; 159, identifier:c_ushort; 160, argument_list; 160, 161; 161, identifier:msec; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:nRet; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:dnaserv_dll; 168, identifier:DnaAddAnalogShortIdMsecRecord; 169, argument_list; 169, 170; 169, 171; 169, 172; 169, 173; 169, 174; 169, 175; 169, 176; 169, 177; 169, 178; 169, 179; 169, 180; 169, 181; 169, 182; 170, identifier:szService; 171, identifier:szPointId; 172, identifier:tTime; 173, identifier:dValue; 174, identifier:bLowWarning; 175, identifier:bHighWarning; 176, identifier:bLowAlarm; 177, identifier:bHighAlarm; 178, identifier:bOutOfRangeLow; 179, identifier:bOutOfRangeHigh; 180, identifier:bUnReliable; 181, identifier:bManual; 182, identifier:usMsec; 183, return_statement; 183, 184; 184, identifier:nRet | def AddAnalogShortIdMsecRecord(site_service, tag, time_value, msec, value,
low_warn=False, high_warn=False, low_alarm=False, high_alarm=False,
oor_low=False, oor_high=False, unreliable=False, manual=False):
szService = c_char_p(site_service.encode('utf-8'))
szPointId = c_char_p(tag.encode('utf-8'))
tTime = c_long(int(time_value))
dValue = c_double(value)
bLowWarning = c_int(int(low_warn))
bHighWarning = c_int(int(high_warn))
bLowAlarm = c_int(int(low_alarm))
bHighAlarm = c_int(int(high_alarm))
bOutOfRangeLow = c_int(int(oor_low))
bOutOfRangeHigh = c_int(int(oor_high))
bUnReliable = c_int(int(unreliable))
bManual = c_int(int(manual))
usMsec = c_ushort(msec)
nRet = dnaserv_dll.DnaAddAnalogShortIdMsecRecord(szService, szPointId,
tTime, dValue, bLowWarning, bHighWarning, bLowAlarm,
bHighAlarm, bOutOfRangeLow, bOutOfRangeHigh, bUnReliable,
bManual, usMsec)
return nRet |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:update_node_ids; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sub_job_num; 7, None; 8, block; 8, 9; 8, 27; 8, 31; 8, 35; 8, 67; 8, 82; 8, 87; 8, 104; 8, 121; 8, 133; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:dag_id; 12, conditional_expression:if; 12, 13; 12, 20; 12, 21; 13, binary_operator:%; 13, 14; 13, 15; 14, string:'%s.%s'; 15, tuple; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:cluster_id; 19, identifier:sub_job_num; 20, identifier:sub_job_num; 21, call; 21, 22; 21, 23; 22, identifier:str; 23, argument_list; 23, 24; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:cluster_id; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:job_delimiter; 30, string:'+++'; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:attr_delimiter; 34, string:';;;'; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:format; 38, list:[
'-format', '"%d' + attr_delimiter + '"', 'ClusterId',
'-format', '"%v' + attr_delimiter + '"', 'Cmd',
'-format', '"%v' + attr_delimiter + '"', 'Args',
'-format', '"%v' + job_delimiter + '"', 'Arguments'
]; 38, 39; 38, 40; 38, 45; 38, 46; 38, 47; 38, 52; 38, 53; 38, 54; 38, 59; 38, 60; 38, 61; 38, 66; 39, string:'-format'; 40, binary_operator:+; 40, 41; 40, 44; 41, binary_operator:+; 41, 42; 41, 43; 42, string:'"%d'; 43, identifier:attr_delimiter; 44, string:'"'; 45, string:'ClusterId'; 46, string:'-format'; 47, binary_operator:+; 47, 48; 47, 51; 48, binary_operator:+; 48, 49; 48, 50; 49, string:'"%v'; 50, identifier:attr_delimiter; 51, string:'"'; 52, string:'Cmd'; 53, string:'-format'; 54, binary_operator:+; 54, 55; 54, 58; 55, binary_operator:+; 55, 56; 55, 57; 56, string:'"%v'; 57, identifier:attr_delimiter; 58, string:'"'; 59, string:'Args'; 60, string:'-format'; 61, binary_operator:+; 61, 62; 61, 65; 62, binary_operator:+; 62, 63; 62, 64; 63, string:'"%v'; 64, identifier:job_delimiter; 65, string:'"'; 66, string:'Arguments'; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:cmd; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, string:'condor_q -constraint DAGManJobID=={0} {1} && condor_history -constraint DAGManJobID=={0} {1}'; 73, identifier:format; 74, argument_list; 74, 75; 74, 76; 75, identifier:dag_id; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, string:' '; 79, identifier:join; 80, argument_list; 80, 81; 81, identifier:format; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:_args; 85, list:[cmd]; 85, 86; 86, identifier:cmd; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, pattern_list; 89, 90; 89, 91; 90, identifier:out; 91, identifier:err; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:_execute; 96, argument_list; 96, 97; 96, 98; 96, 101; 97, identifier:_args; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:shell; 100, True; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:run_in_job_dir; 103, False; 104, if_statement; 104, 105; 104, 106; 105, identifier:err; 106, block; 106, 107; 106, 116; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:log; 111, identifier:error; 112, argument_list; 112, 113; 112, 114; 112, 115; 113, string:'Error while associating ids for jobs dag %s: %s'; 114, identifier:dag_id; 115, identifier:err; 116, raise_statement; 116, 117; 117, call; 117, 118; 117, 119; 118, identifier:HTCondorError; 119, argument_list; 119, 120; 120, identifier:err; 121, if_statement; 121, 122; 121, 124; 122, not_operator; 122, 123; 123, identifier:out; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:log; 129, identifier:warning; 130, argument_list; 130, 131; 130, 132; 131, string:'Error while associating ids for jobs in dag %s: No jobs found for dag.'; 132, identifier:dag_id; 133, try_statement; 133, 134; 133, 282; 134, block; 134, 135; 134, 144; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:jobs_out; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:out; 141, identifier:split; 142, argument_list; 142, 143; 143, identifier:job_delimiter; 144, for_statement; 144, 145; 144, 146; 144, 149; 145, identifier:node; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:_node_set; 149, block; 149, 150; 149, 156; 149, 166; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:job; 153, attribute; 153, 154; 153, 155; 154, identifier:node; 155, identifier:job; 156, if_statement; 156, 157; 156, 164; 157, comparison_operator:!=; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:job; 160, identifier:cluster_id; 161, attribute; 161, 162; 161, 163; 162, identifier:job; 163, identifier:NULL_CLUSTER_ID; 164, block; 164, 165; 165, continue_statement; 166, for_statement; 166, 167; 166, 168; 166, 169; 167, identifier:job_out; 168, identifier:jobs_out; 169, block; 169, 170; 169, 179; 169, 192; 169, 232; 169, 238; 169, 253; 170, if_statement; 170, 171; 170, 177; 171, boolean_operator:or; 171, 172; 171, 174; 172, not_operator; 172, 173; 173, identifier:job_out; 174, comparison_operator:not; 174, 175; 174, 176; 175, identifier:attr_delimiter; 176, identifier:job_out; 177, block; 177, 178; 178, continue_statement; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 186; 181, pattern_list; 181, 182; 181, 183; 181, 184; 181, 185; 182, identifier:cluster_id; 183, identifier:cmd; 184, identifier:_args; 185, identifier:_arguments; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:job_out; 189, identifier:split; 190, argument_list; 190, 191; 191, identifier:attr_delimiter; 192, if_statement; 192, 193; 192, 200; 192, 209; 192, 222; 193, boolean_operator:and; 193, 194; 193, 197; 194, comparison_operator:==; 194, 195; 194, 196; 195, identifier:_args; 196, string:'undefined'; 197, comparison_operator:!=; 197, 198; 197, 199; 198, identifier:_arguments; 199, string:'undefined'; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:args; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:_arguments; 207, identifier:strip; 208, argument_list; 209, elif_clause; 209, 210; 209, 217; 210, boolean_operator:and; 210, 211; 210, 214; 211, comparison_operator:==; 211, 212; 211, 213; 212, identifier:_args; 213, string:'undefined'; 214, comparison_operator:==; 214, 215; 214, 216; 215, identifier:_arguments; 216, string:'undefined'; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:args; 221, None; 222, else_clause; 222, 223; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:args; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:_args; 230, identifier:strip; 231, argument_list; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:job_cmd; 235, attribute; 235, 236; 235, 237; 236, identifier:job; 237, identifier:executable; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:job_args; 241, conditional_expression:if; 241, 242; 241, 249; 241, 252; 242, call; 242, 243; 242, 248; 243, attribute; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:job; 246, identifier:arguments; 247, identifier:strip; 248, argument_list; 249, attribute; 249, 250; 249, 251; 250, identifier:job; 251, identifier:arguments; 252, None; 253, if_statement; 253, 254; 253, 261; 254, boolean_operator:and; 254, 255; 254, 258; 255, comparison_operator:in; 255, 256; 255, 257; 256, identifier:job_cmd; 257, identifier:cmd; 258, comparison_operator:==; 258, 259; 258, 260; 259, identifier:job_args; 260, identifier:args; 261, block; 261, 262; 261, 272; 261, 281; 262, expression_statement; 262, 263; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:log; 266, identifier:info; 267, argument_list; 267, 268; 267, 269; 267, 270; 267, 271; 268, string:'Linking cluster_id %s to job with command and arguments: %s %s'; 269, identifier:cluster_id; 270, identifier:job_cmd; 271, identifier:job_args; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:job; 276, identifier:_cluster_id; 277, call; 277, 278; 277, 279; 278, identifier:int; 279, argument_list; 279, 280; 280, identifier:cluster_id; 281, break_statement; 282, except_clause; 282, 283; 282, 287; 283, as_pattern; 283, 284; 283, 285; 284, identifier:ValueError; 285, as_pattern_target; 285, 286; 286, identifier:e; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:log; 292, identifier:warning; 293, argument_list; 293, 294; 294, call; 294, 295; 294, 296; 295, identifier:str; 296, argument_list; 296, 297; 297, identifier:e | def update_node_ids(self, sub_job_num=None):
dag_id = '%s.%s' % (self.cluster_id, sub_job_num) if sub_job_num else str(self.cluster_id)
job_delimiter = '+++'
attr_delimiter = ';;;'
format = [
'-format', '"%d' + attr_delimiter + '"', 'ClusterId',
'-format', '"%v' + attr_delimiter + '"', 'Cmd',
'-format', '"%v' + attr_delimiter + '"', 'Args',
'-format', '"%v' + job_delimiter + '"', 'Arguments'
]
cmd = 'condor_q -constraint DAGManJobID=={0} {1} && condor_history -constraint DAGManJobID=={0} {1}'.format(dag_id, ' '.join(format))
_args = [cmd]
out, err = self._execute(_args, shell=True, run_in_job_dir=False)
if err:
log.error('Error while associating ids for jobs dag %s: %s', dag_id, err)
raise HTCondorError(err)
if not out:
log.warning('Error while associating ids for jobs in dag %s: No jobs found for dag.', dag_id)
try:
jobs_out = out.split(job_delimiter)
for node in self._node_set:
job = node.job
if job.cluster_id != job.NULL_CLUSTER_ID:
continue
for job_out in jobs_out:
if not job_out or attr_delimiter not in job_out:
continue
cluster_id, cmd, _args, _arguments = job_out.split(attr_delimiter)
if _args == 'undefined' and _arguments != 'undefined':
args = _arguments.strip()
elif _args == 'undefined' and _arguments == 'undefined':
args = None
else:
args = _args.strip()
job_cmd = job.executable
job_args = job.arguments.strip() if job.arguments else None
if job_cmd in cmd and job_args == args:
log.info('Linking cluster_id %s to job with command and arguments: %s %s', cluster_id,
job_cmd, job_args)
job._cluster_id = int(cluster_id)
break
except ValueError as e:
log.warning(str(e)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:concat_cols; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 14; 4, identifier:df1; 5, identifier:df2; 6, identifier:idx_col; 7, identifier:df1_cols; 8, identifier:df2_cols; 9, identifier:df1_suffix; 10, identifier:df2_suffix; 11, default_parameter; 11, 12; 11, 13; 12, identifier:wc_cols; 13, list:[]; 14, default_parameter; 14, 15; 14, 16; 15, identifier:suffix_all; 16, False; 17, block; 17, 18; 17, 27; 17, 36; 17, 81; 17, 107; 17, 182; 17, 190; 17, 198; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:df1; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:df1; 24, identifier:set_index; 25, argument_list; 25, 26; 26, identifier:idx_col; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:df2; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:df2; 33, identifier:set_index; 34, argument_list; 34, 35; 35, identifier:idx_col; 36, if_statement; 36, 37; 36, 44; 37, not_operator; 37, 38; 38, comparison_operator:==; 38, 39; 38, 43; 39, call; 39, 40; 39, 41; 40, identifier:len; 41, argument_list; 41, 42; 42, identifier:wc_cols; 43, integer:0; 44, block; 44, 45; 45, for_statement; 45, 46; 45, 47; 45, 48; 46, identifier:wc; 47, identifier:wc_cols; 48, block; 48, 49; 48, 65; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:df1_cols; 52, binary_operator:+; 52, 53; 52, 54; 53, identifier:df1_cols; 54, list_comprehension; 54, 55; 54, 56; 54, 61; 55, identifier:c; 56, for_in_clause; 56, 57; 56, 58; 57, identifier:c; 58, attribute; 58, 59; 58, 60; 59, identifier:df1; 60, identifier:columns; 61, if_clause; 61, 62; 62, comparison_operator:in; 62, 63; 62, 64; 63, identifier:wc; 64, identifier:c; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:df2_cols; 68, binary_operator:+; 68, 69; 68, 70; 69, identifier:df2_cols; 70, list_comprehension; 70, 71; 70, 72; 70, 77; 71, identifier:c; 72, for_in_clause; 72, 73; 72, 74; 73, identifier:c; 74, attribute; 74, 75; 74, 76; 75, identifier:df2; 76, identifier:columns; 77, if_clause; 77, 78; 78, comparison_operator:in; 78, 79; 78, 80; 79, identifier:wc; 80, identifier:c; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:combo; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:pd; 87, identifier:concat; 88, argument_list; 88, 89; 88, 104; 89, list:[df1.loc[:,df1_cols],df2.loc[:,df2_cols]]; 89, 90; 89, 97; 90, subscript; 90, 91; 90, 94; 90, 96; 91, attribute; 91, 92; 91, 93; 92, identifier:df1; 93, identifier:loc; 94, slice; 94, 95; 95, colon; 96, identifier:df1_cols; 97, subscript; 97, 98; 97, 101; 97, 103; 98, attribute; 98, 99; 98, 100; 99, identifier:df2; 100, identifier:loc; 101, slice; 101, 102; 102, colon; 103, identifier:df2_cols; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:axis; 106, integer:1; 107, if_statement; 107, 108; 107, 109; 107, 134; 108, identifier:suffix_all; 109, block; 109, 110; 109, 122; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:df1_cols; 113, list_comprehension; 113, 114; 113, 119; 114, binary_operator:%; 114, 115; 114, 116; 115, string:"%s%s"; 116, tuple; 116, 117; 116, 118; 117, identifier:c; 118, identifier:df1_suffix; 119, for_in_clause; 119, 120; 119, 121; 120, identifier:c; 121, identifier:df1_cols; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:df2_cols; 125, list_comprehension; 125, 126; 125, 131; 126, binary_operator:%; 126, 127; 126, 128; 127, string:"%s%s"; 128, tuple; 128, 129; 128, 130; 129, identifier:c; 130, identifier:df2_suffix; 131, for_in_clause; 131, 132; 131, 133; 132, identifier:c; 133, identifier:df2_cols; 134, else_clause; 134, 135; 135, block; 135, 136; 135, 148; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:common_cols; 139, list_comprehension; 139, 140; 139, 141; 139, 144; 140, identifier:col; 141, for_in_clause; 141, 142; 141, 143; 142, identifier:col; 143, identifier:df1_cols; 144, if_clause; 144, 145; 145, comparison_operator:in; 145, 146; 145, 147; 146, identifier:col; 147, identifier:df2_cols; 148, for_statement; 148, 149; 148, 150; 148, 151; 149, identifier:col; 150, identifier:common_cols; 151, block; 151, 152; 151, 167; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 162; 154, subscript; 154, 155; 154, 156; 155, identifier:df1_cols; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:df1_cols; 159, identifier:index; 160, argument_list; 160, 161; 161, identifier:col; 162, binary_operator:%; 162, 163; 162, 164; 163, string:"%s%s"; 164, tuple; 164, 165; 164, 166; 165, identifier:col; 166, identifier:df1_suffix; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 177; 169, subscript; 169, 170; 169, 171; 170, identifier:df2_cols; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:df2_cols; 174, identifier:index; 175, argument_list; 175, 176; 176, identifier:col; 177, binary_operator:%; 177, 178; 177, 179; 178, string:"%s%s"; 179, tuple; 179, 180; 179, 181; 180, identifier:col; 181, identifier:df2_suffix; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:combo; 186, identifier:columns; 187, binary_operator:+; 187, 188; 187, 189; 188, identifier:df1_cols; 189, identifier:df2_cols; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 197; 192, attribute; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:combo; 195, identifier:index; 196, identifier:name; 197, identifier:idx_col; 198, return_statement; 198, 199; 199, identifier:combo | def concat_cols(df1,df2,idx_col,df1_cols,df2_cols,
df1_suffix,df2_suffix,wc_cols=[],suffix_all=False):
df1=df1.set_index(idx_col)
df2=df2.set_index(idx_col)
if not len(wc_cols)==0:
for wc in wc_cols:
df1_cols=df1_cols+[c for c in df1.columns if wc in c]
df2_cols=df2_cols+[c for c in df2.columns if wc in c]
combo=pd.concat([df1.loc[:,df1_cols],df2.loc[:,df2_cols]],axis=1)
if suffix_all:
df1_cols=["%s%s" % (c,df1_suffix) for c in df1_cols]
df2_cols=["%s%s" % (c,df2_suffix) for c in df2_cols]
else:
common_cols=[col for col in df1_cols if col in df2_cols]
for col in common_cols:
df1_cols[df1_cols.index(col)]="%s%s" % (col,df1_suffix)
df2_cols[df2_cols.index(col)]="%s%s" % (col,df2_suffix)
combo.columns=df1_cols+df2_cols
combo.index.name=idx_col
return combo |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:to_json; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:indent; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort_keys; 10, True; 11, block; 11, 12; 12, return_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:json; 16, identifier:dumps; 17, argument_list; 17, 18; 17, 23; 17, 26; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:to_dict; 22, argument_list; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:indent; 25, identifier:indent; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:sort_keys; 28, identifier:sort_keys | def to_json(self, indent=None, sort_keys=True):
return json.dumps(self.to_dict(), indent=indent, sort_keys=sort_keys) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_validate_method_decoration; 3, parameters; 3, 4; 3, 5; 4, identifier:meta; 5, identifier:class_; 6, block; 6, 7; 6, 17; 6, 40; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:super_mro; 10, subscript; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:class_; 13, identifier:__mro__; 14, slice; 14, 15; 14, 16; 15, integer:1; 16, colon; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:own_methods; 20, generator_expression; 20, 21; 20, 24; 20, 35; 21, tuple; 21, 22; 21, 23; 22, identifier:name; 23, identifier:member; 24, for_in_clause; 24, 25; 24, 28; 25, pattern_list; 25, 26; 25, 27; 26, identifier:name; 27, identifier:member; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:class_; 32, identifier:__dict__; 33, identifier:items; 34, argument_list; 35, if_clause; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:is_method; 38, argument_list; 38, 39; 39, identifier:member; 40, for_statement; 40, 41; 40, 44; 40, 45; 41, pattern_list; 41, 42; 41, 43; 42, identifier:name; 43, identifier:method; 44, identifier:own_methods; 45, block; 45, 46; 45, 74; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 51; 48, pattern_list; 48, 49; 48, 50; 49, identifier:shadowed_method; 50, identifier:base_class; 51, call; 51, 52; 51, 53; 52, identifier:next; 53, argument_list; 53, 54; 53, 71; 54, generator_expression; 54, 55; 54, 62; 54, 65; 55, tuple; 55, 56; 55, 61; 56, call; 56, 57; 56, 58; 57, identifier:getattr; 58, argument_list; 58, 59; 58, 60; 59, identifier:base; 60, identifier:name; 61, identifier:base; 62, for_in_clause; 62, 63; 62, 64; 63, identifier:base; 64, identifier:super_mro; 65, if_clause; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:hasattr; 68, argument_list; 68, 69; 68, 70; 69, identifier:base; 70, identifier:name; 71, tuple; 71, 72; 71, 73; 72, None; 73, None; 74, if_statement; 74, 75; 74, 81; 74, 176; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:meta; 78, identifier:_is_override; 79, argument_list; 79, 80; 80, identifier:method; 81, block; 81, 82; 81, 100; 81, 122; 81, 131; 81, 167; 82, if_statement; 82, 83; 82, 85; 83, not_operator; 83, 84; 84, identifier:shadowed_method; 85, block; 85, 86; 86, raise_statement; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:ClassError; 89, argument_list; 89, 90; 89, 97; 90, binary_operator:%; 90, 91; 90, 92; 91, string:"unnecessary @override on %s.%s"; 92, tuple; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:class_; 95, identifier:__name__; 96, identifier:name; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:class_; 99, identifier:class_; 100, if_statement; 100, 101; 100, 107; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:meta; 104, identifier:_is_final; 105, argument_list; 105, 106; 106, identifier:shadowed_method; 107, block; 107, 108; 108, raise_statement; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:ClassError; 111, argument_list; 111, 112; 111, 119; 112, binary_operator:%; 112, 113; 112, 114; 113, string:"illegal @override on a @final method %s.%s"; 114, tuple; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:base_class; 117, identifier:__name__; 118, identifier:name; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:class_; 121, identifier:class_; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:override_base; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:meta; 128, identifier:_get_override_base; 129, argument_list; 129, 130; 130, identifier:method; 131, if_statement; 131, 132; 131, 137; 132, boolean_operator:and; 132, 133; 132, 134; 133, identifier:override_base; 134, comparison_operator:is; 134, 135; 134, 136; 135, identifier:base_class; 136, identifier:override_base; 137, block; 137, 138; 138, if_statement; 138, 139; 138, 143; 138, 157; 139, call; 139, 140; 139, 141; 140, identifier:is_class; 141, argument_list; 141, 142; 142, identifier:override_base; 143, block; 143, 144; 144, raise_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:ClassError; 147, argument_list; 147, 148; 148, binary_operator:%; 148, 149; 148, 150; 149, string:"incorrect override base: expected %s, got %s"; 150, tuple; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:base_class; 153, identifier:__name__; 154, attribute; 154, 155; 154, 156; 155, identifier:override_base; 156, identifier:__name__; 157, else_clause; 157, 158; 158, block; 158, 159; 159, raise_statement; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:ClassError; 162, argument_list; 162, 163; 163, binary_operator:%; 163, 164; 163, 165; 164, string:"invalid override base specified: %s"; 165, tuple; 165, 166; 166, identifier:override_base; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 170; 169, identifier:setattr; 170, argument_list; 170, 171; 170, 172; 170, 173; 171, identifier:class_; 172, identifier:name; 173, attribute; 173, 174; 173, 175; 174, identifier:method; 175, identifier:method; 176, else_clause; 176, 177; 177, block; 177, 178; 178, if_statement; 178, 179; 178, 186; 179, boolean_operator:and; 179, 180; 179, 181; 180, identifier:shadowed_method; 181, comparison_operator:not; 181, 182; 181, 183; 182, identifier:name; 183, attribute; 183, 184; 183, 185; 184, identifier:meta; 185, identifier:OVERRIDE_EXEMPTIONS; 186, block; 186, 187; 186, 224; 187, if_statement; 187, 188; 187, 194; 187, 209; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, identifier:meta; 191, identifier:_is_final; 192, argument_list; 192, 193; 193, identifier:shadowed_method; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:msg; 198, binary_operator:%; 198, 199; 198, 200; 199, string:"%s.%s is hiding a @final method %s.%s"; 200, tuple; 200, 201; 200, 204; 200, 205; 200, 208; 201, attribute; 201, 202; 201, 203; 202, identifier:class_; 203, identifier:__name__; 204, identifier:name; 205, attribute; 205, 206; 205, 207; 206, identifier:base_class; 207, identifier:__name__; 208, identifier:name; 209, else_clause; 209, 210; 210, block; 210, 211; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:msg; 214, parenthesized_expression; 214, 215; 215, binary_operator:%; 215, 216; 215, 219; 216, concatenated_string; 216, 217; 216, 218; 217, string:"overridden method %s.%s "; 218, string:"must be marked with @override"; 219, tuple; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:class_; 222, identifier:__name__; 223, identifier:name; 224, raise_statement; 224, 225; 225, call; 225, 226; 225, 227; 226, identifier:ClassError; 227, argument_list; 227, 228; 227, 229; 228, identifier:msg; 229, keyword_argument; 229, 230; 229, 231; 230, identifier:class_; 231, identifier:class_ | def _validate_method_decoration(meta, class_):
super_mro = class_.__mro__[1:]
own_methods = ((name, member)
for name, member in class_.__dict__.items()
if is_method(member))
for name, method in own_methods:
shadowed_method, base_class = next(
((getattr(base, name), base)
for base in super_mro if hasattr(base, name)),
(None, None)
)
if meta._is_override(method):
if not shadowed_method:
raise ClassError("unnecessary @override on %s.%s" % (
class_.__name__, name), class_=class_)
if meta._is_final(shadowed_method):
raise ClassError(
"illegal @override on a @final method %s.%s" % (
base_class.__name__, name), class_=class_)
override_base = meta._get_override_base(method)
if override_base and base_class is not override_base:
if is_class(override_base):
raise ClassError(
"incorrect override base: expected %s, got %s" % (
base_class.__name__, override_base.__name__))
else:
raise ClassError(
"invalid override base specified: %s" % (
override_base,))
setattr(class_, name, method.method)
else:
if shadowed_method and name not in meta.OVERRIDE_EXEMPTIONS:
if meta._is_final(shadowed_method):
msg = "%s.%s is hiding a @final method %s.%s" % (
class_.__name__, name, base_class.__name__, name)
else:
msg = ("overridden method %s.%s "
"must be marked with @override" % (
class_.__name__, name))
raise ClassError(msg, class_=class_) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_parse_status; 3, parameters; 3, 4; 4, identifier:bug_el; 5, block; 5, 6; 5, 12; 5, 40; 5, 57; 5, 74; 5, 97; 5, 109; 5, 121; 5, 133; 5, 145; 5, 168; 5, 191; 5, 214; 5, 239; 5, 264; 5, 285; 5, 302; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:bug; 9, call; 9, 10; 9, 11; 10, identifier:Bugreport; 11, argument_list; 12, for_statement; 12, 13; 12, 14; 12, 26; 13, identifier:field; 14, tuple; 14, 15; 14, 16; 14, 17; 14, 18; 14, 19; 14, 20; 14, 21; 14, 22; 14, 23; 14, 24; 14, 25; 15, string:'originator'; 16, string:'subject'; 17, string:'msgid'; 18, string:'package'; 19, string:'severity'; 20, string:'owner'; 21, string:'summary'; 22, string:'location'; 23, string:'source'; 24, string:'pending'; 25, string:'forwarded'; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:setattr; 30, argument_list; 30, 31; 30, 32; 30, 33; 31, identifier:bug; 32, identifier:field; 33, call; 33, 34; 33, 35; 34, identifier:_parse_string_el; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:bug_el; 38, argument_list; 38, 39; 39, identifier:field; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:bug; 44, identifier:date; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:datetime; 48, identifier:utcfromtimestamp; 49, argument_list; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:float; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:bug_el; 55, argument_list; 55, 56; 56, string:'date'; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:bug; 61, identifier:log_modified; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:datetime; 65, identifier:utcfromtimestamp; 66, argument_list; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:float; 69, argument_list; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:bug_el; 72, argument_list; 72, 73; 73, string:'log_modified'; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:bug; 78, identifier:tags; 79, list_comprehension; 79, 80; 79, 84; 80, call; 80, 81; 80, 82; 81, identifier:_uc; 82, argument_list; 82, 83; 83, identifier:tag; 84, for_in_clause; 84, 85; 84, 86; 85, identifier:tag; 86, call; 86, 87; 86, 96; 87, attribute; 87, 88; 87, 95; 88, call; 88, 89; 88, 90; 89, identifier:str; 90, argument_list; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:bug_el; 93, argument_list; 93, 94; 94, string:'tags'; 95, identifier:split; 96, argument_list; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:bug; 101, identifier:done; 102, call; 102, 103; 102, 104; 103, identifier:_parse_bool; 104, argument_list; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:bug_el; 107, argument_list; 107, 108; 108, string:'done'; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:bug; 113, identifier:archived; 114, call; 114, 115; 114, 116; 115, identifier:_parse_bool; 116, argument_list; 116, 117; 117, call; 117, 118; 117, 119; 118, identifier:bug_el; 119, argument_list; 119, 120; 120, string:'archived'; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:bug; 125, identifier:unarchived; 126, call; 126, 127; 126, 128; 127, identifier:_parse_bool; 128, argument_list; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:bug_el; 131, argument_list; 131, 132; 132, string:'unarchived'; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:bug; 137, identifier:bug_num; 138, call; 138, 139; 138, 140; 139, identifier:int; 140, argument_list; 140, 141; 141, call; 141, 142; 141, 143; 142, identifier:bug_el; 143, argument_list; 143, 144; 144, string:'bug_num'; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:bug; 149, identifier:mergedwith; 150, list_comprehension; 150, 151; 150, 155; 151, call; 151, 152; 151, 153; 152, identifier:int; 153, argument_list; 153, 154; 154, identifier:i; 155, for_in_clause; 155, 156; 155, 157; 156, identifier:i; 157, call; 157, 158; 157, 167; 158, attribute; 158, 159; 158, 166; 159, call; 159, 160; 159, 161; 160, identifier:str; 161, argument_list; 161, 162; 162, call; 162, 163; 162, 164; 163, identifier:bug_el; 164, argument_list; 164, 165; 165, string:'mergedwith'; 166, identifier:split; 167, argument_list; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:bug; 172, identifier:blockedby; 173, list_comprehension; 173, 174; 173, 178; 174, call; 174, 175; 174, 176; 175, identifier:int; 176, argument_list; 176, 177; 177, identifier:i; 178, for_in_clause; 178, 179; 178, 180; 179, identifier:i; 180, call; 180, 181; 180, 190; 181, attribute; 181, 182; 181, 189; 182, call; 182, 183; 182, 184; 183, identifier:str; 184, argument_list; 184, 185; 185, call; 185, 186; 185, 187; 186, identifier:bug_el; 187, argument_list; 187, 188; 188, string:'blockedby'; 189, identifier:split; 190, argument_list; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:bug; 195, identifier:blocks; 196, list_comprehension; 196, 197; 196, 201; 197, call; 197, 198; 197, 199; 198, identifier:int; 199, argument_list; 199, 200; 200, identifier:i; 201, for_in_clause; 201, 202; 201, 203; 202, identifier:i; 203, call; 203, 204; 203, 213; 204, attribute; 204, 205; 204, 212; 205, call; 205, 206; 205, 207; 206, identifier:str; 207, argument_list; 207, 208; 208, call; 208, 209; 208, 210; 209, identifier:bug_el; 210, argument_list; 210, 211; 211, string:'blocks'; 212, identifier:split; 213, argument_list; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:bug; 218, identifier:found_versions; 219, list_comprehension; 219, 220; 219, 227; 220, call; 220, 221; 220, 222; 221, identifier:_uc; 222, argument_list; 222, 223; 223, call; 223, 224; 223, 225; 224, identifier:str; 225, argument_list; 225, 226; 226, identifier:el; 227, for_in_clause; 227, 228; 227, 229; 228, identifier:el; 229, boolean_operator:or; 229, 230; 229, 238; 230, call; 230, 231; 230, 237; 231, attribute; 231, 232; 231, 236; 232, call; 232, 233; 232, 234; 233, identifier:bug_el; 234, argument_list; 234, 235; 235, string:'found_versions'; 236, identifier:children; 237, argument_list; 238, list:[]; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:bug; 243, identifier:fixed_versions; 244, list_comprehension; 244, 245; 244, 252; 245, call; 245, 246; 245, 247; 246, identifier:_uc; 247, argument_list; 247, 248; 248, call; 248, 249; 248, 250; 249, identifier:str; 250, argument_list; 250, 251; 251, identifier:el; 252, for_in_clause; 252, 253; 252, 254; 253, identifier:el; 254, boolean_operator:or; 254, 255; 254, 263; 255, call; 255, 256; 255, 262; 256, attribute; 256, 257; 256, 261; 257, call; 257, 258; 257, 259; 258, identifier:bug_el; 259, argument_list; 259, 260; 260, string:'fixed_versions'; 261, identifier:children; 262, argument_list; 263, list:[]; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:affects; 267, list_comprehension; 267, 268; 267, 269; 267, 283; 268, identifier:_f; 269, for_in_clause; 269, 270; 269, 271; 270, identifier:_f; 271, call; 271, 272; 271, 281; 272, attribute; 272, 273; 272, 280; 273, call; 273, 274; 273, 275; 274, identifier:str; 275, argument_list; 275, 276; 276, call; 276, 277; 276, 278; 277, identifier:bug_el; 278, argument_list; 278, 279; 279, string:'affects'; 280, identifier:split; 281, argument_list; 281, 282; 282, string:','; 283, if_clause; 283, 284; 284, identifier:_f; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:bug; 289, identifier:affects; 290, list_comprehension; 290, 291; 290, 299; 291, call; 291, 292; 291, 298; 292, attribute; 292, 293; 292, 297; 293, call; 293, 294; 293, 295; 294, identifier:_uc; 295, argument_list; 295, 296; 296, identifier:a; 297, identifier:strip; 298, argument_list; 299, for_in_clause; 299, 300; 299, 301; 300, identifier:a; 301, identifier:affects; 302, return_statement; 302, 303; 303, identifier:bug | def _parse_status(bug_el):
bug = Bugreport()
for field in ('originator', 'subject', 'msgid', 'package', 'severity',
'owner', 'summary', 'location', 'source', 'pending',
'forwarded'):
setattr(bug, field, _parse_string_el(bug_el(field)))
bug.date = datetime.utcfromtimestamp(float(bug_el('date')))
bug.log_modified = datetime.utcfromtimestamp(float(bug_el('log_modified')))
bug.tags = [_uc(tag) for tag in str(bug_el('tags')).split()]
bug.done = _parse_bool(bug_el('done'))
bug.archived = _parse_bool(bug_el('archived'))
bug.unarchived = _parse_bool(bug_el('unarchived'))
bug.bug_num = int(bug_el('bug_num'))
bug.mergedwith = [int(i) for i in str(bug_el('mergedwith')).split()]
bug.blockedby = [int(i) for i in str(bug_el('blockedby')).split()]
bug.blocks = [int(i) for i in str(bug_el('blocks')).split()]
bug.found_versions = [_uc(str(el)) for el in
bug_el('found_versions').children() or []]
bug.fixed_versions = [_uc(str(el)) for el in
bug_el('fixed_versions').children() or []]
affects = [_f for _f in str(bug_el('affects')).split(',') if _f]
bug.affects = [_uc(a).strip() for a in affects]
return bug |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:set; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:attr; 6, identifier:value; 7, block; 7, 8; 7, 62; 7, 73; 7, 100; 7, 123; 7, 141; 7, 166; 7, 237; 8, function_definition; 8, 9; 8, 10; 8, 15; 9, function_name:escape_new_syntax; 10, parameters; 10, 11; 10, 12; 11, identifier:value; 12, default_parameter; 12, 13; 12, 14; 13, identifier:double_quote_escape; 14, string:'"'; 15, block; 15, 16; 15, 23; 15, 33; 15, 45; 15, 60; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:value; 19, call; 19, 20; 19, 21; 20, identifier:str; 21, argument_list; 21, 22; 22, identifier:value; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:value; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:value; 29, identifier:replace; 30, argument_list; 30, 31; 30, 32; 31, string:"'"; 32, string:"''"; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:value; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:value; 39, identifier:replace; 40, argument_list; 40, 41; 40, 42; 41, string:'"'; 42, binary_operator:%; 42, 43; 42, 44; 43, string:'%s"'; 44, identifier:double_quote_escape; 45, if_statement; 45, 46; 45, 53; 46, boolean_operator:or; 46, 47; 46, 50; 47, comparison_operator:in; 47, 48; 47, 49; 48, string:' '; 49, identifier:value; 50, comparison_operator:in; 50, 51; 50, 52; 51, string:'\t'; 52, identifier:value; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:value; 57, binary_operator:%; 57, 58; 57, 59; 58, string:"'%s'"; 59, identifier:value; 60, return_statement; 60, 61; 61, identifier:value; 62, function_definition; 62, 63; 62, 64; 62, 66; 63, function_name:escape_new_syntax_pre_post_script; 64, parameters; 64, 65; 65, identifier:value; 66, block; 66, 67; 67, return_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:escape_new_syntax; 70, argument_list; 70, 71; 70, 72; 71, identifier:value; 72, string:'\\'; 73, function_definition; 73, 74; 73, 75; 73, 77; 74, function_name:escape_remap; 75, parameters; 75, 76; 76, identifier:value; 77, block; 77, 78; 77, 88; 77, 98; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:value; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:value; 84, identifier:replace; 85, argument_list; 85, 86; 85, 87; 86, string:'='; 87, string:'\='; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:value; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:value; 94, identifier:replace; 95, argument_list; 95, 96; 95, 97; 96, string:';'; 97, string:'\;'; 98, return_statement; 98, 99; 99, identifier:value; 100, function_definition; 100, 101; 100, 102; 100, 105; 101, function_name:join_function_template; 102, parameters; 102, 103; 102, 104; 103, identifier:join_string; 104, identifier:escape_func; 105, block; 105, 106; 106, return_statement; 106, 107; 107, lambda; 107, 108; 107, 110; 108, lambda_parameters; 108, 109; 109, identifier:value; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:join_string; 113, identifier:join; 114, argument_list; 114, 115; 115, list_comprehension; 115, 116; 115, 120; 116, call; 116, 117; 116, 118; 117, identifier:escape_func; 118, argument_list; 118, 119; 119, identifier:i; 120, for_in_clause; 120, 121; 120, 122; 121, identifier:i; 122, identifier:value; 123, function_definition; 123, 124; 123, 125; 123, 128; 124, function_name:quote_join_function_template; 125, parameters; 125, 126; 125, 127; 126, identifier:join_string; 127, identifier:escape_func; 128, block; 128, 129; 129, return_statement; 129, 130; 130, lambda; 130, 131; 130, 133; 131, lambda_parameters; 131, 132; 132, identifier:value; 133, call; 133, 134; 133, 139; 134, call; 134, 135; 134, 136; 135, identifier:join_function_template; 136, argument_list; 136, 137; 136, 138; 137, identifier:join_string; 138, identifier:escape_func; 139, argument_list; 139, 140; 140, identifier:value; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:join_functions; 144, dictionary; 144, 145; 144, 152; 144, 159; 145, pair; 145, 146; 145, 147; 146, string:'rempas'; 147, call; 147, 148; 147, 149; 148, identifier:quote_join_function_template; 149, argument_list; 149, 150; 149, 151; 150, string:'; '; 151, identifier:escape_remap; 152, pair; 152, 153; 152, 154; 153, string:'arguments'; 154, call; 154, 155; 154, 156; 155, identifier:quote_join_function_template; 156, argument_list; 156, 157; 156, 158; 157, string:' '; 158, identifier:escape_new_syntax; 159, pair; 159, 160; 159, 161; 160, string:'Arguments'; 161, call; 161, 162; 161, 163; 162, identifier:quote_join_function_template; 163, argument_list; 163, 164; 163, 165; 164, string:' '; 165, identifier:escape_new_syntax_pre_post_script; 166, if_statement; 166, 167; 166, 170; 166, 175; 166, 184; 167, comparison_operator:is; 167, 168; 167, 169; 168, identifier:value; 169, False; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:value; 174, string:'false'; 175, elif_clause; 175, 176; 175, 179; 176, comparison_operator:is; 176, 177; 176, 178; 177, identifier:value; 178, True; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:value; 183, string:'true'; 184, elif_clause; 184, 185; 184, 196; 185, boolean_operator:or; 185, 186; 185, 191; 186, call; 186, 187; 186, 188; 187, identifier:isinstance; 188, argument_list; 188, 189; 188, 190; 189, identifier:value; 190, identifier:list; 191, call; 191, 192; 191, 193; 192, identifier:isinstance; 193, argument_list; 193, 194; 193, 195; 194, identifier:value; 195, identifier:tuple; 196, block; 196, 197; 196, 205; 196, 230; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:join_function; 200, call; 200, 201; 200, 202; 201, identifier:join_function_template; 202, argument_list; 202, 203; 202, 204; 203, string:', '; 204, identifier:str; 205, for_statement; 205, 206; 205, 207; 205, 215; 206, identifier:key; 207, call; 207, 208; 207, 209; 208, identifier:list; 209, argument_list; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:join_functions; 213, identifier:keys; 214, argument_list; 215, block; 215, 216; 216, if_statement; 216, 217; 216, 223; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:attr; 220, identifier:endswith; 221, argument_list; 221, 222; 222, identifier:key; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 227; 226, identifier:join_function; 227, subscript; 227, 228; 227, 229; 228, identifier:join_functions; 229, identifier:key; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:value; 233, call; 233, 234; 233, 235; 234, identifier:join_function; 235, argument_list; 235, 236; 236, identifier:value; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 244; 239, subscript; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:self; 242, identifier:attributes; 243, identifier:attr; 244, identifier:value | def set(self, attr, value):
def escape_new_syntax(value, double_quote_escape='"'):
value = str(value)
value = value.replace("'", "''")
value = value.replace('"', '%s"' % double_quote_escape)
if ' ' in value or '\t' in value:
value = "'%s'" % value
return value
def escape_new_syntax_pre_post_script(value):
return escape_new_syntax(value, '\\')
def escape_remap(value):
value = value.replace('=', '\=')
value = value.replace(';', '\;')
return value
def join_function_template(join_string, escape_func):
return lambda value: join_string.join([escape_func(i) for i in value])
def quote_join_function_template(join_string, escape_func):
return lambda value: join_function_template(join_string, escape_func)(value)
join_functions = {'rempas': quote_join_function_template('; ', escape_remap),
'arguments': quote_join_function_template(' ', escape_new_syntax),
'Arguments': quote_join_function_template(' ', escape_new_syntax_pre_post_script)
}
if value is False:
value = 'false'
elif value is True:
value = 'true'
elif isinstance(value, list) or isinstance(value, tuple):
join_function = join_function_template(', ', str)
for key in list(join_functions.keys()):
if attr.endswith(key):
join_function = join_functions[key]
value = join_function(value)
self.attributes[attr] = value |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_update_status; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sub_job_num; 7, None; 8, block; 8, 9; 8, 27; 8, 34; 8, 49; 8, 54; 8, 71; 8, 88; 8, 105; 8, 115; 8, 124; 8, 177; 8, 183; 8, 197; 8, 230; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:job_id; 12, conditional_expression:if; 12, 13; 12, 20; 12, 21; 13, binary_operator:%; 13, 14; 13, 15; 14, string:'%s.%s'; 15, tuple; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:cluster_id; 19, identifier:sub_job_num; 20, identifier:sub_job_num; 21, call; 21, 22; 21, 23; 22, identifier:str; 23, argument_list; 23, 24; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:cluster_id; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:format; 30, list:['-format', '"%d"', 'JobStatus']; 30, 31; 30, 32; 30, 33; 31, string:'-format'; 32, string:'"%d"'; 33, string:'JobStatus'; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:cmd; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, string:'condor_q {0} {1} && condor_history {0} {1}'; 40, identifier:format; 41, argument_list; 41, 42; 41, 43; 42, identifier:job_id; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, string:' '; 46, identifier:join; 47, argument_list; 47, 48; 48, identifier:format; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:args; 52, list:[cmd]; 52, 53; 53, identifier:cmd; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, pattern_list; 56, 57; 56, 58; 57, identifier:out; 58, identifier:err; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:_execute; 63, argument_list; 63, 64; 63, 65; 63, 68; 64, identifier:args; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:shell; 67, True; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:run_in_job_dir; 70, False; 71, if_statement; 71, 72; 71, 73; 72, identifier:err; 73, block; 73, 74; 73, 83; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:log; 78, identifier:error; 79, argument_list; 79, 80; 79, 81; 79, 82; 80, string:'Error while updating status for job %s: %s'; 81, identifier:job_id; 82, identifier:err; 83, raise_statement; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:HTCondorError; 86, argument_list; 86, 87; 87, identifier:err; 88, if_statement; 88, 89; 88, 91; 89, not_operator; 89, 90; 90, identifier:out; 91, block; 91, 92; 91, 100; 92, expression_statement; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:log; 96, identifier:error; 97, argument_list; 97, 98; 97, 99; 98, string:'Error while updating status for job %s: Job not found.'; 99, identifier:job_id; 100, raise_statement; 100, 101; 101, call; 101, 102; 101, 103; 102, identifier:HTCondorError; 103, argument_list; 103, 104; 104, string:'Job not found.'; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:out; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:out; 111, identifier:replace; 112, argument_list; 112, 113; 112, 114; 113, string:'\"'; 114, string:''; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:log; 119, identifier:info; 120, argument_list; 120, 121; 120, 122; 120, 123; 121, string:'Job %s status: %s'; 122, identifier:job_id; 123, identifier:out; 124, if_statement; 124, 125; 124, 127; 125, not_operator; 125, 126; 126, identifier:sub_job_num; 127, block; 127, 128; 128, if_statement; 128, 129; 128, 137; 128, 148; 129, comparison_operator:>=; 129, 130; 129, 134; 130, call; 130, 131; 130, 132; 131, identifier:len; 132, argument_list; 132, 133; 133, identifier:out; 134, attribute; 134, 135; 134, 136; 135, identifier:self; 136, identifier:num_jobs; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:out; 141, subscript; 141, 142; 141, 143; 142, identifier:out; 143, slice; 143, 144; 143, 145; 144, colon; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:num_jobs; 148, else_clause; 148, 149; 149, block; 149, 150; 149, 165; 149, 172; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:msg; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, string:'There are {0} sub-jobs, but {1} status(es).'; 156, identifier:format; 157, argument_list; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:num_jobs; 161, call; 161, 162; 161, 163; 162, identifier:len; 163, argument_list; 163, 164; 164, identifier:out; 165, expression_statement; 165, 166; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:log; 169, identifier:error; 170, argument_list; 170, 171; 171, identifier:msg; 172, raise_statement; 172, 173; 173, call; 173, 174; 173, 175; 174, identifier:HTCondorError; 175, argument_list; 175, 176; 176, identifier:msg; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:status_dict; 180, call; 180, 181; 180, 182; 181, identifier:dict; 182, argument_list; 183, for_statement; 183, 184; 183, 185; 183, 190; 184, identifier:val; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:CONDOR_JOB_STATUSES; 188, identifier:values; 189, argument_list; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 196; 193, subscript; 193, 194; 193, 195; 194, identifier:status_dict; 195, identifier:val; 196, integer:0; 197, for_statement; 197, 198; 197, 199; 197, 200; 198, identifier:status_code_str; 199, identifier:out; 200, block; 200, 201; 200, 205; 200, 218; 200, 224; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:status_code; 204, integer:0; 205, try_statement; 205, 206; 205, 214; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:status_code; 210, call; 210, 211; 210, 212; 211, identifier:int; 212, argument_list; 212, 213; 213, identifier:status_code_str; 214, except_clause; 214, 215; 214, 216; 215, identifier:ValueError; 216, block; 216, 217; 217, pass_statement; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:key; 221, subscript; 221, 222; 221, 223; 222, identifier:CONDOR_JOB_STATUSES; 223, identifier:status_code; 224, expression_statement; 224, 225; 225, augmented_assignment:+=; 225, 226; 225, 229; 226, subscript; 226, 227; 226, 228; 227, identifier:status_dict; 228, identifier:key; 229, integer:1; 230, return_statement; 230, 231; 231, identifier:status_dict | def _update_status(self, sub_job_num=None):
job_id = '%s.%s' % (self.cluster_id, sub_job_num) if sub_job_num else str(self.cluster_id)
format = ['-format', '"%d"', 'JobStatus']
cmd = 'condor_q {0} {1} && condor_history {0} {1}'.format(job_id, ' '.join(format))
args = [cmd]
out, err = self._execute(args, shell=True, run_in_job_dir=False)
if err:
log.error('Error while updating status for job %s: %s', job_id, err)
raise HTCondorError(err)
if not out:
log.error('Error while updating status for job %s: Job not found.', job_id)
raise HTCondorError('Job not found.')
out = out.replace('\"', '')
log.info('Job %s status: %s', job_id, out)
if not sub_job_num:
if len(out) >= self.num_jobs:
out = out[:self.num_jobs]
else:
msg = 'There are {0} sub-jobs, but {1} status(es).'.format(self.num_jobs, len(out))
log.error(msg)
raise HTCondorError(msg)
status_dict = dict()
for val in CONDOR_JOB_STATUSES.values():
status_dict[val] = 0
for status_code_str in out:
status_code = 0
try:
status_code = int(status_code_str)
except ValueError:
pass
key = CONDOR_JOB_STATUSES[status_code]
status_dict[key] += 1
return status_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:mangle; 3, parameters; 3, 4; 4, identifier:text; 5, block; 5, 6; 5, 15; 5, 22; 5, 28; 5, 34; 5, 39; 5, 43; 5, 47; 5, 51; 5, 60; 5, 292; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:text_bytes; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:text; 12, identifier:encode; 13, argument_list; 13, 14; 14, string:'utf-8'; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:buff; 18, call; 18, 19; 18, 20; 19, identifier:BytesIO; 20, argument_list; 20, 21; 21, identifier:text_bytes; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:mangled; 25, call; 25, 26; 25, 27; 26, identifier:BytesIO; 27, argument_list; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:last_tok; 31, attribute; 31, 32; 31, 33; 32, identifier:token; 33, identifier:INDENT; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:last_line; 37, unary_operator:-; 37, 38; 38, integer:1; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:last_col; 42, integer:0; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:last_line_text; 46, string:''; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:open_list_dicts; 50, integer:0; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:tokens; 54, call; 54, 55; 54, 56; 55, identifier:tokenizer; 56, argument_list; 56, 57; 57, attribute; 57, 58; 57, 59; 58, identifier:buff; 59, identifier:readline; 60, for_statement; 60, 61; 60, 71; 60, 72; 61, pattern_list; 61, 62; 61, 63; 61, 64; 61, 67; 61, 70; 62, identifier:t; 63, identifier:text; 64, tuple_pattern; 64, 65; 64, 66; 65, identifier:line_s; 66, identifier:col_s; 67, tuple_pattern; 67, 68; 67, 69; 68, identifier:line_e; 69, identifier:col_e; 70, identifier:line; 71, identifier:tokens; 72, block; 72, 73; 72, 108; 72, 116; 72, 128; 72, 140; 72, 166; 72, 276; 72, 280; 72, 284; 72, 288; 73, if_statement; 73, 74; 73, 82; 74, boolean_operator:and; 74, 75; 74, 78; 75, comparison_operator:>; 75, 76; 75, 77; 76, identifier:line_s; 77, identifier:last_line; 78, comparison_operator:!=; 78, 79; 78, 80; 79, identifier:last_line; 80, unary_operator:-; 80, 81; 81, integer:1; 82, block; 82, 83; 82, 87; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:last_col; 86, integer:0; 87, if_statement; 87, 88; 87, 100; 88, comparison_operator:==; 88, 89; 88, 99; 89, subscript; 89, 90; 89, 95; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:last_line_text; 93, identifier:rstrip; 94, argument_list; 95, slice; 95, 96; 95, 98; 96, unary_operator:-; 96, 97; 97, integer:1; 98, colon; 99, string:'\\'; 100, block; 100, 101; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:mangled; 105, identifier:write; 106, argument_list; 106, 107; 107, string:b' \\\n'; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:striped; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:text; 114, identifier:strip; 115, argument_list; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:list_dict_open; 119, list:[token.LSQB, token.LBRACE, '[', '{']; 119, 120; 119, 123; 119, 126; 119, 127; 120, attribute; 120, 121; 120, 122; 121, identifier:token; 122, identifier:LSQB; 123, attribute; 123, 124; 123, 125; 124, identifier:token; 125, identifier:LBRACE; 126, string:'['; 127, string:'{'; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:list_dict_close; 131, list:[token.RSQB, token.RBRACE, ']', '}']; 131, 132; 131, 135; 131, 138; 131, 139; 132, attribute; 132, 133; 132, 134; 133, identifier:token; 134, identifier:RSQB; 135, attribute; 135, 136; 135, 137; 136, identifier:token; 137, identifier:RBRACE; 138, string:']'; 139, string:'}'; 140, if_statement; 140, 141; 140, 148; 140, 153; 141, boolean_operator:or; 141, 142; 141, 145; 142, comparison_operator:in; 142, 143; 142, 144; 143, identifier:t; 144, identifier:list_dict_open; 145, comparison_operator:in; 145, 146; 145, 147; 146, identifier:striped; 147, identifier:list_dict_open; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, augmented_assignment:+=; 150, 151; 150, 152; 151, identifier:open_list_dicts; 152, integer:1; 153, elif_clause; 153, 154; 153, 161; 154, boolean_operator:or; 154, 155; 154, 158; 155, comparison_operator:in; 155, 156; 155, 157; 156, identifier:t; 157, identifier:list_dict_close; 158, comparison_operator:in; 158, 159; 158, 160; 159, identifier:striped; 160, identifier:list_dict_close; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, augmented_assignment:-=; 163, 164; 163, 165; 164, identifier:open_list_dicts; 165, integer:1; 166, if_statement; 166, 167; 166, 209; 166, 230; 166, 238; 167, boolean_operator:and; 167, 168; 167, 173; 168, comparison_operator:==; 168, 169; 168, 170; 169, identifier:t; 170, attribute; 170, 171; 170, 172; 171, identifier:token; 172, identifier:STRING; 173, parenthesized_expression; 173, 174; 174, boolean_operator:or; 174, 175; 174, 180; 175, comparison_operator:==; 175, 176; 175, 177; 176, identifier:last_tok; 177, attribute; 177, 178; 177, 179; 178, identifier:token; 179, identifier:INDENT; 180, parenthesized_expression; 180, 181; 181, boolean_operator:and; 181, 182; 181, 206; 182, parenthesized_expression; 182, 183; 183, boolean_operator:or; 183, 184; 183, 201; 184, boolean_operator:or; 184, 185; 184, 196; 185, boolean_operator:or; 185, 186; 185, 191; 186, comparison_operator:==; 186, 187; 186, 188; 187, identifier:last_tok; 188, attribute; 188, 189; 188, 190; 189, identifier:token; 190, identifier:NEWLINE; 191, comparison_operator:==; 191, 192; 191, 193; 192, identifier:last_tok; 193, attribute; 193, 194; 193, 195; 194, identifier:tokenize; 195, identifier:NL; 196, comparison_operator:==; 196, 197; 196, 198; 197, identifier:last_tok; 198, attribute; 198, 199; 198, 200; 199, identifier:token; 200, identifier:DEDENT; 201, comparison_operator:==; 201, 202; 201, 203; 202, identifier:last_tok; 203, attribute; 203, 204; 203, 205; 204, identifier:tokenize; 205, identifier:ENCODING; 206, comparison_operator:==; 206, 207; 206, 208; 207, identifier:open_list_dicts; 208, integer:0; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:mangled; 214, identifier:write; 215, argument_list; 215, 216; 216, binary_operator:*; 216, 217; 216, 218; 217, string:b'\n'; 218, parenthesized_expression; 218, 219; 219, binary_operator:-; 219, 220; 219, 229; 220, call; 220, 221; 220, 222; 221, identifier:len; 222, argument_list; 222, 223; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:text; 226, identifier:split; 227, argument_list; 227, 228; 228, string:'\n'; 229, integer:1; 230, elif_clause; 230, 231; 230, 236; 231, comparison_operator:==; 231, 232; 231, 233; 232, identifier:t; 233, attribute; 233, 234; 233, 235; 234, identifier:tokenize; 235, identifier:COMMENT; 236, block; 236, 237; 237, pass_statement; 238, else_clause; 238, 239; 239, block; 239, 240; 239, 257; 240, if_statement; 240, 241; 240, 244; 241, comparison_operator:>; 241, 242; 241, 243; 242, identifier:col_s; 243, identifier:last_col; 244, block; 244, 245; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:mangled; 249, identifier:write; 250, argument_list; 250, 251; 251, binary_operator:*; 251, 252; 251, 253; 252, string:b' '; 253, parenthesized_expression; 253, 254; 254, binary_operator:-; 254, 255; 254, 256; 255, identifier:col_s; 256, identifier:last_col; 257, if_statement; 257, 258; 257, 263; 258, comparison_operator:!=; 258, 259; 258, 260; 259, identifier:t; 260, attribute; 260, 261; 260, 262; 261, identifier:tokenize; 262, identifier:ENCODING; 263, block; 263, 264; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:mangled; 268, identifier:write; 269, argument_list; 269, 270; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:text; 273, identifier:encode; 274, argument_list; 274, 275; 275, string:'utf-8'; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:last_tok; 279, identifier:t; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 283; 282, identifier:last_col; 283, identifier:col_e; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 287; 286, identifier:last_line; 287, identifier:line_e; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:last_line_text; 291, identifier:line; 292, return_statement; 292, 293; 293, call; 293, 294; 293, 301; 294, attribute; 294, 295; 294, 300; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:mangled; 298, identifier:getvalue; 299, argument_list; 300, identifier:decode; 301, argument_list; 301, 302; 302, string:'utf-8' | def mangle(text):
text_bytes = text.encode('utf-8')
buff = BytesIO(text_bytes)
mangled = BytesIO()
last_tok = token.INDENT
last_line = -1
last_col = 0
last_line_text = ''
open_list_dicts = 0
tokens = tokenizer(buff.readline)
for t, text, (line_s, col_s), (line_e, col_e), line in tokens:
if line_s > last_line and last_line != -1:
last_col = 0
if last_line_text.rstrip()[-1:] == '\\':
mangled.write(b' \\\n')
striped = text.strip()
list_dict_open = [token.LSQB, token.LBRACE, '[', '{']
list_dict_close = [token.RSQB, token.RBRACE, ']', '}']
if t in list_dict_open or striped in list_dict_open:
open_list_dicts += 1
elif t in list_dict_close or striped in list_dict_close:
open_list_dicts -= 1
if t == token.STRING and (last_tok == token.INDENT or (
(last_tok == token.NEWLINE or last_tok == tokenize.NL or
last_tok == token.DEDENT or last_tok == tokenize.ENCODING)
and open_list_dicts == 0)):
mangled.write(b'\n' * (len(text.split('\n')) - 1))
elif t == tokenize.COMMENT:
pass
else:
if col_s > last_col:
mangled.write(b' ' * (col_s - last_col))
if t != tokenize.ENCODING:
mangled.write(text.encode('utf-8'))
last_tok = t
last_col = col_e
last_line = line_e
last_line_text = line
return mangled.getvalue().decode('utf-8') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 1, 34; 2, function_name:get_array_from_hist2D; 3, parameters; 3, 4; 3, 8; 3, 13; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:hist; 6, type; 6, 7; 7, identifier:Hist; 8, typed_default_parameter; 8, 9; 8, 10; 8, 12; 9, identifier:set_zero_to_NaN; 10, type; 10, 11; 11, identifier:bool; 12, True; 13, typed_default_parameter; 13, 14; 13, 15; 13, 17; 14, identifier:return_bin_edges; 15, type; 15, 16; 16, identifier:bool; 17, False; 18, type; 18, 19; 19, generic_type; 19, 20; 19, 21; 20, identifier:Tuple; 21, type_parameter; 21, 22; 21, 26; 21, 30; 22, type; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:np; 25, identifier:ndarray; 26, type; 26, 27; 27, attribute; 27, 28; 27, 29; 28, identifier:np; 29, identifier:ndarray; 30, type; 30, 31; 31, attribute; 31, 32; 31, 33; 32, identifier:np; 33, identifier:ndarray; 34, block; 34, 35; 34, 57; 34, 99; 34, 108; 34, 114; 34, 127; 34, 294; 34, 306; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:shape; 38, tuple; 38, 39; 38, 48; 39, call; 39, 40; 39, 47; 40, attribute; 40, 41; 40, 46; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:hist; 44, identifier:GetYaxis; 45, argument_list; 46, identifier:GetNbins; 47, argument_list; 48, call; 48, 49; 48, 56; 49, attribute; 49, 50; 49, 55; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:hist; 53, identifier:GetXaxis; 54, argument_list; 55, identifier:GetNbins; 56, argument_list; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:hist_array; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:np; 63, identifier:array; 64, argument_list; 64, 65; 65, list_comprehension; 65, 66; 65, 72; 65, 83; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:hist; 69, identifier:GetBinContent; 70, argument_list; 70, 71; 71, identifier:x; 72, for_in_clause; 72, 73; 72, 74; 73, identifier:x; 74, call; 74, 75; 74, 76; 75, identifier:range; 76, argument_list; 76, 77; 76, 78; 77, integer:1; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:hist; 81, identifier:GetNcells; 82, argument_list; 83, if_clause; 83, 84; 84, boolean_operator:and; 84, 85; 84, 92; 85, not_operator; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:hist; 89, identifier:IsBinUnderflow; 90, argument_list; 90, 91; 91, identifier:x; 92, not_operator; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:hist; 96, identifier:IsBinOverflow; 97, argument_list; 97, 98; 98, identifier:x; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:hist_array; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:hist_array; 105, identifier:reshape; 106, argument_list; 106, 107; 107, identifier:shape; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:hist_array; 111, attribute; 111, 112; 111, 113; 112, identifier:hist_array; 113, identifier:T; 114, if_statement; 114, 115; 114, 116; 115, identifier:set_zero_to_NaN; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 124; 119, subscript; 119, 120; 119, 121; 120, identifier:hist_array; 121, comparison_operator:==; 121, 122; 121, 123; 122, identifier:hist_array; 123, integer:0; 124, attribute; 124, 125; 124, 126; 125, identifier:np; 126, identifier:nan; 127, if_statement; 127, 128; 127, 129; 127, 220; 128, identifier:return_bin_edges; 129, block; 129, 130; 129, 141; 129, 152; 129, 156; 129, 188; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:x_bin_edges; 133, call; 133, 134; 133, 135; 134, identifier:get_bin_edges_from_axis; 135, argument_list; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:hist; 139, identifier:GetXaxis; 140, argument_list; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:y_bin_edges; 144, call; 144, 145; 144, 146; 145, identifier:get_bin_edges_from_axis; 146, argument_list; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:hist; 150, identifier:GetYaxis; 151, argument_list; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:epsilon; 155, float:1e-9; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:x_range; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:np; 162, identifier:arange; 163, argument_list; 163, 164; 163, 170; 163, 178; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:np; 167, identifier:amin; 168, argument_list; 168, 169; 169, identifier:x_bin_edges; 170, binary_operator:+; 170, 171; 170, 177; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:np; 174, identifier:amax; 175, argument_list; 175, 176; 176, identifier:x_bin_edges; 177, identifier:epsilon; 178, call; 178, 179; 178, 186; 179, attribute; 179, 180; 179, 185; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:hist; 183, identifier:GetXaxis; 184, argument_list; 185, identifier:GetBinWidth; 186, argument_list; 186, 187; 187, integer:1; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:y_range; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:np; 194, identifier:arange; 195, argument_list; 195, 196; 195, 202; 195, 210; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:np; 199, identifier:amin; 200, argument_list; 200, 201; 201, identifier:y_bin_edges; 202, binary_operator:+; 202, 203; 202, 209; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:np; 206, identifier:amax; 207, argument_list; 207, 208; 208, identifier:y_bin_edges; 209, identifier:epsilon; 210, call; 210, 211; 210, 218; 211, attribute; 211, 212; 211, 217; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:hist; 215, identifier:GetYaxis; 216, argument_list; 217, identifier:GetBinWidth; 218, argument_list; 218, 219; 219, integer:1; 220, else_clause; 220, 221; 221, block; 221, 222; 221, 258; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:x_range; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:np; 228, identifier:array; 229, argument_list; 229, 230; 230, list_comprehension; 230, 231; 230, 241; 231, call; 231, 232; 231, 239; 232, attribute; 232, 233; 232, 238; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:hist; 236, identifier:GetXaxis; 237, argument_list; 238, identifier:GetBinCenter; 239, argument_list; 239, 240; 240, identifier:i; 241, for_in_clause; 241, 242; 241, 243; 242, identifier:i; 243, call; 243, 244; 243, 245; 244, identifier:range; 245, argument_list; 245, 246; 245, 247; 246, integer:1; 247, binary_operator:+; 247, 248; 247, 257; 248, call; 248, 249; 248, 256; 249, attribute; 249, 250; 249, 255; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:hist; 253, identifier:GetXaxis; 254, argument_list; 255, identifier:GetNbins; 256, argument_list; 257, integer:1; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:y_range; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:np; 264, identifier:array; 265, argument_list; 265, 266; 266, list_comprehension; 266, 267; 266, 277; 267, call; 267, 268; 267, 275; 268, attribute; 268, 269; 268, 274; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:hist; 272, identifier:GetYaxis; 273, argument_list; 274, identifier:GetBinCenter; 275, argument_list; 275, 276; 276, identifier:i; 277, for_in_clause; 277, 278; 277, 279; 278, identifier:i; 279, call; 279, 280; 279, 281; 280, identifier:range; 281, argument_list; 281, 282; 281, 283; 282, integer:1; 283, binary_operator:+; 283, 284; 283, 293; 284, call; 284, 285; 284, 292; 285, attribute; 285, 286; 285, 291; 286, call; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:hist; 289, identifier:GetYaxis; 290, argument_list; 291, identifier:GetNbins; 292, argument_list; 293, integer:1; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 299; 296, pattern_list; 296, 297; 296, 298; 297, identifier:X; 298, identifier:Y; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:np; 302, identifier:meshgrid; 303, argument_list; 303, 304; 303, 305; 304, identifier:x_range; 305, identifier:y_range; 306, return_statement; 306, 307; 307, tuple; 307, 308; 307, 309; 307, 310; 308, identifier:X; 309, identifier:Y; 310, identifier:hist_array | def get_array_from_hist2D(hist: Hist, set_zero_to_NaN: bool = True, return_bin_edges: bool = False) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
shape = (hist.GetYaxis().GetNbins(), hist.GetXaxis().GetNbins())
hist_array = np.array([hist.GetBinContent(x) for x in range(1, hist.GetNcells()) if not hist.IsBinUnderflow(x) and not hist.IsBinOverflow(x)])
hist_array = hist_array.reshape(shape)
hist_array = hist_array.T
if set_zero_to_NaN:
hist_array[hist_array == 0] = np.nan
if return_bin_edges:
x_bin_edges = get_bin_edges_from_axis(hist.GetXaxis())
y_bin_edges = get_bin_edges_from_axis(hist.GetYaxis())
epsilon = 1e-9
x_range = np.arange(
np.amin(x_bin_edges),
np.amax(x_bin_edges) + epsilon,
hist.GetXaxis().GetBinWidth(1)
)
y_range = np.arange(
np.amin(y_bin_edges),
np.amax(y_bin_edges) + epsilon,
hist.GetYaxis().GetBinWidth(1)
)
else:
x_range = np.array([hist.GetXaxis().GetBinCenter(i) for i in range(1, hist.GetXaxis().GetNbins() + 1)])
y_range = np.array([hist.GetYaxis().GetBinCenter(i) for i in range(1, hist.GetYaxis().GetNbins() + 1)])
X, Y = np.meshgrid(x_range, y_range)
return (X, Y, hist_array) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.