sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:get_entries; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:self; 5, identifier:chemsys_formula_id_criteria; 6, default_parameter; 6, 7; 6, 8; 7, identifier:compatible_only; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:inc_structure; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:property_data; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:conventional_unit_cell; 17, False; 18, default_parameter; 18, 19; 18, 20; 19, identifier:sort_by_e_above_hull; 20, False; 21, block; 21, 22; 21, 32; 21, 41; 21, 67; 21, 74; 21, 98; 21, 121; 21, 131; 21, 135; 21, 320; 21, 342; 21, 362; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:params; 25, list:["run_type", "is_hubbard", "pseudo_potential", "hubbards",
"potcar_symbols", "oxide_type"]; 25, 26; 25, 27; 25, 28; 25, 29; 25, 30; 25, 31; 26, string:"run_type"; 27, string:"is_hubbard"; 28, string:"pseudo_potential"; 29, string:"hubbards"; 30, string:"potcar_symbols"; 31, string:"oxide_type"; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:props; 35, binary_operator:+; 35, 36; 35, 40; 36, list:["energy", "unit_cell_formula", "task_id"]; 36, 37; 36, 38; 36, 39; 37, string:"energy"; 38, string:"unit_cell_formula"; 39, string:"task_id"; 40, identifier:params; 41, if_statement; 41, 42; 41, 43; 42, identifier:sort_by_e_above_hull; 43, block; 43, 44; 44, if_statement; 44, 45; 44, 50; 44, 58; 45, boolean_operator:and; 45, 46; 45, 47; 46, identifier:property_data; 47, comparison_operator:not; 47, 48; 47, 49; 48, string:"e_above_hull"; 49, identifier:property_data; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:property_data; 55, identifier:append; 56, argument_list; 56, 57; 57, string:"e_above_hull"; 58, elif_clause; 58, 59; 58, 61; 59, not_operator; 59, 60; 60, identifier:property_data; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:property_data; 65, list:["e_above_hull"]; 65, 66; 66, string:"e_above_hull"; 67, if_statement; 67, 68; 67, 69; 68, identifier:property_data; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, augmented_assignment:+=; 71, 72; 71, 73; 72, identifier:props; 73, identifier:property_data; 74, if_statement; 74, 75; 74, 76; 75, identifier:inc_structure; 76, block; 76, 77; 77, if_statement; 77, 78; 77, 81; 77, 89; 78, comparison_operator:==; 78, 79; 78, 80; 79, identifier:inc_structure; 80, string:"initial"; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:props; 86, identifier:append; 87, argument_list; 87, 88; 88, string:"initial_structure"; 89, else_clause; 89, 90; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:props; 95, identifier:append; 96, argument_list; 96, 97; 97, string:"structure"; 98, if_statement; 98, 99; 98, 105; 98, 115; 99, not_operator; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:isinstance; 102, argument_list; 102, 103; 102, 104; 103, identifier:chemsys_formula_id_criteria; 104, identifier:dict; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:criteria; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:MPRester; 112, identifier:parse_criteria; 113, argument_list; 113, 114; 114, identifier:chemsys_formula_id_criteria; 115, else_clause; 115, 116; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:criteria; 120, identifier:chemsys_formula_id_criteria; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:data; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:query; 128, argument_list; 128, 129; 128, 130; 129, identifier:criteria; 130, identifier:props; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:entries; 134, list:[]; 135, for_statement; 135, 136; 135, 137; 135, 138; 136, identifier:d; 137, identifier:data; 138, block; 138, 139; 138, 161; 138, 170; 138, 188; 138, 313; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 144; 141, subscript; 141, 142; 141, 143; 142, identifier:d; 143, string:"potcar_symbols"; 144, list_comprehension; 144, 145; 144, 154; 145, binary_operator:%; 145, 146; 145, 147; 146, string:"%s %s"; 147, tuple; 147, 148; 147, 153; 148, subscript; 148, 149; 148, 152; 149, subscript; 149, 150; 149, 151; 150, identifier:d; 151, string:"pseudo_potential"; 152, string:"functional"; 153, identifier:l; 154, for_in_clause; 154, 155; 154, 156; 155, identifier:l; 156, subscript; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:d; 159, string:"pseudo_potential"; 160, string:"labels"; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:data; 164, dictionary; 164, 165; 165, pair; 165, 166; 165, 167; 166, string:"oxide_type"; 167, subscript; 167, 168; 167, 169; 168, identifier:d; 169, string:"oxide_type"; 170, if_statement; 170, 171; 170, 172; 171, identifier:property_data; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:data; 177, identifier:update; 178, argument_list; 178, 179; 179, dictionary_comprehension; 179, 180; 179, 185; 180, pair; 180, 181; 180, 182; 181, identifier:k; 182, subscript; 182, 183; 182, 184; 183, identifier:d; 184, identifier:k; 185, for_in_clause; 185, 186; 185, 187; 186, identifier:k; 187, identifier:property_data; 188, if_statement; 188, 189; 188, 191; 188, 223; 189, not_operator; 189, 190; 190, identifier:inc_structure; 191, block; 191, 192; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:e; 195, call; 195, 196; 195, 197; 196, identifier:ComputedEntry; 197, argument_list; 197, 198; 197, 201; 197, 204; 197, 215; 197, 218; 198, subscript; 198, 199; 198, 200; 199, identifier:d; 200, string:"unit_cell_formula"; 201, subscript; 201, 202; 201, 203; 202, identifier:d; 203, string:"energy"; 204, keyword_argument; 204, 205; 204, 206; 205, identifier:parameters; 206, dictionary_comprehension; 206, 207; 206, 212; 207, pair; 207, 208; 207, 209; 208, identifier:k; 209, subscript; 209, 210; 209, 211; 210, identifier:d; 211, identifier:k; 212, for_in_clause; 212, 213; 212, 214; 213, identifier:k; 214, identifier:params; 215, keyword_argument; 215, 216; 215, 217; 216, identifier:data; 217, identifier:data; 218, keyword_argument; 218, 219; 218, 220; 219, identifier:entry_id; 220, subscript; 220, 221; 220, 222; 221, identifier:d; 222, string:"task_id"; 223, else_clause; 223, 224; 224, block; 224, 225; 224, 239; 224, 286; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:prim; 228, conditional_expression:if; 228, 229; 228, 232; 228, 235; 228, 236; 229, subscript; 229, 230; 229, 231; 230, identifier:d; 231, string:"initial_structure"; 232, comparison_operator:==; 232, 233; 232, 234; 233, identifier:inc_structure; 234, string:"initial"; 235, line_continuation:\; 236, subscript; 236, 237; 236, 238; 237, identifier:d; 238, string:"structure"; 239, if_statement; 239, 240; 239, 241; 239, 270; 240, identifier:conventional_unit_cell; 241, block; 241, 242; 241, 253; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:s; 245, call; 245, 246; 245, 252; 246, attribute; 246, 247; 246, 251; 247, call; 247, 248; 247, 249; 248, identifier:SpacegroupAnalyzer; 249, argument_list; 249, 250; 250, identifier:prim; 251, identifier:get_conventional_standard_structure; 252, argument_list; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:energy; 256, binary_operator:*; 256, 257; 256, 260; 257, subscript; 257, 258; 257, 259; 258, identifier:d; 259, string:"energy"; 260, parenthesized_expression; 260, 261; 261, binary_operator:/; 261, 262; 261, 266; 262, call; 262, 263; 262, 264; 263, identifier:len; 264, argument_list; 264, 265; 265, identifier:s; 266, call; 266, 267; 266, 268; 267, identifier:len; 268, argument_list; 268, 269; 269, identifier:prim; 270, else_clause; 270, 271; 271, block; 271, 272; 271, 280; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 275; 274, identifier:s; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:prim; 278, identifier:copy; 279, argument_list; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 283; 282, identifier:energy; 283, subscript; 283, 284; 283, 285; 284, identifier:d; 285, string:"energy"; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:e; 289, call; 289, 290; 289, 291; 290, identifier:ComputedStructureEntry; 291, argument_list; 291, 292; 291, 293; 291, 294; 291, 305; 291, 308; 292, identifier:s; 293, identifier:energy; 294, keyword_argument; 294, 295; 294, 296; 295, identifier:parameters; 296, dictionary_comprehension; 296, 297; 296, 302; 297, pair; 297, 298; 297, 299; 298, identifier:k; 299, subscript; 299, 300; 299, 301; 300, identifier:d; 301, identifier:k; 302, for_in_clause; 302, 303; 302, 304; 303, identifier:k; 304, identifier:params; 305, keyword_argument; 305, 306; 305, 307; 306, identifier:data; 307, identifier:data; 308, keyword_argument; 308, 309; 308, 310; 309, identifier:entry_id; 310, subscript; 310, 311; 310, 312; 311, identifier:d; 312, string:"task_id"; 313, expression_statement; 313, 314; 314, call; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, identifier:entries; 317, identifier:append; 318, argument_list; 318, 319; 319, identifier:e; 320, if_statement; 320, 321; 320, 322; 321, identifier:compatible_only; 322, block; 322, 323; 322, 331; 323, import_from_statement; 323, 324; 323, 328; 323, 329; 324, dotted_name; 324, 325; 324, 326; 324, 327; 325, identifier:pymatgen; 326, identifier:entries; 327, identifier:compatibility; 328, line_continuation:\; 329, dotted_name; 329, 330; 330, identifier:MaterialsProjectCompatibility; 331, expression_statement; 331, 332; 332, assignment; 332, 333; 332, 334; 333, identifier:entries; 334, call; 334, 335; 334, 340; 335, attribute; 335, 336; 335, 339; 336, call; 336, 337; 336, 338; 337, identifier:MaterialsProjectCompatibility; 338, argument_list; 339, identifier:process_entries; 340, argument_list; 340, 341; 341, identifier:entries; 342, if_statement; 342, 343; 342, 344; 343, identifier:sort_by_e_above_hull; 344, block; 344, 345; 345, expression_statement; 345, 346; 346, assignment; 346, 347; 346, 348; 347, identifier:entries; 348, call; 348, 349; 348, 350; 349, identifier:sorted; 350, argument_list; 350, 351; 350, 352; 351, identifier:entries; 352, keyword_argument; 352, 353; 352, 354; 353, identifier:key; 354, lambda; 354, 355; 354, 357; 355, lambda_parameters; 355, 356; 356, identifier:entry; 357, subscript; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, identifier:entry; 360, identifier:data; 361, string:"e_above_hull"; 362, return_statement; 362, 363; 363, identifier:entries | def get_entries(self, chemsys_formula_id_criteria, compatible_only=True,
inc_structure=None, property_data=None,
conventional_unit_cell=False, sort_by_e_above_hull=False):
params = ["run_type", "is_hubbard", "pseudo_potential", "hubbards",
"potcar_symbols", "oxide_type"]
props = ["energy", "unit_cell_formula", "task_id"] + params
if sort_by_e_above_hull:
if property_data and "e_above_hull" not in property_data:
property_data.append("e_above_hull")
elif not property_data:
property_data = ["e_above_hull"]
if property_data:
props += property_data
if inc_structure:
if inc_structure == "initial":
props.append("initial_structure")
else:
props.append("structure")
if not isinstance(chemsys_formula_id_criteria, dict):
criteria = MPRester.parse_criteria(chemsys_formula_id_criteria)
else:
criteria = chemsys_formula_id_criteria
data = self.query(criteria, props)
entries = []
for d in data:
d["potcar_symbols"] = [
"%s %s" % (d["pseudo_potential"]["functional"], l)
for l in d["pseudo_potential"]["labels"]]
data = {"oxide_type": d["oxide_type"]}
if property_data:
data.update({k: d[k] for k in property_data})
if not inc_structure:
e = ComputedEntry(d["unit_cell_formula"], d["energy"],
parameters={k: d[k] for k in params},
data=data,
entry_id=d["task_id"])
else:
prim = d["initial_structure"] if inc_structure == "initial" \
else d["structure"]
if conventional_unit_cell:
s = SpacegroupAnalyzer(prim).get_conventional_standard_structure()
energy = d["energy"] * (len(s) / len(prim))
else:
s = prim.copy()
energy = d["energy"]
e = ComputedStructureEntry(
s, energy,
parameters={k: d[k] for k in params},
data=data,
entry_id=d["task_id"])
entries.append(e)
if compatible_only:
from pymatgen.entries.compatibility import \
MaterialsProjectCompatibility
entries = MaterialsProjectCompatibility().process_entries(entries)
if sort_by_e_above_hull:
entries = sorted(entries, key=lambda entry: entry.data["e_above_hull"])
return entries |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:aos_as_list; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 6, expression_statement; 6, 7; 7, string:'''
Returns a list of atomic orbitals, sorted from lowest to highest energy
'''; 8, return_statement; 8, 9; 9, call; 9, 10; 9, 11; 10, identifier:sorted; 11, argument_list; 11, 12; 11, 37; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:chain; 15, identifier:from_iterable; 16, argument_list; 16, 17; 17, list_comprehension; 17, 18; 17, 32; 18, binary_operator:*; 18, 19; 18, 24; 19, subscript; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:aos; 23, identifier:el; 24, call; 24, 25; 24, 26; 25, identifier:int; 26, argument_list; 26, 27; 27, subscript; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:composition; 31, identifier:el; 32, for_in_clause; 32, 33; 32, 34; 33, identifier:el; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:elements; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:key; 39, lambda; 39, 40; 39, 42; 40, lambda_parameters; 40, 41; 41, identifier:x; 42, subscript; 42, 43; 42, 44; 43, identifier:x; 44, integer:2 | def aos_as_list(self):
'''
Returns a list of atomic orbitals, sorted from lowest to highest energy
'''
return sorted(chain.from_iterable(
[self.aos[el] * int(self.composition[el]) for el in self.elements]
), key=lambda x: x[2]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:get_dataframe; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort_key; 7, string:"wall_time"; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 16; 10, 29; 10, 54; 10, 62; 10, 70; 10, 78; 10, 86; 10, 94; 10, 102; 10, 110; 11, import_statement; 11, 12; 12, aliased_import; 12, 13; 12, 15; 13, dotted_name; 13, 14; 14, identifier:pandas; 15, identifier:pd; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:frame; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:pd; 22, identifier:DataFrame; 23, argument_list; 23, 24; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:columns; 26, attribute; 26, 27; 26, 28; 27, identifier:AbinitTimerSection; 28, identifier:FIELDS; 29, for_statement; 29, 30; 29, 31; 29, 37; 30, identifier:osect; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:order_sections; 35, argument_list; 35, 36; 36, identifier:sort_key; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:frame; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:frame; 44, identifier:append; 45, argument_list; 45, 46; 45, 51; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:osect; 49, identifier:to_dict; 50, argument_list; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:ignore_index; 53, True; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:frame; 58, identifier:info; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:info; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:frame; 66, identifier:cpu_time; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:cpu_time; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:frame; 74, identifier:wall_time; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:wall_time; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:frame; 82, identifier:mpi_nprocs; 83, attribute; 83, 84; 83, 85; 84, identifier:self; 85, identifier:mpi_nprocs; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:frame; 90, identifier:omp_nthreads; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:omp_nthreads; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:frame; 98, identifier:mpi_rank; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:mpi_rank; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:frame; 106, identifier:fname; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:fname; 110, return_statement; 110, 111; 111, identifier:frame | def get_dataframe(self, sort_key="wall_time", **kwargs):
import pandas as pd
frame = pd.DataFrame(columns=AbinitTimerSection.FIELDS)
for osect in self.order_sections(sort_key):
frame = frame.append(osect.to_dict(), ignore_index=True)
frame.info = self.info
frame.cpu_time = self.cpu_time
frame.wall_time = self.wall_time
frame.mpi_nprocs = self.mpi_nprocs
frame.omp_nthreads = self.omp_nthreads
frame.mpi_rank = self.mpi_rank
frame.fname = self.fname
return frame |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:order_sections; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:reverse; 8, True; 9, block; 9, 10; 9, 21; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:fsort; 13, lambda; 13, 14; 13, 16; 14, lambda_parameters; 14, 15; 15, identifier:s; 16, subscript; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:s; 19, identifier:__dict__; 20, identifier:key; 21, return_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:sorted; 24, argument_list; 24, 25; 24, 28; 24, 31; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:sections; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:key; 30, identifier:fsort; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:reverse; 33, identifier:reverse | def order_sections(self, key, reverse=True):
fsort = lambda s: s.__dict__[key]
return sorted(self.sections, key=fsort, reverse=reverse) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort_dict; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:d; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, block; 11, 12; 11, 24; 11, 60; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:kv_items; 15, list_comprehension; 15, 16; 15, 17; 16, identifier:kv; 17, for_in_clause; 17, 18; 17, 19; 18, identifier:kv; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:d; 22, identifier:items; 23, argument_list; 24, if_statement; 24, 25; 24, 28; 24, 46; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:key; 27, None; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:kv_items; 33, identifier:sort; 34, argument_list; 34, 35; 34, 43; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:key; 37, lambda; 37, 38; 37, 40; 38, lambda_parameters; 38, 39; 39, identifier:t; 40, subscript; 40, 41; 40, 42; 41, identifier:t; 42, integer:1; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:reverse; 45, identifier:reverse; 46, else_clause; 46, 47; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:kv_items; 52, identifier:sort; 53, argument_list; 53, 54; 53, 57; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:key; 56, identifier:key; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:reverse; 59, identifier:reverse; 60, return_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:collections; 64, identifier:OrderedDict; 65, argument_list; 65, 66; 66, identifier:kv_items | def sort_dict(d, key=None, reverse=False):
kv_items = [kv for kv in d.items()]
if key is None:
kv_items.sort(key=lambda t: t[1], reverse=reverse)
else:
kv_items.sort(key=key, reverse=reverse)
return collections.OrderedDict(kv_items) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_by_efficiency; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:reverse; 7, True; 8, block; 8, 9; 8, 28; 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:_confs; 15, identifier:sort; 16, argument_list; 16, 17; 16, 25; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:key; 19, lambda; 19, 20; 19, 22; 20, lambda_parameters; 20, 21; 21, identifier:c; 22, attribute; 22, 23; 22, 24; 23, identifier:c; 24, identifier:efficiency; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:reverse; 27, identifier:reverse; 28, return_statement; 28, 29; 29, identifier:self | def sort_by_efficiency(self, reverse=True):
self._confs.sort(key=lambda c: c.efficiency, reverse=reverse)
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_by_speedup; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:reverse; 7, True; 8, block; 8, 9; 8, 28; 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:_confs; 15, identifier:sort; 16, argument_list; 16, 17; 16, 25; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:key; 19, lambda; 19, 20; 19, 22; 20, lambda_parameters; 20, 21; 21, identifier:c; 22, attribute; 22, 23; 22, 24; 23, identifier:c; 24, identifier:speedup; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:reverse; 27, identifier:reverse; 28, return_statement; 28, 29; 29, identifier:self | def sort_by_speedup(self, reverse=True):
self._confs.sort(key=lambda c: c.speedup, reverse=reverse)
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_by_mem_per_proc; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:reverse; 7, False; 8, block; 8, 9; 8, 41; 9, if_statement; 9, 10; 9, 21; 10, call; 10, 11; 10, 12; 11, identifier:any; 12, generator_expression; 12, 13; 12, 18; 13, comparison_operator:>; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:c; 16, identifier:mem_per_proc; 17, float:0.0; 18, for_in_clause; 18, 19; 18, 20; 19, identifier:c; 20, identifier:self; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_confs; 28, identifier:sort; 29, argument_list; 29, 30; 29, 38; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:key; 32, lambda; 32, 33; 32, 35; 33, lambda_parameters; 33, 34; 34, identifier:c; 35, attribute; 35, 36; 35, 37; 36, identifier:c; 37, identifier:mem_per_proc; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:reverse; 40, identifier:reverse; 41, return_statement; 41, 42; 42, identifier:self | def sort_by_mem_per_proc(self, reverse=False):
if any(c.mem_per_proc > 0.0 for c in self):
self._confs.sort(key=lambda c: c.mem_per_proc, reverse=reverse)
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:add_cohp_dict; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:cohp_dict; 6, default_parameter; 6, 7; 6, 8; 7, identifier:key_sort_func; 8, None; 9, block; 9, 10; 9, 37; 10, if_statement; 10, 11; 10, 12; 10, 27; 11, identifier:key_sort_func; 12, block; 12, 13; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:keys; 16, call; 16, 17; 16, 18; 17, identifier:sorted; 18, argument_list; 18, 19; 18, 24; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:cohp_dict; 22, identifier:keys; 23, argument_list; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:key; 26, identifier:key_sort_func; 27, else_clause; 27, 28; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:keys; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:cohp_dict; 35, identifier:keys; 36, argument_list; 37, for_statement; 37, 38; 37, 39; 37, 40; 38, identifier:label; 39, identifier:keys; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:add_cohp; 46, argument_list; 46, 47; 46, 48; 47, identifier:label; 48, subscript; 48, 49; 48, 50; 49, identifier:cohp_dict; 50, identifier:label | def add_cohp_dict(self, cohp_dict, key_sort_func=None):
if key_sort_func:
keys = sorted(cohp_dict.keys(), key=key_sort_func)
else:
keys = cohp_dict.keys()
for label in keys:
self.add_cohp(label, cohp_dict[label]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_line_in_facet; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:facet; 6, block; 6, 7; 6, 16; 6, 20; 6, 24; 6, 125; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:lines; 10, call; 10, 11; 10, 12; 11, identifier:list; 12, argument_list; 12, 13; 13, attribute; 13, 14; 13, 15; 14, identifier:facet; 15, identifier:outer_lines; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:pt; 19, list:[]; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:prev; 23, None; 24, while_statement; 24, 25; 24, 31; 25, comparison_operator:>; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, identifier:lines; 30, integer:0; 31, block; 31, 32; 31, 85; 31, 102; 31, 119; 32, if_statement; 32, 33; 32, 36; 32, 46; 33, comparison_operator:is; 33, 34; 33, 35; 34, identifier:prev; 35, None; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:l; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:lines; 43, identifier:pop; 44, argument_list; 44, 45; 45, integer:0; 46, else_clause; 46, 47; 47, block; 47, 48; 48, for_statement; 48, 49; 48, 52; 48, 56; 49, pattern_list; 49, 50; 49, 51; 50, identifier:i; 51, identifier:l; 52, call; 52, 53; 52, 54; 53, identifier:enumerate; 54, argument_list; 54, 55; 55, identifier:lines; 56, block; 56, 57; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:in; 58, 59; 58, 60; 59, identifier:prev; 60, identifier:l; 61, block; 61, 62; 61, 71; 61, 84; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:l; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:lines; 68, identifier:pop; 69, argument_list; 69, 70; 70, identifier:i; 71, if_statement; 71, 72; 71, 77; 72, comparison_operator:==; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:l; 75, integer:1; 76, identifier:prev; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:l; 82, identifier:reverse; 83, argument_list; 84, break_statement; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:pt; 89, identifier:append; 90, argument_list; 90, 91; 91, call; 91, 92; 91, 101; 92, attribute; 92, 93; 92, 100; 93, subscript; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:self; 96, identifier:wulff_pt_list; 97, subscript; 97, 98; 97, 99; 98, identifier:l; 99, integer:0; 100, identifier:tolist; 101, argument_list; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:pt; 106, identifier:append; 107, argument_list; 107, 108; 108, call; 108, 109; 108, 118; 109, attribute; 109, 110; 109, 117; 110, subscript; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:wulff_pt_list; 114, subscript; 114, 115; 114, 116; 115, identifier:l; 116, integer:1; 117, identifier:tolist; 118, argument_list; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:prev; 122, subscript; 122, 123; 122, 124; 123, identifier:l; 124, integer:1; 125, return_statement; 125, 126; 126, identifier:pt | def get_line_in_facet(self, facet):
lines = list(facet.outer_lines)
pt = []
prev = None
while len(lines) > 0:
if prev is None:
l = lines.pop(0)
else:
for i, l in enumerate(lines):
if prev in l:
l = lines.pop(i)
if l[1] == prev:
l.reverse()
break
pt.append(self.wulff_pt_list[l[0]].tolist())
pt.append(self.wulff_pt_list[l[1]].tolist())
prev = l[1]
return pt |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 1, 17; 2, function_name:get_classical_addresses_from_program; 3, parameters; 3, 4; 4, identifier:program; 5, type; 5, 6; 6, generic_type; 6, 7; 6, 8; 7, identifier:Dict; 8, type_parameter; 8, 9; 8, 11; 9, type; 9, 10; 10, identifier:str; 11, type; 11, 12; 12, generic_type; 12, 13; 12, 14; 13, identifier:List; 14, type_parameter; 14, 15; 15, type; 15, 16; 16, identifier:int; 17, block; 17, 18; 17, 37; 17, 41; 17, 73; 17, 105; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 19, 33; 20, identifier:addresses; 21, type; 21, 22; 22, generic_type; 22, 23; 22, 24; 23, identifier:Dict; 24, type_parameter; 24, 25; 24, 27; 25, type; 25, 26; 26, identifier:str; 27, type; 27, 28; 28, generic_type; 28, 29; 28, 30; 29, identifier:List; 30, type_parameter; 30, 31; 31, type; 31, 32; 32, identifier:int; 33, call; 33, 34; 33, 35; 34, identifier:defaultdict; 35, argument_list; 35, 36; 36, identifier:list; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:flattened_addresses; 40, dictionary; 41, for_statement; 41, 42; 41, 43; 41, 44; 42, identifier:instr; 43, identifier:program; 44, block; 44, 45; 45, if_statement; 45, 46; 45, 55; 46, boolean_operator:and; 46, 47; 46, 52; 47, call; 47, 48; 47, 49; 48, identifier:isinstance; 49, argument_list; 49, 50; 49, 51; 50, identifier:instr; 51, identifier:Measurement; 52, attribute; 52, 53; 52, 54; 53, identifier:instr; 54, identifier:classical_reg; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 67; 58, attribute; 58, 59; 58, 66; 59, subscript; 59, 60; 59, 61; 60, identifier:addresses; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:instr; 64, identifier:classical_reg; 65, identifier:name; 66, identifier:append; 67, argument_list; 67, 68; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:instr; 71, identifier:classical_reg; 72, identifier:offset; 73, for_statement; 73, 74; 73, 77; 73, 82; 74, pattern_list; 74, 75; 74, 76; 75, identifier:k; 76, identifier:v; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:addresses; 80, identifier:items; 81, argument_list; 82, block; 82, 83; 82, 93; 82, 99; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:reduced_list; 86, call; 86, 87; 86, 88; 87, identifier:list; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:set; 91, argument_list; 91, 92; 92, identifier:v; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:reduced_list; 97, identifier:sort; 98, argument_list; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 104; 101, subscript; 101, 102; 101, 103; 102, identifier:flattened_addresses; 103, identifier:k; 104, identifier:reduced_list; 105, return_statement; 105, 106; 106, identifier:flattened_addresses | def get_classical_addresses_from_program(program) -> Dict[str, List[int]]:
addresses: Dict[str, List[int]] = defaultdict(list)
flattened_addresses = {}
for instr in program:
if isinstance(instr, Measurement) and instr.classical_reg:
addresses[instr.classical_reg.name].append(instr.classical_reg.offset)
for k, v in addresses.items():
reduced_list = list(set(v))
reduced_list.sort()
flattened_addresses[k] = reduced_list
return flattened_addresses |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 1, 10; 2, function_name:percolate_declares; 3, parameters; 3, 4; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:program; 6, type; 6, 7; 7, identifier:Program; 8, type; 8, 9; 9, identifier:Program; 10, block; 10, 11; 10, 17; 10, 23; 10, 44; 10, 50; 10, 58; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:declare_program; 14, call; 14, 15; 14, 16; 15, identifier:Program; 16, argument_list; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:instrs_program; 20, call; 20, 21; 20, 22; 21, identifier:Program; 22, argument_list; 23, for_statement; 23, 24; 23, 25; 23, 26; 24, identifier:instr; 25, identifier:program; 26, block; 26, 27; 27, if_statement; 27, 28; 27, 33; 27, 38; 28, call; 28, 29; 28, 30; 29, identifier:isinstance; 30, argument_list; 30, 31; 30, 32; 31, identifier:instr; 32, identifier:Declare; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, augmented_assignment:+=; 35, 36; 35, 37; 36, identifier:declare_program; 37, identifier:instr; 38, else_clause; 38, 39; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, augmented_assignment:+=; 41, 42; 41, 43; 42, identifier:instrs_program; 43, identifier:instr; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:p; 47, binary_operator:+; 47, 48; 47, 49; 48, identifier:declare_program; 49, identifier:instrs_program; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:p; 54, identifier:_defined_gates; 55, attribute; 55, 56; 55, 57; 56, identifier:program; 57, identifier:_defined_gates; 58, return_statement; 58, 59; 59, identifier:p | def percolate_declares(program: Program) -> Program:
declare_program = Program()
instrs_program = Program()
for instr in program:
if isinstance(instr, Declare):
declare_program += instr
else:
instrs_program += instr
p = declare_program + instrs_program
p._defined_gates = program._defined_gates
return p |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 25; 2, function_name:text_search; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 4, identifier:conn; 5, identifier:search; 6, keyword_separator; 7, default_parameter; 7, 8; 7, 9; 8, identifier:language; 9, string:'english'; 10, default_parameter; 10, 11; 10, 12; 11, identifier:case_sensitive; 12, False; 13, default_parameter; 13, 14; 13, 15; 14, identifier:diacritic_sensitive; 15, False; 16, default_parameter; 16, 17; 16, 18; 17, identifier:text_score; 18, False; 19, default_parameter; 19, 20; 19, 21; 20, identifier:limit; 21, integer:0; 22, default_parameter; 22, 23; 22, 24; 23, identifier:table; 24, None; 25, block; 25, 26; 26, raise_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:OperationError; 29, argument_list; 29, 30; 30, concatenated_string; 30, 31; 30, 32; 31, string:'This query is only supported when running '; 32, string:'BigchainDB with MongoDB as the backend.' | def text_search(conn, search, *, language='english', case_sensitive=False,
diacritic_sensitive=False, text_score=False, limit=0, table=None):
raise OperationError('This query is only supported when running '
'BigchainDB with MongoDB as the backend.') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_utxoset_merkle_root; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 19; 5, 48; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:utxoset; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:backend; 13, identifier:query; 14, identifier:get_unspent_outputs; 15, argument_list; 15, 16; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:connection; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:hashes; 22, list_comprehension; 22, 23; 22, 45; 23, call; 23, 24; 23, 44; 24, attribute; 24, 25; 24, 43; 25, call; 25, 26; 25, 27; 26, identifier:sha3_256; 27, argument_list; 27, 28; 28, call; 28, 29; 28, 42; 29, attribute; 29, 30; 29, 41; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, string:'{}{}'; 33, identifier:format; 34, argument_list; 34, 35; 34, 38; 35, subscript; 35, 36; 35, 37; 36, identifier:utxo; 37, string:'transaction_id'; 38, subscript; 38, 39; 38, 40; 39, identifier:utxo; 40, string:'output_index'; 41, identifier:encode; 42, argument_list; 43, identifier:digest; 44, argument_list; 45, for_in_clause; 45, 46; 45, 47; 46, identifier:utxo; 47, identifier:utxoset; 48, return_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:merkleroot; 51, argument_list; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:sorted; 54, argument_list; 54, 55; 55, identifier:hashes | def get_utxoset_merkle_root(self):
utxoset = backend.query.get_unspent_outputs(self.connection)
hashes = [
sha3_256(
'{}{}'.format(utxo['transaction_id'], utxo['output_index']).encode()
).digest() for utxo in utxoset
]
return merkleroot(sorted(hashes)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 1, 22; 2, function_name:log_time; 3, parameters; 3, 4; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:func; 6, type; 6, 7; 7, generic_type; 7, 8; 7, 9; 8, identifier:Callable; 9, type_parameter; 9, 10; 9, 12; 10, type; 10, 11; 11, ellipsis:...; 12, type; 12, 13; 13, identifier:Any; 14, type; 14, 15; 15, generic_type; 15, 16; 15, 17; 16, identifier:Callable; 17, type_parameter; 17, 18; 17, 20; 18, type; 18, 19; 19, ellipsis:...; 20, type; 20, 21; 21, identifier:Any; 22, block; 22, 23; 22, 96; 23, function_definition; 23, 24; 23, 25; 23, 30; 24, function_name:wrapper; 25, parameters; 25, 26; 25, 28; 26, list_splat_pattern; 26, 27; 27, identifier:args; 28, dictionary_splat_pattern; 28, 29; 29, identifier:kwargs; 30, block; 30, 31; 30, 39; 30, 53; 30, 63; 30, 94; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:start_time; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:time; 37, identifier:time; 38, argument_list; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:log; 43, identifier:info; 44, argument_list; 44, 45; 44, 46; 45, string:"%s starting..."; 46, call; 46, 47; 46, 52; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:func; 50, identifier:__name__; 51, identifier:title; 52, argument_list; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:ret; 56, call; 56, 57; 56, 58; 57, identifier:func; 58, argument_list; 58, 59; 58, 61; 59, list_splat; 59, 60; 60, identifier:args; 61, dictionary_splat; 61, 62; 62, identifier:kwargs; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:log; 67, identifier:info; 68, argument_list; 68, 69; 68, 70; 68, 77; 69, string:"%s finished (%s)"; 70, call; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:func; 74, identifier:__name__; 75, identifier:title; 76, argument_list; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:datetime; 80, identifier:timedelta; 81, argument_list; 81, 82; 82, keyword_argument; 82, 83; 82, 84; 83, identifier:seconds; 84, call; 84, 85; 84, 86; 85, identifier:int; 86, argument_list; 86, 87; 87, binary_operator:-; 87, 88; 87, 93; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:time; 91, identifier:time; 92, argument_list; 93, identifier:start_time; 94, return_statement; 94, 95; 95, identifier:ret; 96, return_statement; 96, 97; 97, identifier:wrapper | def log_time(func: Callable[..., Any]) -> Callable[..., Any]:
def wrapper(*args, **kwargs):
start_time = time.time()
log.info("%s starting...", func.__name__.title())
ret = func(*args, **kwargs)
log.info(
"%s finished (%s)",
func.__name__.title(),
datetime.timedelta(seconds=int(time.time() - start_time)),
)
return ret
return wrapper |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_mro; 3, parameters; 3, 4; 4, identifier:cls; 5, block; 5, 6; 5, 22; 6, if_statement; 6, 7; 6, 14; 7, comparison_operator:==; 7, 8; 7, 13; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:platform; 11, identifier:python_implementation; 12, argument_list; 13, string:"Jython"; 14, block; 14, 15; 15, return_statement; 15, 16; 16, binary_operator:+; 16, 17; 16, 19; 17, tuple; 17, 18; 18, identifier:cls; 19, attribute; 19, 20; 19, 21; 20, identifier:cls; 21, identifier:__bases__; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:inspect; 26, identifier:getmro; 27, argument_list; 27, 28; 28, identifier:cls | def _get_mro(cls):
if platform.python_implementation() == "Jython":
return (cls,) + cls.__bases__
return inspect.getmro(cls) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sorted_walk; 3, parameters; 3, 4; 4, identifier:dir; 5, block; 5, 6; 6, for_statement; 6, 7; 6, 11; 6, 17; 7, pattern_list; 7, 8; 7, 9; 7, 10; 8, identifier:base; 9, identifier:dirs; 10, identifier:files; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:os; 14, identifier:walk; 15, argument_list; 15, 16; 16, identifier:dir; 17, block; 17, 18; 17, 24; 17, 30; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:dirs; 22, identifier:sort; 23, argument_list; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:files; 28, identifier:sort; 29, argument_list; 30, expression_statement; 30, 31; 31, yield; 31, 32; 32, expression_list; 32, 33; 32, 34; 32, 35; 33, identifier:base; 34, identifier:dirs; 35, identifier:files | def sorted_walk(dir):
for base, dirs, files in os.walk(dir):
dirs.sort()
files.sort()
yield base, dirs, files |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_all_ns_packages; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 16; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:pkgs; 9, boolean_operator:or; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:distribution; 14, identifier:namespace_packages; 15, list:[]; 16, return_statement; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:sorted; 19, argument_list; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:flatten; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:map; 25, argument_list; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_pkg_names; 29, identifier:pkgs | def _get_all_ns_packages(self):
pkgs = self.distribution.namespace_packages or []
return sorted(flatten(map(self._pkg_names, pkgs))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:flatten_comments; 3, parameters; 3, 4; 3, 5; 4, identifier:comments; 5, default_parameter; 5, 6; 5, 7; 6, identifier:root_level; 7, integer:0; 8, block; 8, 9; 8, 16; 8, 26; 8, 34; 8, 146; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:stack; 12, subscript; 12, 13; 12, 14; 13, identifier:comments; 14, slice; 14, 15; 15, colon; 16, for_statement; 16, 17; 16, 18; 16, 19; 17, identifier:item; 18, identifier:stack; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:item; 24, identifier:nested_level; 25, identifier:root_level; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 31; 28, pattern_list; 28, 29; 28, 30; 29, identifier:retval; 30, identifier:parent_candidates; 31, expression_list; 31, 32; 31, 33; 32, list:[]; 33, dictionary; 34, while_statement; 34, 35; 34, 36; 35, identifier:stack; 36, block; 36, 37; 36, 46; 36, 64; 36, 97; 36, 131; 36, 139; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:item; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:stack; 43, identifier:pop; 44, argument_list; 44, 45; 45, integer:0; 46, if_statement; 46, 47; 46, 62; 47, boolean_operator:and; 47, 48; 47, 57; 48, call; 48, 49; 48, 50; 49, identifier:isinstance; 50, argument_list; 50, 51; 50, 52; 51, identifier:item; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:praw; 55, identifier:objects; 56, identifier:MoreComments; 57, comparison_operator:==; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:item; 60, identifier:count; 61, integer:0; 62, block; 62, 63; 63, continue_statement; 64, if_statement; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:item; 67, identifier:parent_id; 68, block; 68, 69; 68, 84; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:parent; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:parent_candidates; 75, identifier:get; 76, argument_list; 76, 77; 77, subscript; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:item; 80, identifier:parent_id; 81, slice; 81, 82; 81, 83; 82, integer:3; 83, colon; 84, if_statement; 84, 85; 84, 86; 85, identifier:parent; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:item; 91, identifier:nested_level; 92, binary_operator:+; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:parent; 95, identifier:nested_level; 96, integer:1; 97, if_statement; 97, 98; 97, 103; 98, call; 98, 99; 98, 100; 99, identifier:hasattr; 100, argument_list; 100, 101; 100, 102; 101, identifier:item; 102, string:'replies'; 103, block; 103, 104; 103, 120; 104, for_statement; 104, 105; 104, 106; 104, 109; 105, identifier:n; 106, attribute; 106, 107; 106, 108; 107, identifier:item; 108, identifier:replies; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:n; 114, identifier:nested_level; 115, binary_operator:+; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:item; 118, identifier:nested_level; 119, integer:1; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 128; 122, subscript; 122, 123; 122, 124; 123, identifier:stack; 124, slice; 124, 125; 124, 126; 124, 127; 125, integer:0; 126, colon; 127, integer:0; 128, attribute; 128, 129; 128, 130; 129, identifier:item; 130, identifier:replies; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 138; 133, subscript; 133, 134; 133, 135; 134, identifier:parent_candidates; 135, attribute; 135, 136; 135, 137; 136, identifier:item; 137, identifier:id; 138, identifier:item; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:retval; 143, identifier:append; 144, argument_list; 144, 145; 145, identifier:item; 146, return_statement; 146, 147; 147, identifier:retval | def flatten_comments(comments, root_level=0):
stack = comments[:]
for item in stack:
item.nested_level = root_level
retval, parent_candidates = [], {}
while stack:
item = stack.pop(0)
if isinstance(item, praw.objects.MoreComments) and item.count == 0:
continue
if item.parent_id:
parent = parent_candidates.get(item.parent_id[3:])
if parent:
item.nested_level = parent.nested_level + 1
if hasattr(item, 'replies'):
for n in item.replies:
n.nested_level = item.nested_level + 1
stack[0:0] = item.replies
parent_candidates[item.id] = item
retval.append(item)
return retval |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:get_domain_listing; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 14; 4, identifier:self; 5, identifier:domain; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, string:'hot'; 9, default_parameter; 9, 10; 9, 11; 10, identifier:period; 11, None; 12, list_splat_pattern; 12, 13; 13, identifier:args; 14, dictionary_splat_pattern; 14, 15; 15, identifier:kwargs; 16, block; 16, 17; 16, 33; 16, 50; 16, 64; 16, 79; 16, 88; 16, 103; 17, if_statement; 17, 18; 17, 27; 18, comparison_operator:not; 18, 19; 18, 20; 19, identifier:sort; 20, tuple; 20, 21; 20, 22; 20, 23; 20, 24; 20, 25; 20, 26; 21, string:'controversial'; 22, string:'hot'; 23, string:'new'; 24, string:'rising'; 25, string:'top'; 26, string:'gilded'; 27, block; 27, 28; 28, raise_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:TypeError; 31, argument_list; 31, 32; 32, string:'Invalid sort parameter.'; 33, if_statement; 33, 34; 33, 44; 34, comparison_operator:not; 34, 35; 34, 36; 35, identifier:period; 36, tuple; 36, 37; 36, 38; 36, 39; 36, 40; 36, 41; 36, 42; 36, 43; 37, None; 38, string:'all'; 39, string:'day'; 40, string:'hour'; 41, string:'month'; 42, string:'week'; 43, string:'year'; 44, block; 44, 45; 45, raise_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:TypeError; 48, argument_list; 48, 49; 49, string:'Invalid period parameter.'; 50, if_statement; 50, 51; 50, 58; 51, boolean_operator:and; 51, 52; 51, 57; 52, comparison_operator:not; 52, 53; 52, 54; 53, identifier:sort; 54, tuple; 54, 55; 54, 56; 55, string:'controversial'; 56, string:'top'; 57, identifier:period; 58, block; 58, 59; 59, raise_statement; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:TypeError; 62, argument_list; 62, 63; 63, string:'Period cannot be set for that sort argument.'; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:url; 67, call; 67, 68; 67, 75; 68, attribute; 68, 69; 68, 74; 69, subscript; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:config; 73, string:'domain'; 74, identifier:format; 75, argument_list; 75, 76; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:domain; 78, identifier:domain; 79, if_statement; 79, 80; 79, 83; 80, comparison_operator:!=; 80, 81; 80, 82; 81, identifier:sort; 82, string:'hot'; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, augmented_assignment:+=; 85, 86; 85, 87; 86, identifier:url; 87, identifier:sort; 88, if_statement; 88, 89; 88, 90; 89, identifier:period; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 102; 93, subscript; 93, 94; 93, 101; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:kwargs; 97, identifier:setdefault; 98, argument_list; 98, 99; 98, 100; 99, string:'params'; 100, dictionary; 101, string:'t'; 102, identifier:period; 103, return_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:self; 107, identifier:get_content; 108, argument_list; 108, 109; 108, 110; 108, 112; 109, identifier:url; 110, list_splat; 110, 111; 111, identifier:args; 112, dictionary_splat; 112, 113; 113, identifier:kwargs | def get_domain_listing(self, domain, sort='hot', period=None, *args,
**kwargs):
if sort not in ('controversial', 'hot', 'new', 'rising', 'top',
'gilded'):
raise TypeError('Invalid sort parameter.')
if period not in (None, 'all', 'day', 'hour', 'month', 'week', 'year'):
raise TypeError('Invalid period parameter.')
if sort not in ('controversial', 'top') and period:
raise TypeError('Period cannot be set for that sort argument.')
url = self.config['domain'].format(domain=domain)
if sort != 'hot':
url += sort
if period:
kwargs.setdefault('params', {})['t'] = period
return self.get_content(url, *args, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:get_submission; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:url; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:submission_id; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:comment_limit; 13, integer:0; 14, default_parameter; 14, 15; 14, 16; 15, identifier:comment_sort; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:params; 19, None; 20, block; 20, 21; 20, 37; 20, 52; 21, if_statement; 21, 22; 21, 31; 22, comparison_operator:==; 22, 23; 22, 27; 23, call; 23, 24; 23, 25; 24, identifier:bool; 25, argument_list; 25, 26; 26, identifier:url; 27, call; 27, 28; 27, 29; 28, identifier:bool; 29, argument_list; 29, 30; 30, identifier:submission_id; 31, block; 31, 32; 32, raise_statement; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:TypeError; 35, argument_list; 35, 36; 36, string:'One (and only one) of id or url is required!'; 37, if_statement; 37, 38; 37, 39; 38, identifier:submission_id; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:url; 43, call; 43, 44; 43, 45; 44, identifier:urljoin; 45, argument_list; 45, 46; 45, 51; 46, subscript; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:config; 50, string:'comments'; 51, identifier:submission_id; 52, return_statement; 52, 53; 53, call; 53, 54; 53, 59; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:objects; 57, identifier:Submission; 58, identifier:from_url; 59, argument_list; 59, 60; 59, 61; 59, 62; 59, 65; 59, 68; 60, identifier:self; 61, identifier:url; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:comment_limit; 64, identifier:comment_limit; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:comment_sort; 67, identifier:comment_sort; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:params; 70, identifier:params | def get_submission(self, url=None, submission_id=None, comment_limit=0,
comment_sort=None, params=None):
if bool(url) == bool(submission_id):
raise TypeError('One (and only one) of id or url is required!')
if submission_id:
url = urljoin(self.config['comments'], submission_id)
return objects.Submission.from_url(self, url,
comment_limit=comment_limit,
comment_sort=comment_sort,
params=params) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:search; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 20; 4, identifier:self; 5, identifier:query; 6, default_parameter; 6, 7; 6, 8; 7, identifier:subreddit; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:syntax; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:period; 17, None; 18, list_splat_pattern; 18, 19; 19, identifier:args; 20, dictionary_splat_pattern; 20, 21; 21, identifier:kwargs; 22, block; 22, 23; 22, 30; 22, 51; 22, 60; 22, 69; 22, 78; 22, 102; 22, 117; 22, 121; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:params; 26, dictionary; 26, 27; 27, pair; 27, 28; 27, 29; 28, string:'q'; 29, identifier:query; 30, if_statement; 30, 31; 30, 34; 31, comparison_operator:in; 31, 32; 31, 33; 32, string:'params'; 33, identifier:kwargs; 34, block; 34, 35; 34, 44; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:params; 39, identifier:update; 40, argument_list; 40, 41; 41, subscript; 41, 42; 41, 43; 42, identifier:kwargs; 43, string:'params'; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:kwargs; 48, identifier:pop; 49, argument_list; 49, 50; 50, string:'params'; 51, if_statement; 51, 52; 51, 53; 52, identifier:sort; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:params; 58, string:'sort'; 59, identifier:sort; 60, if_statement; 60, 61; 60, 62; 61, identifier:syntax; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:params; 67, string:'syntax'; 68, identifier:syntax; 69, if_statement; 69, 70; 69, 71; 70, identifier:period; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 77; 74, subscript; 74, 75; 74, 76; 75, identifier:params; 76, string:'t'; 77, identifier:period; 78, if_statement; 78, 79; 78, 80; 78, 96; 79, identifier:subreddit; 80, block; 80, 81; 80, 87; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:params; 85, string:'restrict_sr'; 86, string:'on'; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:subreddit; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:six; 93, identifier:text_type; 94, argument_list; 94, 95; 95, identifier:subreddit; 96, else_clause; 96, 97; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:subreddit; 101, string:'all'; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:url; 105, call; 105, 106; 105, 113; 106, attribute; 106, 107; 106, 112; 107, subscript; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:config; 111, string:'search'; 112, identifier:format; 113, argument_list; 113, 114; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:subreddit; 116, identifier:subreddit; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:depth; 120, integer:2; 121, while_statement; 121, 122; 121, 125; 122, comparison_operator:>; 122, 123; 122, 124; 123, identifier:depth; 124, integer:0; 125, block; 125, 126; 125, 130; 126, expression_statement; 126, 127; 127, augmented_assignment:-=; 127, 128; 127, 129; 128, identifier:depth; 129, integer:1; 130, try_statement; 130, 131; 130, 152; 131, block; 131, 132; 131, 151; 132, for_statement; 132, 133; 132, 134; 132, 147; 133, identifier:item; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:get_content; 138, argument_list; 138, 139; 138, 140; 138, 143; 138, 145; 139, identifier:url; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:params; 142, identifier:params; 143, list_splat; 143, 144; 144, identifier:args; 145, dictionary_splat; 145, 146; 146, identifier:kwargs; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, yield; 149, 150; 150, identifier:item; 151, break_statement; 152, except_clause; 152, 153; 152, 159; 153, as_pattern; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:errors; 156, identifier:RedirectException; 157, as_pattern_target; 157, 158; 158, identifier:exc; 159, block; 159, 160; 159, 169; 159, 197; 159, 213; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:parsed; 163, call; 163, 164; 163, 165; 164, identifier:urlparse; 165, argument_list; 165, 166; 166, attribute; 166, 167; 166, 168; 167, identifier:exc; 168, identifier:response_url; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:params; 172, call; 172, 173; 172, 174; 173, identifier:dict; 174, generator_expression; 174, 175; 174, 183; 175, tuple; 175, 176; 175, 177; 176, identifier:k; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, string:","; 180, identifier:join; 181, argument_list; 181, 182; 182, identifier:v; 183, for_in_clause; 183, 184; 183, 187; 184, pattern_list; 184, 185; 184, 186; 185, identifier:k; 186, identifier:v; 187, call; 187, 188; 187, 196; 188, attribute; 188, 189; 188, 195; 189, call; 189, 190; 189, 191; 190, identifier:parse_qs; 191, argument_list; 191, 192; 192, attribute; 192, 193; 192, 194; 193, identifier:parsed; 194, identifier:query; 195, identifier:items; 196, argument_list; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:url; 200, call; 200, 201; 200, 202; 201, identifier:urlunparse; 202, argument_list; 202, 203; 203, binary_operator:+; 203, 204; 203, 209; 204, subscript; 204, 205; 204, 206; 205, identifier:parsed; 206, slice; 206, 207; 206, 208; 207, colon; 208, integer:3; 209, tuple; 209, 210; 209, 211; 209, 212; 210, string:""; 211, string:""; 212, string:""; 213, if_statement; 213, 214; 213, 217; 214, comparison_operator:in; 214, 215; 214, 216; 215, string:'already_submitted'; 216, identifier:params; 217, block; 217, 218; 217, 226; 218, expression_statement; 218, 219; 219, yield; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:self; 223, identifier:get_submission; 224, argument_list; 224, 225; 225, identifier:url; 226, break_statement | def search(self, query, subreddit=None, sort=None, syntax=None,
period=None, *args, **kwargs):
params = {'q': query}
if 'params' in kwargs:
params.update(kwargs['params'])
kwargs.pop('params')
if sort:
params['sort'] = sort
if syntax:
params['syntax'] = syntax
if period:
params['t'] = period
if subreddit:
params['restrict_sr'] = 'on'
subreddit = six.text_type(subreddit)
else:
subreddit = 'all'
url = self.config['search'].format(subreddit=subreddit)
depth = 2
while depth > 0:
depth -= 1
try:
for item in self.get_content(url, params=params, *args,
**kwargs):
yield item
break
except errors.RedirectException as exc:
parsed = urlparse(exc.response_url)
params = dict((k, ",".join(v)) for k, v in
parse_qs(parsed.query).items())
url = urlunparse(parsed[:3] + ("", "", ""))
if 'already_submitted' in params:
yield self.get_submission(url)
break |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_get_sorter; 3, parameters; 3, 4; 3, 7; 4, default_parameter; 4, 5; 4, 6; 5, identifier:subpath; 6, string:''; 7, dictionary_splat_pattern; 7, 8; 8, identifier:defaults; 9, block; 9, 10; 9, 86; 10, decorated_definition; 10, 11; 10, 18; 11, decorator; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:restrict_access; 14, argument_list; 14, 15; 15, keyword_argument; 15, 16; 15, 17; 16, identifier:scope; 17, string:'read'; 18, function_definition; 18, 19; 18, 20; 18, 26; 19, function_name:_sorted; 20, parameters; 20, 21; 20, 22; 20, 24; 21, identifier:self; 22, list_splat_pattern; 22, 23; 23, identifier:args; 24, dictionary_splat_pattern; 24, 25; 25, identifier:kwargs; 26, block; 26, 27; 26, 42; 26, 63; 26, 73; 27, if_statement; 27, 28; 27, 35; 28, not_operator; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:kwargs; 32, identifier:get; 33, argument_list; 33, 34; 34, string:'params'; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 41; 38, subscript; 38, 39; 38, 40; 39, identifier:kwargs; 40, string:'params'; 41, dictionary; 42, for_statement; 42, 43; 42, 46; 42, 52; 43, pattern_list; 43, 44; 43, 45; 44, identifier:key; 45, identifier:value; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:six; 49, identifier:iteritems; 50, argument_list; 50, 51; 51, identifier:defaults; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 60; 55, attribute; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:kwargs; 58, string:'params'; 59, identifier:setdefault; 60, argument_list; 60, 61; 60, 62; 61, identifier:key; 62, identifier:value; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:url; 66, call; 66, 67; 66, 68; 67, identifier:urljoin; 68, argument_list; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:_url; 72, identifier:subpath; 73, return_statement; 73, 74; 74, call; 74, 75; 74, 80; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:reddit_session; 79, identifier:get_content; 80, argument_list; 80, 81; 80, 82; 80, 84; 81, identifier:url; 82, list_splat; 82, 83; 83, identifier:args; 84, dictionary_splat; 84, 85; 85, identifier:kwargs; 86, return_statement; 86, 87; 87, identifier:_sorted | def _get_sorter(subpath='', **defaults):
@restrict_access(scope='read')
def _sorted(self, *args, **kwargs):
if not kwargs.get('params'):
kwargs['params'] = {}
for key, value in six.iteritems(defaults):
kwargs['params'].setdefault(key, value)
url = urljoin(self._url, subpath)
return self.reddit_session.get_content(url, *args, **kwargs)
return _sorted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_draw_banner; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 20; 5, 38; 5, 44; 5, 62; 5, 77; 5, 90; 5, 116; 5, 129; 5, 138; 5, 150; 5, 206; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 11; 8, pattern_list; 8, 9; 8, 10; 9, identifier:n_rows; 10, identifier:n_cols; 11, call; 11, 12; 11, 19; 12, attribute; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:term; 17, identifier:stdscr; 18, identifier:getmaxyx; 19, argument_list; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:window; 23, call; 23, 24; 23, 31; 24, attribute; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:term; 29, identifier:stdscr; 30, identifier:derwin; 31, argument_list; 31, 32; 31, 33; 31, 34; 31, 37; 32, integer:1; 33, identifier:n_cols; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_row; 37, integer:0; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:window; 42, identifier:erase; 43, argument_list; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:window; 48, identifier:bkgd; 49, argument_list; 49, 50; 49, 54; 50, call; 50, 51; 50, 52; 51, identifier:str; 52, argument_list; 52, 53; 53, string:' '; 54, call; 54, 55; 54, 60; 55, attribute; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:term; 59, identifier:attr; 60, argument_list; 60, 61; 61, string:'OrderBar'; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:banner; 65, conditional_expression:if; 65, 66; 65, 69; 65, 74; 66, attribute; 66, 67; 66, 68; 67, identifier:docs; 68, identifier:BANNER_SEARCH; 69, attribute; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:content; 73, identifier:query; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:BANNER; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:items; 80, call; 80, 81; 80, 88; 81, attribute; 81, 82; 81, 87; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:banner; 85, identifier:strip; 86, argument_list; 87, identifier:split; 88, argument_list; 88, 89; 89, string:' '; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:distance; 93, binary_operator:/; 93, 94; 93, 109; 94, parenthesized_expression; 94, 95; 95, binary_operator:-; 95, 96; 95, 108; 96, binary_operator:-; 96, 97; 96, 98; 97, identifier:n_cols; 98, call; 98, 99; 98, 100; 99, identifier:sum; 100, generator_expression; 100, 101; 100, 105; 101, call; 101, 102; 101, 103; 102, identifier:len; 103, argument_list; 103, 104; 104, identifier:t; 105, for_in_clause; 105, 106; 105, 107; 106, identifier:t; 107, identifier:items; 108, integer:1; 109, parenthesized_expression; 109, 110; 110, binary_operator:-; 110, 111; 110, 115; 111, call; 111, 112; 111, 113; 112, identifier:len; 113, argument_list; 113, 114; 114, identifier:items; 115, integer:1; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:spacing; 119, binary_operator:*; 119, 120; 119, 128; 120, call; 120, 121; 120, 122; 121, identifier:max; 122, argument_list; 122, 123; 122, 124; 123, integer:1; 124, call; 124, 125; 124, 126; 125, identifier:int; 126, argument_list; 126, 127; 127, identifier:distance; 128, string:' '; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:text; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:spacing; 135, identifier:join; 136, argument_list; 136, 137; 137, identifier:items; 138, expression_statement; 138, 139; 139, call; 139, 140; 139, 145; 140, attribute; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:term; 144, identifier:add_line; 145, argument_list; 145, 146; 145, 147; 145, 148; 145, 149; 146, identifier:window; 147, identifier:text; 148, integer:0; 149, integer:0; 150, if_statement; 150, 151; 150, 158; 151, comparison_operator:is; 151, 152; 151, 157; 152, attribute; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:content; 156, identifier:order; 157, None; 158, block; 158, 159; 158, 174; 158, 185; 158, 196; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:order; 162, subscript; 162, 163; 162, 173; 163, call; 163, 164; 163, 171; 164, attribute; 164, 165; 164, 170; 165, attribute; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:content; 169, identifier:order; 170, identifier:split; 171, argument_list; 171, 172; 172, string:'-'; 173, integer:0; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:col; 177, binary_operator:-; 177, 178; 177, 184; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:text; 181, identifier:find; 182, argument_list; 182, 183; 183, identifier:order; 184, integer:3; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:attr; 188, call; 188, 189; 188, 194; 189, attribute; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:self; 192, identifier:term; 193, identifier:attr; 194, argument_list; 194, 195; 195, string:'OrderBarHighlight'; 196, expression_statement; 196, 197; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:window; 200, identifier:chgat; 201, argument_list; 201, 202; 201, 203; 201, 204; 201, 205; 202, integer:0; 203, identifier:col; 204, integer:3; 205, identifier:attr; 206, expression_statement; 206, 207; 207, augmented_assignment:+=; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:self; 210, identifier:_row; 211, integer:1 | def _draw_banner(self):
n_rows, n_cols = self.term.stdscr.getmaxyx()
window = self.term.stdscr.derwin(1, n_cols, self._row, 0)
window.erase()
window.bkgd(str(' '), self.term.attr('OrderBar'))
banner = docs.BANNER_SEARCH if self.content.query else self.BANNER
items = banner.strip().split(' ')
distance = (n_cols - sum(len(t) for t in items) - 1) / (len(items) - 1)
spacing = max(1, int(distance)) * ' '
text = spacing.join(items)
self.term.add_line(window, text, 0, 0)
if self.content.order is not None:
order = self.content.order.split('-')[0]
col = text.find(order) - 3
attr = self.term.attr('OrderBarHighlight')
window.chgat(0, col, 3, attr)
self._row += 1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:from_url; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:reddit_session; 5, identifier:url; 6, default_parameter; 6, 7; 6, 8; 7, identifier:comment_limit; 8, integer:0; 9, default_parameter; 9, 10; 9, 11; 10, identifier:comment_sort; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:comments_only; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:params; 17, None; 18, block; 18, 19; 18, 28; 18, 35; 18, 44; 18, 67; 18, 74; 18, 90; 18, 112; 18, 121; 18, 133; 18, 144; 18, 153; 18, 159; 18, 165; 19, if_statement; 19, 20; 19, 23; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:params; 22, None; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:params; 27, dictionary; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:parsed; 31, call; 31, 32; 31, 33; 32, identifier:urlparse; 33, argument_list; 33, 34; 34, identifier:url; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:query_pairs; 38, call; 38, 39; 38, 40; 39, identifier:parse_qs; 40, argument_list; 40, 41; 41, attribute; 41, 42; 41, 43; 42, identifier:parsed; 43, identifier:query; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:get_params; 47, call; 47, 48; 47, 49; 48, identifier:dict; 49, generator_expression; 49, 50; 49, 58; 50, tuple; 50, 51; 50, 52; 51, identifier:k; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, string:","; 55, identifier:join; 56, argument_list; 56, 57; 57, identifier:v; 58, for_in_clause; 58, 59; 58, 62; 59, pattern_list; 59, 60; 59, 61; 60, identifier:k; 61, identifier:v; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:query_pairs; 65, identifier:items; 66, argument_list; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:params; 71, identifier:update; 72, argument_list; 72, 73; 73, identifier:get_params; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:url; 77, call; 77, 78; 77, 79; 78, identifier:urlunparse; 79, argument_list; 79, 80; 80, binary_operator:+; 80, 81; 80, 86; 81, subscript; 81, 82; 81, 83; 82, identifier:parsed; 83, slice; 83, 84; 83, 85; 84, colon; 85, integer:3; 86, tuple; 86, 87; 86, 88; 86, 89; 87, string:""; 88, string:""; 89, string:""; 90, if_statement; 90, 91; 90, 94; 90, 101; 91, comparison_operator:is; 91, 92; 91, 93; 92, identifier:comment_limit; 93, None; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:params; 99, string:'limit'; 100, integer:2048; 101, elif_clause; 101, 102; 101, 105; 102, comparison_operator:>; 102, 103; 102, 104; 103, identifier:comment_limit; 104, integer:0; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 111; 108, subscript; 108, 109; 108, 110; 109, identifier:params; 110, string:'limit'; 111, identifier:comment_limit; 112, if_statement; 112, 113; 112, 114; 113, identifier:comment_sort; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 120; 117, subscript; 117, 118; 117, 119; 118, identifier:params; 119, string:'sort'; 120, identifier:comment_sort; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:response; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:reddit_session; 127, identifier:request_json; 128, argument_list; 128, 129; 128, 130; 129, identifier:url; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:params; 132, identifier:params; 133, if_statement; 133, 134; 133, 135; 134, identifier:comments_only; 135, block; 135, 136; 136, return_statement; 136, 137; 137, subscript; 137, 138; 137, 143; 138, subscript; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:response; 141, integer:1; 142, string:'data'; 143, string:'children'; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:submission; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:Submission; 150, identifier:from_json; 151, argument_list; 151, 152; 152, identifier:response; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:submission; 157, identifier:_comment_sort; 158, identifier:comment_sort; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 164; 161, attribute; 161, 162; 161, 163; 162, identifier:submission; 163, identifier:_params; 164, identifier:params; 165, return_statement; 165, 166; 166, identifier:submission | def from_url(reddit_session, url, comment_limit=0, comment_sort=None,
comments_only=False, params=None):
if params is None:
params = {}
parsed = urlparse(url)
query_pairs = parse_qs(parsed.query)
get_params = dict((k, ",".join(v)) for k, v in query_pairs.items())
params.update(get_params)
url = urlunparse(parsed[:3] + ("", "", ""))
if comment_limit is None:
params['limit'] = 2048
elif comment_limit > 0:
params['limit'] = comment_limit
if comment_sort:
params['sort'] = comment_sort
response = reddit_session.request_json(url, params=params)
if comments_only:
return response[1]['data']['children']
submission = Submission.from_json(response)
submission._comment_sort = comment_sort
submission._params = params
return submission |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:set_suggested_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, string:'blank'; 8, block; 8, 9; 8, 19; 8, 31; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:url; 12, subscript; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:reddit_session; 17, identifier:config; 18, string:'suggested_sort'; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:data; 22, dictionary; 22, 23; 22, 28; 23, pair; 23, 24; 23, 25; 24, string:'id'; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:fullname; 28, pair; 28, 29; 28, 30; 29, string:'sort'; 30, identifier:sort; 31, return_statement; 31, 32; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:reddit_session; 37, identifier:request_json; 38, argument_list; 38, 39; 38, 40; 39, identifier:url; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:data; 42, identifier:data | def set_suggested_sort(self, sort='blank'):
url = self.reddit_session.config['suggested_sort']
data = {'id': self.fullname, 'sort': sort}
return self.reddit_session.request_json(url, data=data) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:is_jump_back; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:offset; 6, identifier:extended_arg; 7, block; 7, 8; 7, 23; 8, if_statement; 8, 9; 8, 20; 9, comparison_operator:!=; 9, 10; 9, 15; 10, subscript; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:code; 14, identifier:offset; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:opc; 19, identifier:JUMP_ABSOLUTE; 20, block; 20, 21; 21, return_statement; 21, 22; 22, False; 23, return_statement; 23, 24; 24, comparison_operator:>; 24, 25; 24, 26; 25, identifier:offset; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:get_target; 30, argument_list; 30, 31; 30, 32; 31, identifier:offset; 32, identifier:extended_arg | def is_jump_back(self, offset, extended_arg):
if self.code[offset] != self.opc.JUMP_ABSOLUTE:
return False
return offset > self.get_target(offset, extended_arg) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:is_jump_forward; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:offset; 6, block; 6, 7; 6, 18; 6, 25; 6, 32; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:opname; 10, attribute; 10, 11; 10, 17; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:get_inst; 15, argument_list; 15, 16; 16, identifier:offset; 17, identifier:opname; 18, if_statement; 18, 19; 18, 22; 19, comparison_operator:==; 19, 20; 19, 21; 20, identifier:opname; 21, string:'JUMP_FORWARD'; 22, block; 22, 23; 23, return_statement; 23, 24; 24, True; 25, if_statement; 25, 26; 25, 29; 26, comparison_operator:!=; 26, 27; 26, 28; 27, identifier:opname; 28, string:'JUMP_ABSOLUTE'; 29, block; 29, 30; 30, return_statement; 30, 31; 31, False; 32, return_statement; 32, 33; 33, comparison_operator:<; 33, 34; 33, 35; 34, identifier:offset; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:get_target; 39, argument_list; 39, 40; 40, identifier:offset | def is_jump_forward(self, offset):
opname = self.get_inst(offset).opname
if opname == 'JUMP_FORWARD':
return True
if opname != 'JUMP_ABSOLUTE':
return False
return offset < self.get_target(offset) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:show_grid; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:data_frame; 5, default_parameter; 5, 6; 5, 7; 6, identifier:show_toolbar; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:precision; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:grid_options; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:column_options; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:column_definitions; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:row_edit_callback; 22, None; 23, block; 23, 24; 23, 35; 23, 46; 23, 64; 23, 98; 23, 132; 23, 150; 23, 188; 23, 195; 24, if_statement; 24, 25; 24, 28; 25, comparison_operator:is; 25, 26; 25, 27; 26, identifier:show_toolbar; 27, None; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:show_toolbar; 32, attribute; 32, 33; 32, 34; 33, identifier:defaults; 34, identifier:show_toolbar; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:is; 36, 37; 36, 38; 37, identifier:precision; 38, None; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:precision; 43, attribute; 43, 44; 43, 45; 44, identifier:defaults; 45, identifier:precision; 46, if_statement; 46, 47; 46, 53; 47, not_operator; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:isinstance; 50, argument_list; 50, 51; 50, 52; 51, identifier:precision; 52, identifier:Integral; 53, block; 53, 54; 54, raise_statement; 54, 55; 55, call; 55, 56; 55, 57; 56, identifier:TypeError; 57, argument_list; 57, 58; 58, binary_operator:%; 58, 59; 58, 60; 59, string:"precision must be int, not %s"; 60, call; 60, 61; 60, 62; 61, identifier:type; 62, argument_list; 62, 63; 63, identifier:precision; 64, if_statement; 64, 65; 64, 68; 64, 75; 65, comparison_operator:is; 65, 66; 65, 67; 66, identifier:column_options; 67, None; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:column_options; 72, attribute; 72, 73; 72, 74; 73, identifier:defaults; 74, identifier:column_options; 75, else_clause; 75, 76; 76, block; 76, 77; 76, 87; 76, 94; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:options; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:defaults; 84, identifier:column_options; 85, identifier:copy; 86, argument_list; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:options; 91, identifier:update; 92, argument_list; 92, 93; 93, identifier:column_options; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:column_options; 97, identifier:options; 98, if_statement; 98, 99; 98, 102; 98, 109; 99, comparison_operator:is; 99, 100; 99, 101; 100, identifier:grid_options; 101, None; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:grid_options; 106, attribute; 106, 107; 106, 108; 107, identifier:defaults; 108, identifier:grid_options; 109, else_clause; 109, 110; 110, block; 110, 111; 110, 121; 110, 128; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:options; 114, call; 114, 115; 114, 120; 115, attribute; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:defaults; 118, identifier:grid_options; 119, identifier:copy; 120, argument_list; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:options; 125, identifier:update; 126, argument_list; 126, 127; 127, identifier:grid_options; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:grid_options; 131, identifier:options; 132, if_statement; 132, 133; 132, 139; 133, not_operator; 133, 134; 134, call; 134, 135; 134, 136; 135, identifier:isinstance; 136, argument_list; 136, 137; 136, 138; 137, identifier:grid_options; 138, identifier:dict; 139, block; 139, 140; 140, raise_statement; 140, 141; 141, call; 141, 142; 141, 143; 142, identifier:TypeError; 143, argument_list; 143, 144; 144, binary_operator:%; 144, 145; 144, 146; 145, string:"grid_options must be dict, not %s"; 146, call; 146, 147; 146, 148; 147, identifier:type; 148, argument_list; 148, 149; 149, identifier:grid_options; 150, if_statement; 150, 151; 150, 158; 150, 168; 151, call; 151, 152; 151, 153; 152, identifier:isinstance; 153, argument_list; 153, 154; 153, 155; 154, identifier:data_frame; 155, attribute; 155, 156; 155, 157; 156, identifier:pd; 157, identifier:Series; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:data_frame; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:pd; 165, identifier:DataFrame; 166, argument_list; 166, 167; 167, identifier:data_frame; 168, elif_clause; 168, 169; 168, 177; 169, not_operator; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:isinstance; 172, argument_list; 172, 173; 172, 174; 173, identifier:data_frame; 174, attribute; 174, 175; 174, 176; 175, identifier:pd; 176, identifier:DataFrame; 177, block; 177, 178; 178, raise_statement; 178, 179; 179, call; 179, 180; 179, 181; 180, identifier:TypeError; 181, argument_list; 181, 182; 182, binary_operator:%; 182, 183; 182, 184; 183, string:"data_frame must be DataFrame or Series, not %s"; 184, call; 184, 185; 184, 186; 185, identifier:type; 186, argument_list; 186, 187; 187, identifier:data_frame; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:column_definitions; 191, parenthesized_expression; 191, 192; 192, boolean_operator:or; 192, 193; 192, 194; 193, identifier:column_definitions; 194, dictionary; 195, return_statement; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:QgridWidget; 198, argument_list; 198, 199; 198, 202; 198, 205; 198, 208; 198, 211; 198, 214; 198, 217; 199, keyword_argument; 199, 200; 199, 201; 200, identifier:df; 201, identifier:data_frame; 202, keyword_argument; 202, 203; 202, 204; 203, identifier:precision; 204, identifier:precision; 205, keyword_argument; 205, 206; 205, 207; 206, identifier:grid_options; 207, identifier:grid_options; 208, keyword_argument; 208, 209; 208, 210; 209, identifier:column_options; 210, identifier:column_options; 211, keyword_argument; 211, 212; 211, 213; 212, identifier:column_definitions; 213, identifier:column_definitions; 214, keyword_argument; 214, 215; 214, 216; 215, identifier:row_edit_callback; 216, identifier:row_edit_callback; 217, keyword_argument; 217, 218; 217, 219; 218, identifier:show_toolbar; 219, identifier:show_toolbar | def show_grid(data_frame,
show_toolbar=None,
precision=None,
grid_options=None,
column_options=None,
column_definitions=None,
row_edit_callback=None):
if show_toolbar is None:
show_toolbar = defaults.show_toolbar
if precision is None:
precision = defaults.precision
if not isinstance(precision, Integral):
raise TypeError("precision must be int, not %s" % type(precision))
if column_options is None:
column_options = defaults.column_options
else:
options = defaults.column_options.copy()
options.update(column_options)
column_options = options
if grid_options is None:
grid_options = defaults.grid_options
else:
options = defaults.grid_options.copy()
options.update(grid_options)
grid_options = options
if not isinstance(grid_options, dict):
raise TypeError(
"grid_options must be dict, not %s" % type(grid_options)
)
if isinstance(data_frame, pd.Series):
data_frame = pd.DataFrame(data_frame)
elif not isinstance(data_frame, pd.DataFrame):
raise TypeError(
"data_frame must be DataFrame or Series, not %s" % type(data_frame)
)
column_definitions = (column_definitions or {})
return QgridWidget(df=data_frame, precision=precision,
grid_options=grid_options,
column_options=column_options,
column_definitions=column_definitions,
row_edit_callback=row_edit_callback,
show_toolbar=show_toolbar) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_eigsorted; 3, parameters; 3, 4; 3, 5; 4, identifier:cov; 5, default_parameter; 5, 6; 5, 7; 6, identifier:asc; 7, True; 8, block; 8, 9; 8, 22; 8, 30; 8, 44; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 14; 11, pattern_list; 11, 12; 11, 13; 12, identifier:eigval; 13, identifier:eigvec; 14, call; 14, 15; 14, 20; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:np; 18, identifier:linalg; 19, identifier:eigh; 20, argument_list; 20, 21; 21, identifier:cov; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:order; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:eigval; 28, identifier:argsort; 29, argument_list; 30, if_statement; 30, 31; 30, 33; 31, not_operator; 31, 32; 32, identifier:asc; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:order; 37, subscript; 37, 38; 37, 39; 38, identifier:order; 39, slice; 39, 40; 39, 41; 39, 42; 40, colon; 41, colon; 42, unary_operator:-; 42, 43; 43, integer:1; 44, return_statement; 44, 45; 45, expression_list; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:eigval; 48, identifier:order; 49, subscript; 49, 50; 49, 51; 49, 53; 50, identifier:eigvec; 51, slice; 51, 52; 52, colon; 53, identifier:order | def _eigsorted(cov, asc=True):
eigval, eigvec = np.linalg.eigh(cov)
order = eigval.argsort()
if not asc:
order = order[::-1]
return eigval[order], eigvec[:, order] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_args; 3, parameters; 3, 4; 4, identifier:args; 5, block; 5, 6; 5, 14; 5, 31; 5, 42; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:args; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:args; 12, identifier:copy; 13, argument_list; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:flags; 17, list_comprehension; 17, 18; 17, 19; 17, 22; 18, identifier:i; 19, for_in_clause; 19, 20; 19, 21; 20, identifier:i; 21, identifier:args; 22, if_clause; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:FLAGS_RE; 26, identifier:match; 27, argument_list; 27, 28; 28, subscript; 28, 29; 28, 30; 29, identifier:i; 30, integer:1; 31, for_statement; 31, 32; 31, 33; 31, 34; 32, identifier:i; 33, identifier:flags; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:args; 39, identifier:remove; 40, argument_list; 40, 41; 41, identifier:i; 42, return_statement; 42, 43; 43, binary_operator:+; 43, 44; 43, 45; 44, identifier:args; 45, identifier:flags | def sort_args(args):
args = args.copy()
flags = [i for i in args if FLAGS_RE.match(i[1])]
for i in flags:
args.remove(i)
return args + flags |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:plot_fracs; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:Q; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ax; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:fignum; 13, None; 14, block; 14, 15; 14, 22; 14, 28; 14, 36; 14, 59; 14, 70; 14, 79; 14, 100; 14, 122; 14, 129; 14, 136; 14, 150; 14, 170; 14, 181; 15, import_from_statement; 15, 16; 15, 20; 16, relative_import; 16, 17; 16, 18; 17, import_prefix; 18, dotted_name; 18, 19; 19, identifier:plotting; 20, dotted_name; 20, 21; 21, identifier:Tango; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:Tango; 26, identifier:reset; 27, argument_list; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:col; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:Tango; 34, identifier:nextMedium; 35, argument_list; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:is; 37, 38; 37, 39; 38, identifier:ax; 39, None; 40, block; 40, 41; 40, 50; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:fig; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:pylab; 47, identifier:figure; 48, argument_list; 48, 49; 49, identifier:fignum; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:ax; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:fig; 56, identifier:add_subplot; 57, argument_list; 57, 58; 58, integer:111; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:is; 60, 61; 60, 62; 61, identifier:Q; 62, None; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:Q; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:Q; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:ticks; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:numpy; 76, identifier:arange; 77, argument_list; 77, 78; 78, identifier:Q; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:bar; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:ax; 85, identifier:bar; 86, argument_list; 86, 87; 86, 90; 86, 97; 87, binary_operator:-; 87, 88; 87, 89; 88, identifier:ticks; 89, float:.4; 90, subscript; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:fracs; 94, slice; 94, 95; 94, 96; 95, colon; 96, identifier:Q; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:color; 99, identifier:col; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:ax; 104, identifier:set_xticks; 105, argument_list; 105, 106; 105, 107; 106, identifier:ticks; 107, call; 107, 108; 107, 109; 108, identifier:map; 109, argument_list; 109, 110; 109, 119; 110, lambda; 110, 111; 110, 113; 111, lambda_parameters; 111, 112; 112, identifier:x; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, string:r"${}$"; 116, identifier:format; 117, argument_list; 117, 118; 118, identifier:x; 119, binary_operator:+; 119, 120; 119, 121; 120, identifier:ticks; 121, integer:1; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:ax; 126, identifier:set_ylabel; 127, argument_list; 127, 128; 128, string:"Eigenvalue fraction"; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:ax; 133, identifier:set_xlabel; 134, argument_list; 134, 135; 135, string:"PC"; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:ax; 140, identifier:set_ylim; 141, argument_list; 141, 142; 141, 143; 142, integer:0; 143, subscript; 143, 144; 143, 149; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:ax; 147, identifier:get_ylim; 148, argument_list; 149, integer:1; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:ax; 154, identifier:set_xlim; 155, argument_list; 155, 156; 155, 163; 156, binary_operator:-; 156, 157; 156, 162; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:ticks; 160, identifier:min; 161, argument_list; 162, float:.5; 163, binary_operator:+; 163, 164; 163, 169; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:ticks; 167, identifier:max; 168, argument_list; 169, float:.5; 170, try_statement; 170, 171; 170, 178; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:pylab; 176, identifier:tight_layout; 177, argument_list; 178, except_clause; 178, 179; 179, block; 179, 180; 180, pass_statement; 181, return_statement; 181, 182; 182, identifier:bar | def plot_fracs(self, Q=None, ax=None, fignum=None):
from ..plotting import Tango
Tango.reset()
col = Tango.nextMedium()
if ax is None:
fig = pylab.figure(fignum)
ax = fig.add_subplot(111)
if Q is None:
Q = self.Q
ticks = numpy.arange(Q)
bar = ax.bar(ticks - .4, self.fracs[:Q], color=col)
ax.set_xticks(ticks, map(lambda x: r"${}$".format(x), ticks + 1))
ax.set_ylabel("Eigenvalue fraction")
ax.set_xlabel("PC")
ax.set_ylim(0, ax.get_ylim()[1])
ax.set_xlim(ticks.min() - .5, ticks.max() + .5)
try:
pylab.tight_layout()
except:
pass
return bar |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 1, 17; 2, function_name:_distance_squared; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:p2; 7, type; 7, 8; 8, string:"Point2"; 9, type; 9, 10; 10, generic_type; 10, 11; 10, 12; 11, identifier:Union; 12, type_parameter; 12, 13; 12, 15; 13, type; 13, 14; 14, identifier:int; 15, type; 15, 16; 16, identifier:float; 17, block; 17, 18; 18, return_statement; 18, 19; 19, binary_operator:+; 19, 20; 19, 30; 20, binary_operator:**; 20, 21; 20, 29; 21, parenthesized_expression; 21, 22; 22, binary_operator:-; 22, 23; 22, 26; 23, subscript; 23, 24; 23, 25; 24, identifier:self; 25, integer:0; 26, subscript; 26, 27; 26, 28; 27, identifier:p2; 28, integer:0; 29, integer:2; 30, binary_operator:**; 30, 31; 30, 39; 31, parenthesized_expression; 31, 32; 32, binary_operator:-; 32, 33; 32, 36; 33, subscript; 33, 34; 33, 35; 34, identifier:self; 35, integer:1; 36, subscript; 36, 37; 36, 38; 37, identifier:p2; 38, integer:1; 39, integer:2 | def _distance_squared(self, p2: "Point2") -> Union[int, float]:
return (self[0] - p2[0]) ** 2 + (self[1] - p2[1]) ** 2 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_next_of_type; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:processor_type; 6, block; 6, 7; 7, with_statement; 7, 8; 7, 13; 8, with_clause; 8, 9; 9, with_item; 9, 10; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_condition; 13, block; 13, 14; 13, 26; 13, 50; 13, 56; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:not; 15, 16; 15, 17; 16, identifier:processor_type; 17, identifier:self; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:wait_for_registration; 24, argument_list; 24, 25; 25, identifier:processor_type; 26, try_statement; 26, 27; 26, 38; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:processor; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, subscript; 33, 34; 33, 35; 34, identifier:self; 35, identifier:processor_type; 36, identifier:next_processor; 37, argument_list; 38, except_clause; 38, 39; 38, 40; 39, identifier:NoProcessorVacancyError; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:processor; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:wait_for_vacancy; 48, argument_list; 48, 49; 49, identifier:processor_type; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:processor; 54, identifier:inc_occupancy; 55, argument_list; 56, return_statement; 56, 57; 57, identifier:processor | def get_next_of_type(self, processor_type):
with self._condition:
if processor_type not in self:
self.wait_for_registration(processor_type)
try:
processor = self[processor_type].next_processor()
except NoProcessorVacancyError:
processor = self.wait_for_vacancy(processor_type)
processor.inc_occupancy()
return processor |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:wait_for_registration; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:processor_type; 6, block; 6, 7; 7, with_statement; 7, 8; 7, 13; 8, with_clause; 8, 9; 9, with_item; 9, 10; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_condition; 13, block; 13, 14; 13, 35; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_condition; 20, identifier:wait_for; 21, argument_list; 21, 22; 22, lambda; 22, 23; 23, parenthesized_expression; 23, 24; 24, boolean_operator:or; 24, 25; 24, 28; 25, comparison_operator:in; 25, 26; 25, 27; 26, identifier:processor_type; 27, identifier:self; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_cancelled_event; 33, identifier:is_set; 34, argument_list; 35, if_statement; 35, 36; 35, 43; 36, call; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:_cancelled_event; 41, identifier:is_set; 42, argument_list; 43, block; 43, 44; 44, raise_statement; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:WaitCancelledException; 47, argument_list | def wait_for_registration(self, processor_type):
with self._condition:
self._condition.wait_for(lambda: (
processor_type in self
or self._cancelled_event.is_set()))
if self._cancelled_event.is_set():
raise WaitCancelledException() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:wait_for_vacancy; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:processor_type; 6, block; 6, 7; 7, with_statement; 7, 8; 7, 13; 8, with_clause; 8, 9; 9, with_item; 9, 10; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_condition; 13, block; 13, 14; 13, 38; 13, 51; 13, 61; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_condition; 20, identifier:wait_for; 21, argument_list; 21, 22; 22, lambda; 22, 23; 23, parenthesized_expression; 23, 24; 24, boolean_operator:or; 24, 25; 24, 31; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_processor_available; 29, argument_list; 29, 30; 30, identifier:processor_type; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:_cancelled_event; 36, identifier:is_set; 37, argument_list; 38, if_statement; 38, 39; 38, 46; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_cancelled_event; 44, identifier:is_set; 45, argument_list; 46, block; 46, 47; 47, raise_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:WaitCancelledException; 50, argument_list; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:processor; 54, call; 54, 55; 54, 60; 55, attribute; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:self; 58, identifier:processor_type; 59, identifier:next_processor; 60, argument_list; 61, return_statement; 61, 62; 62, identifier:processor | def wait_for_vacancy(self, processor_type):
with self._condition:
self._condition.wait_for(lambda: (
self._processor_available(processor_type)
or self._cancelled_event.is_set()))
if self._cancelled_event.is_set():
raise WaitCancelledException()
processor = self[processor_type].next_processor()
return processor |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_sorting_message; 3, parameters; 3, 4; 3, 5; 4, identifier:request; 5, identifier:key; 6, block; 6, 7; 6, 11; 6, 25; 6, 32; 6, 94; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:control_list; 10, list:[]; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:reverse; 14, call; 14, 15; 14, 22; 15, attribute; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:request; 19, identifier:url; 20, identifier:query; 21, identifier:get; 22, argument_list; 22, 23; 22, 24; 23, string:'reverse'; 24, None; 25, if_statement; 25, 26; 25, 29; 26, comparison_operator:is; 26, 27; 26, 28; 27, identifier:reverse; 28, None; 29, block; 29, 30; 30, return_statement; 30, 31; 31, identifier:control_list; 32, if_statement; 32, 33; 32, 40; 32, 63; 33, comparison_operator:==; 33, 34; 33, 39; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:reverse; 37, identifier:lower; 38, argument_list; 39, string:""; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:control_list; 45, identifier:append; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:client_list_control_pb2; 50, identifier:ClientSortControls; 51, argument_list; 51, 52; 51, 55; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:reverse; 54, True; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:keys; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:key; 60, identifier:split; 61, argument_list; 61, 62; 62, string:","; 63, elif_clause; 63, 64; 63, 71; 64, comparison_operator:!=; 64, 65; 64, 70; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:reverse; 68, identifier:lower; 69, argument_list; 70, string:'false'; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:control_list; 76, identifier:append; 77, argument_list; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:client_list_control_pb2; 81, identifier:ClientSortControls; 82, argument_list; 82, 83; 82, 86; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:reverse; 85, True; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:keys; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:reverse; 91, identifier:split; 92, argument_list; 92, 93; 93, string:","; 94, return_statement; 94, 95; 95, identifier:control_list | def _get_sorting_message(request, key):
control_list = []
reverse = request.url.query.get('reverse', None)
if reverse is None:
return control_list
if reverse.lower() == "":
control_list.append(client_list_control_pb2.ClientSortControls(
reverse=True,
keys=key.split(",")
))
elif reverse.lower() != 'false':
control_list.append(client_list_control_pb2.ClientSortControls(
reverse=True,
keys=reverse.split(",")
))
return control_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort_resources; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:cls; 5, identifier:request; 6, identifier:resources; 7, identifier:fail_enum; 8, default_parameter; 8, 9; 8, 10; 9, identifier:header_proto; 10, None; 11, block; 11, 12; 11, 20; 11, 31; 11, 80; 12, if_statement; 12, 13; 12, 17; 13, not_operator; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:request; 16, identifier:sorting; 17, block; 17, 18; 18, return_statement; 18, 19; 19, identifier:resources; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:value_handlers; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:cls; 26, identifier:_get_handler_set; 27, argument_list; 27, 28; 27, 29; 27, 30; 28, identifier:request; 29, identifier:fail_enum; 30, identifier:header_proto; 31, function_definition; 31, 32; 31, 33; 31, 36; 32, function_name:sorter; 33, parameters; 33, 34; 33, 35; 34, identifier:resource_a; 35, identifier:resource_b; 36, block; 36, 37; 36, 78; 37, for_statement; 37, 38; 37, 39; 37, 40; 38, identifier:handler; 39, identifier:value_handlers; 40, block; 40, 41; 40, 53; 40, 66; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 46; 43, pattern_list; 43, 44; 43, 45; 44, identifier:val_a; 45, identifier:val_b; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:handler; 49, identifier:get_sort_values; 50, argument_list; 50, 51; 50, 52; 51, identifier:resource_a; 52, identifier:resource_b; 53, if_statement; 53, 54; 53, 57; 54, comparison_operator:<; 54, 55; 54, 56; 55, identifier:val_a; 56, identifier:val_b; 57, block; 57, 58; 58, return_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:handler; 62, identifier:xform_result; 63, argument_list; 63, 64; 64, unary_operator:-; 64, 65; 65, integer:1; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:>; 67, 68; 67, 69; 68, identifier:val_a; 69, identifier:val_b; 70, block; 70, 71; 71, return_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:handler; 75, identifier:xform_result; 76, argument_list; 76, 77; 77, integer:1; 78, return_statement; 78, 79; 79, integer:0; 80, return_statement; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:sorted; 83, argument_list; 83, 84; 83, 85; 84, identifier:resources; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:key; 87, call; 87, 88; 87, 89; 88, identifier:cmp_to_key; 89, argument_list; 89, 90; 90, identifier:sorter | def sort_resources(cls, request, resources, fail_enum, header_proto=None):
if not request.sorting:
return resources
value_handlers = cls._get_handler_set(request, fail_enum, header_proto)
def sorter(resource_a, resource_b):
for handler in value_handlers:
val_a, val_b = handler.get_sort_values(resource_a, resource_b)
if val_a < val_b:
return handler.xform_result(-1)
if val_a > val_b:
return handler.xform_result(1)
return 0
return sorted(resources, key=cmp_to_key(sorter)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:_get_handler_set; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:cls; 5, identifier:request; 6, identifier:fail_enum; 7, default_parameter; 7, 8; 7, 9; 8, identifier:header_proto; 9, None; 10, block; 10, 11; 10, 17; 10, 21; 10, 61; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:added; 14, call; 14, 15; 14, 16; 15, identifier:set; 16, argument_list; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:handlers; 20, list:[]; 21, for_statement; 21, 22; 21, 23; 21, 26; 22, identifier:controls; 23, attribute; 23, 24; 23, 25; 24, identifier:request; 25, identifier:sorting; 26, block; 26, 27; 26, 35; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:control_bytes; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:controls; 33, identifier:SerializeToString; 34, argument_list; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:not; 36, 37; 36, 38; 37, identifier:control_bytes; 38, identifier:added; 39, block; 39, 40; 39, 47; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:added; 44, identifier:add; 45, argument_list; 45, 46; 46, identifier:control_bytes; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:handlers; 51, identifier:append; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:cls; 56, identifier:_ValueHandler; 57, argument_list; 57, 58; 57, 59; 57, 60; 58, identifier:controls; 59, identifier:fail_enum; 60, identifier:header_proto; 61, return_statement; 61, 62; 62, identifier:handlers | def _get_handler_set(cls, request, fail_enum, header_proto=None):
added = set()
handlers = []
for controls in request.sorting:
control_bytes = controls.SerializeToString()
if control_bytes not in added:
added.add(control_bytes)
handlers.append(
cls._ValueHandler(controls, fail_enum, header_proto))
return handlers |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:find_write_predecessors; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:address; 6, block; 6, 7; 6, 13; 6, 17; 6, 28; 6, 35; 6, 117; 6, 153; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:predecessors; 10, call; 10, 11; 10, 12; 11, identifier:set; 12, argument_list; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:enclosing_writer; 16, None; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:node_stream; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_tree; 25, identifier:walk; 26, argument_list; 26, 27; 27, identifier:address; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:address_len; 31, call; 31, 32; 31, 33; 32, identifier:len; 33, argument_list; 33, 34; 34, identifier:address; 35, try_statement; 35, 36; 35, 79; 35, 103; 36, block; 36, 37; 37, for_statement; 37, 38; 37, 41; 37, 42; 38, pattern_list; 38, 39; 38, 40; 39, identifier:node_address; 40, identifier:node; 41, identifier:node_stream; 42, block; 42, 43; 43, if_statement; 43, 44; 43, 47; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:node; 46, None; 47, block; 47, 48; 47, 57; 47, 70; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:predecessors; 52, identifier:update; 53, argument_list; 53, 54; 54, attribute; 54, 55; 54, 56; 55, identifier:node; 56, identifier:readers; 57, if_statement; 57, 58; 57, 63; 58, comparison_operator:is; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:node; 61, identifier:writer; 62, None; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:enclosing_writer; 67, attribute; 67, 68; 67, 69; 68, identifier:node; 69, identifier:writer; 70, if_statement; 70, 71; 70, 77; 71, comparison_operator:>=; 71, 72; 71, 76; 72, call; 72, 73; 72, 74; 73, identifier:len; 74, argument_list; 74, 75; 75, identifier:node_address; 76, identifier:address_len; 77, block; 77, 78; 78, break_statement; 79, except_clause; 79, 80; 79, 84; 80, as_pattern; 80, 81; 80, 82; 81, identifier:AddressNotInTree; 82, as_pattern_target; 82, 83; 83, identifier:err; 84, block; 84, 85; 84, 101; 85, if_statement; 85, 86; 85, 91; 86, comparison_operator:is; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:err; 89, identifier:match; 90, None; 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:find_write_predecessors; 97, argument_list; 97, 98; 98, attribute; 98, 99; 98, 100; 99, identifier:err; 100, identifier:match; 101, return_statement; 101, 102; 102, identifier:predecessors; 103, finally_clause; 103, 104; 104, block; 104, 105; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:is; 106, 107; 106, 108; 107, identifier:enclosing_writer; 108, None; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:predecessors; 114, identifier:add; 115, argument_list; 115, 116; 116, identifier:enclosing_writer; 117, for_statement; 117, 118; 117, 121; 117, 122; 118, pattern_list; 118, 119; 118, 120; 119, identifier:_; 120, identifier:node; 121, identifier:node_stream; 122, block; 122, 123; 123, if_statement; 123, 124; 123, 127; 124, comparison_operator:is; 124, 125; 124, 126; 125, identifier:node; 126, None; 127, block; 127, 128; 127, 144; 128, if_statement; 128, 129; 128, 134; 129, comparison_operator:is; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:node; 132, identifier:writer; 133, None; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:predecessors; 139, identifier:add; 140, argument_list; 140, 141; 141, attribute; 141, 142; 141, 143; 142, identifier:node; 143, identifier:writer; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:predecessors; 148, identifier:update; 149, argument_list; 149, 150; 150, attribute; 150, 151; 150, 152; 151, identifier:node; 152, identifier:readers; 153, return_statement; 153, 154; 154, identifier:predecessors | def find_write_predecessors(self, address):
predecessors = set()
enclosing_writer = None
node_stream = self._tree.walk(address)
address_len = len(address)
try:
for node_address, node in node_stream:
if node is not None:
predecessors.update(node.readers)
if node.writer is not None:
enclosing_writer = node.writer
if len(node_address) >= address_len:
break
except AddressNotInTree as err:
if err.match is not None:
return self.find_write_predecessors(err.match)
return predecessors
finally:
if enclosing_writer is not None:
predecessors.add(enclosing_writer)
for _, node in node_stream:
if node is not None:
if node.writer is not None:
predecessors.add(node.writer)
predecessors.update(node.readers)
return predecessors |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:_get_efron_values_single; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:self; 5, identifier:X; 6, identifier:T; 7, identifier:E; 8, identifier:weights; 9, identifier:beta; 10, block; 10, 11; 10, 19; 10, 30; 10, 40; 10, 44; 10, 54; 10, 62; 10, 82; 10, 104; 10, 108; 10, 112; 10, 129; 10, 473; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 16; 13, pattern_list; 13, 14; 13, 15; 14, identifier:n; 15, identifier:d; 16, attribute; 16, 17; 16, 18; 17, identifier:X; 18, identifier:shape; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:hessian; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:np; 25, identifier:zeros; 26, argument_list; 26, 27; 27, tuple; 27, 28; 27, 29; 28, identifier:d; 29, identifier:d; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:gradient; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:np; 36, identifier:zeros; 37, argument_list; 37, 38; 38, tuple; 38, 39; 39, identifier:d; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:log_lik; 43, integer:0; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:x_death_sum; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:np; 50, identifier:zeros; 51, argument_list; 51, 52; 52, tuple; 52, 53; 53, identifier:d; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, pattern_list; 56, 57; 56, 58; 57, identifier:risk_phi; 58, identifier:tie_phi; 59, expression_list; 59, 60; 59, 61; 60, integer:0; 61, integer:0; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, pattern_list; 64, 65; 64, 66; 65, identifier:risk_phi_x; 66, identifier:tie_phi_x; 67, expression_list; 67, 68; 67, 75; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:np; 71, identifier:zeros; 72, argument_list; 72, 73; 73, tuple; 73, 74; 74, identifier:d; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:np; 78, identifier:zeros; 79, argument_list; 79, 80; 80, tuple; 80, 81; 81, identifier:d; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, pattern_list; 84, 85; 84, 86; 85, identifier:risk_phi_x_x; 86, identifier:tie_phi_x_x; 87, expression_list; 87, 88; 87, 96; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:np; 91, identifier:zeros; 92, argument_list; 92, 93; 93, tuple; 93, 94; 93, 95; 94, identifier:d; 95, identifier:d; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:np; 99, identifier:zeros; 100, argument_list; 100, 101; 101, tuple; 101, 102; 101, 103; 102, identifier:d; 103, identifier:d; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:weight_count; 107, float:0.0; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:tied_death_counts; 111, integer:0; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:scores; 115, binary_operator:*; 115, 116; 115, 117; 116, identifier:weights; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:np; 120, identifier:exp; 121, argument_list; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:np; 125, identifier:dot; 126, argument_list; 126, 127; 126, 128; 127, identifier:X; 128, identifier:beta; 129, for_statement; 129, 130; 129, 131; 129, 141; 130, identifier:i; 131, call; 131, 132; 131, 133; 132, identifier:range; 133, argument_list; 133, 134; 133, 137; 133, 139; 134, binary_operator:-; 134, 135; 134, 136; 135, identifier:n; 136, integer:1; 137, unary_operator:-; 137, 138; 138, integer:1; 139, unary_operator:-; 139, 140; 140, integer:1; 141, block; 141, 142; 141, 148; 141, 154; 141, 160; 141, 166; 141, 172; 141, 176; 141, 182; 141, 192; 141, 198; 141, 204; 141, 210; 141, 247; 141, 267; 141, 273; 141, 358; 141, 368; 141, 379; 141, 394; 141, 419; 141, 430; 141, 434; 141, 438; 141, 448; 141, 452; 141, 462; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:ti; 145, subscript; 145, 146; 145, 147; 146, identifier:T; 147, identifier:i; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:ei; 151, subscript; 151, 152; 151, 153; 152, identifier:E; 153, identifier:i; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:xi; 157, subscript; 157, 158; 157, 159; 158, identifier:X; 159, identifier:i; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:score; 163, subscript; 163, 164; 163, 165; 164, identifier:scores; 165, identifier:i; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:w; 169, subscript; 169, 170; 169, 171; 170, identifier:weights; 171, identifier:i; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:phi_i; 175, identifier:score; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:phi_x_i; 179, binary_operator:*; 179, 180; 179, 181; 180, identifier:phi_i; 181, identifier:xi; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:phi_x_x_i; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:np; 188, identifier:outer; 189, argument_list; 189, 190; 189, 191; 190, identifier:xi; 191, identifier:phi_x_i; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:risk_phi; 195, binary_operator:+; 195, 196; 195, 197; 196, identifier:risk_phi; 197, identifier:phi_i; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:risk_phi_x; 201, binary_operator:+; 201, 202; 201, 203; 202, identifier:risk_phi_x; 203, identifier:phi_x_i; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:risk_phi_x_x; 207, binary_operator:+; 207, 208; 207, 209; 208, identifier:risk_phi_x_x; 209, identifier:phi_x_x_i; 210, if_statement; 210, 211; 210, 212; 211, identifier:ei; 212, block; 212, 213; 212, 221; 212, 227; 212, 233; 212, 239; 212, 243; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:x_death_sum; 216, binary_operator:+; 216, 217; 216, 218; 217, identifier:x_death_sum; 218, binary_operator:*; 218, 219; 218, 220; 219, identifier:w; 220, identifier:xi; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:tie_phi; 224, binary_operator:+; 224, 225; 224, 226; 225, identifier:tie_phi; 226, identifier:phi_i; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:tie_phi_x; 230, binary_operator:+; 230, 231; 230, 232; 231, identifier:tie_phi_x; 232, identifier:phi_x_i; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:tie_phi_x_x; 236, binary_operator:+; 236, 237; 236, 238; 237, identifier:tie_phi_x_x; 238, identifier:phi_x_x_i; 239, expression_statement; 239, 240; 240, augmented_assignment:+=; 240, 241; 240, 242; 241, identifier:tied_death_counts; 242, integer:1; 243, expression_statement; 243, 244; 244, augmented_assignment:+=; 244, 245; 244, 246; 245, identifier:weight_count; 246, identifier:w; 247, if_statement; 247, 248; 247, 259; 247, 261; 248, boolean_operator:and; 248, 249; 248, 252; 249, comparison_operator:>; 249, 250; 249, 251; 250, identifier:i; 251, integer:0; 252, comparison_operator:==; 252, 253; 252, 258; 253, subscript; 253, 254; 253, 255; 254, identifier:T; 255, binary_operator:-; 255, 256; 255, 257; 256, identifier:i; 257, integer:1; 258, identifier:ti; 259, block; 259, 260; 260, continue_statement; 261, elif_clause; 261, 262; 261, 265; 262, comparison_operator:==; 262, 263; 262, 264; 263, identifier:tied_death_counts; 264, integer:0; 265, block; 265, 266; 266, continue_statement; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:weighted_average; 270, binary_operator:/; 270, 271; 270, 272; 271, identifier:weight_count; 272, identifier:tied_death_counts; 273, if_statement; 273, 274; 273, 277; 273, 334; 274, comparison_operator:>; 274, 275; 274, 276; 275, identifier:tied_death_counts; 276, integer:1; 277, block; 277, 278; 277, 289; 277, 300; 277, 312; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 281; 280, identifier:increasing_proportion; 281, binary_operator:/; 281, 282; 281, 288; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:np; 285, identifier:arange; 286, argument_list; 286, 287; 287, identifier:tied_death_counts; 288, identifier:tied_death_counts; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 292; 291, identifier:denom; 292, binary_operator:/; 292, 293; 292, 294; 293, float:1.0; 294, parenthesized_expression; 294, 295; 295, binary_operator:-; 295, 296; 295, 297; 296, identifier:risk_phi; 297, binary_operator:*; 297, 298; 297, 299; 298, identifier:increasing_proportion; 299, identifier:tie_phi; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:numer; 303, binary_operator:-; 303, 304; 303, 305; 304, identifier:risk_phi_x; 305, call; 305, 306; 305, 309; 306, attribute; 306, 307; 306, 308; 307, identifier:np; 308, identifier:outer; 309, argument_list; 309, 310; 309, 311; 310, identifier:increasing_proportion; 311, identifier:tie_phi_x; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 315; 314, identifier:a1; 315, binary_operator:-; 315, 316; 315, 324; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:np; 319, identifier:einsum; 320, argument_list; 320, 321; 320, 322; 320, 323; 321, string:"ab,i->ab"; 322, identifier:risk_phi_x_x; 323, identifier:denom; 324, call; 324, 325; 324, 328; 325, attribute; 325, 326; 325, 327; 326, identifier:np; 327, identifier:einsum; 328, argument_list; 328, 329; 328, 330; 328, 331; 329, string:"ab,i->ab"; 330, identifier:tie_phi_x_x; 331, binary_operator:*; 331, 332; 331, 333; 332, identifier:increasing_proportion; 333, identifier:denom; 334, else_clause; 334, 335; 335, block; 335, 336; 335, 348; 335, 352; 336, expression_statement; 336, 337; 337, assignment; 337, 338; 337, 339; 338, identifier:denom; 339, binary_operator:/; 339, 340; 339, 341; 340, float:1.0; 341, call; 341, 342; 341, 345; 342, attribute; 342, 343; 342, 344; 343, identifier:np; 344, identifier:array; 345, argument_list; 345, 346; 346, list:[risk_phi]; 346, 347; 347, identifier:risk_phi; 348, expression_statement; 348, 349; 349, assignment; 349, 350; 349, 351; 350, identifier:numer; 351, identifier:risk_phi_x; 352, expression_statement; 352, 353; 353, assignment; 353, 354; 353, 355; 354, identifier:a1; 355, binary_operator:*; 355, 356; 355, 357; 356, identifier:risk_phi_x_x; 357, identifier:denom; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 361; 360, identifier:summand; 361, binary_operator:*; 361, 362; 361, 363; 362, identifier:numer; 363, subscript; 363, 364; 363, 365; 363, 367; 364, identifier:denom; 365, slice; 365, 366; 366, colon; 367, None; 368, expression_statement; 368, 369; 369, assignment; 369, 370; 369, 371; 370, identifier:a2; 371, call; 371, 372; 371, 377; 372, attribute; 372, 373; 372, 376; 373, attribute; 373, 374; 373, 375; 374, identifier:summand; 375, identifier:T; 376, identifier:dot; 377, argument_list; 377, 378; 378, identifier:summand; 379, expression_statement; 379, 380; 380, assignment; 380, 381; 380, 382; 381, identifier:gradient; 382, binary_operator:-; 382, 383; 382, 386; 383, binary_operator:+; 383, 384; 383, 385; 384, identifier:gradient; 385, identifier:x_death_sum; 386, binary_operator:*; 386, 387; 386, 388; 387, identifier:weighted_average; 388, call; 388, 389; 388, 392; 389, attribute; 389, 390; 389, 391; 390, identifier:summand; 391, identifier:sum; 392, argument_list; 392, 393; 393, integer:0; 394, expression_statement; 394, 395; 395, assignment; 395, 396; 395, 397; 396, identifier:log_lik; 397, binary_operator:+; 397, 398; 397, 407; 398, binary_operator:+; 398, 399; 398, 400; 399, identifier:log_lik; 400, call; 400, 401; 400, 404; 401, attribute; 401, 402; 401, 403; 402, identifier:np; 403, identifier:dot; 404, argument_list; 404, 405; 404, 406; 405, identifier:x_death_sum; 406, identifier:beta; 407, binary_operator:*; 407, 408; 407, 409; 408, identifier:weighted_average; 409, call; 409, 410; 409, 418; 410, attribute; 410, 411; 410, 417; 411, call; 411, 412; 411, 415; 412, attribute; 412, 413; 412, 414; 413, identifier:np; 414, identifier:log; 415, argument_list; 415, 416; 416, identifier:denom; 417, identifier:sum; 418, argument_list; 419, expression_statement; 419, 420; 420, assignment; 420, 421; 420, 422; 421, identifier:hessian; 422, binary_operator:+; 422, 423; 422, 424; 423, identifier:hessian; 424, binary_operator:*; 424, 425; 424, 426; 425, identifier:weighted_average; 426, parenthesized_expression; 426, 427; 427, binary_operator:-; 427, 428; 427, 429; 428, identifier:a2; 429, identifier:a1; 430, expression_statement; 430, 431; 431, assignment; 431, 432; 431, 433; 432, identifier:tied_death_counts; 433, integer:0; 434, expression_statement; 434, 435; 435, assignment; 435, 436; 435, 437; 436, identifier:weight_count; 437, float:0.0; 438, expression_statement; 438, 439; 439, assignment; 439, 440; 439, 441; 440, identifier:x_death_sum; 441, call; 441, 442; 441, 445; 442, attribute; 442, 443; 442, 444; 443, identifier:np; 444, identifier:zeros; 445, argument_list; 445, 446; 446, tuple; 446, 447; 447, identifier:d; 448, expression_statement; 448, 449; 449, assignment; 449, 450; 449, 451; 450, identifier:tie_phi; 451, integer:0; 452, expression_statement; 452, 453; 453, assignment; 453, 454; 453, 455; 454, identifier:tie_phi_x; 455, call; 455, 456; 455, 459; 456, attribute; 456, 457; 456, 458; 457, identifier:np; 458, identifier:zeros; 459, argument_list; 459, 460; 460, tuple; 460, 461; 461, identifier:d; 462, expression_statement; 462, 463; 463, assignment; 463, 464; 463, 465; 464, identifier:tie_phi_x_x; 465, call; 465, 466; 465, 469; 466, attribute; 466, 467; 466, 468; 467, identifier:np; 468, identifier:zeros; 469, argument_list; 469, 470; 470, tuple; 470, 471; 470, 472; 471, identifier:d; 472, identifier:d; 473, return_statement; 473, 474; 474, expression_list; 474, 475; 474, 476; 474, 477; 475, identifier:hessian; 476, identifier:gradient; 477, identifier:log_lik | def _get_efron_values_single(self, X, T, E, weights, beta):
n, d = X.shape
hessian = np.zeros((d, d))
gradient = np.zeros((d,))
log_lik = 0
x_death_sum = np.zeros((d,))
risk_phi, tie_phi = 0, 0
risk_phi_x, tie_phi_x = np.zeros((d,)), np.zeros((d,))
risk_phi_x_x, tie_phi_x_x = np.zeros((d, d)), np.zeros((d, d))
weight_count = 0.0
tied_death_counts = 0
scores = weights * np.exp(np.dot(X, beta))
for i in range(n - 1, -1, -1):
ti = T[i]
ei = E[i]
xi = X[i]
score = scores[i]
w = weights[i]
phi_i = score
phi_x_i = phi_i * xi
phi_x_x_i = np.outer(xi, phi_x_i)
risk_phi = risk_phi + phi_i
risk_phi_x = risk_phi_x + phi_x_i
risk_phi_x_x = risk_phi_x_x + phi_x_x_i
if ei:
x_death_sum = x_death_sum + w * xi
tie_phi = tie_phi + phi_i
tie_phi_x = tie_phi_x + phi_x_i
tie_phi_x_x = tie_phi_x_x + phi_x_x_i
tied_death_counts += 1
weight_count += w
if i > 0 and T[i - 1] == ti:
continue
elif tied_death_counts == 0:
continue
weighted_average = weight_count / tied_death_counts
if tied_death_counts > 1:
increasing_proportion = np.arange(tied_death_counts) / tied_death_counts
denom = 1.0 / (risk_phi - increasing_proportion * tie_phi)
numer = risk_phi_x - np.outer(increasing_proportion, tie_phi_x)
a1 = np.einsum("ab,i->ab", risk_phi_x_x, denom) - np.einsum(
"ab,i->ab", tie_phi_x_x, increasing_proportion * denom
)
else:
denom = 1.0 / np.array([risk_phi])
numer = risk_phi_x
a1 = risk_phi_x_x * denom
summand = numer * denom[:, None]
a2 = summand.T.dot(summand)
gradient = gradient + x_death_sum - weighted_average * summand.sum(0)
log_lik = log_lik + np.dot(x_death_sum, beta) + weighted_average * np.log(denom).sum()
hessian = hessian + weighted_average * (a2 - a1)
tied_death_counts = 0
weight_count = 0.0
x_death_sum = np.zeros((d,))
tie_phi = 0
tie_phi_x = np.zeros((d,))
tie_phi_x_x = np.zeros((d, d))
return hessian, gradient, log_lik |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:_get_efron_values_batch; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:self; 5, identifier:X; 6, identifier:T; 7, identifier:E; 8, identifier:weights; 9, identifier:beta; 10, block; 10, 11; 10, 19; 10, 30; 10, 40; 10, 44; 10, 52; 10, 72; 10, 94; 10, 109; 10, 126; 10, 130; 10, 466; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 16; 13, pattern_list; 13, 14; 13, 15; 14, identifier:n; 15, identifier:d; 16, attribute; 16, 17; 16, 18; 17, identifier:X; 18, identifier:shape; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:hessian; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:np; 25, identifier:zeros; 26, argument_list; 26, 27; 27, tuple; 27, 28; 27, 29; 28, identifier:d; 29, identifier:d; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:gradient; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:np; 36, identifier:zeros; 37, argument_list; 37, 38; 38, tuple; 38, 39; 39, identifier:d; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:log_lik; 43, integer:0; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 49; 46, pattern_list; 46, 47; 46, 48; 47, identifier:risk_phi; 48, identifier:tie_phi; 49, expression_list; 49, 50; 49, 51; 50, integer:0; 51, integer:0; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 57; 54, pattern_list; 54, 55; 54, 56; 55, identifier:risk_phi_x; 56, identifier:tie_phi_x; 57, expression_list; 57, 58; 57, 65; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:np; 61, identifier:zeros; 62, argument_list; 62, 63; 63, tuple; 63, 64; 64, identifier:d; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:np; 68, identifier:zeros; 69, argument_list; 69, 70; 70, tuple; 70, 71; 71, identifier:d; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 77; 74, pattern_list; 74, 75; 74, 76; 75, identifier:risk_phi_x_x; 76, identifier:tie_phi_x_x; 77, expression_list; 77, 78; 77, 86; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:np; 81, identifier:zeros; 82, argument_list; 82, 83; 83, tuple; 83, 84; 83, 85; 84, identifier:d; 85, identifier:d; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:np; 89, identifier:zeros; 90, argument_list; 90, 91; 91, tuple; 91, 92; 91, 93; 92, identifier:d; 93, identifier:d; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 99; 96, pattern_list; 96, 97; 96, 98; 97, identifier:_; 98, identifier:counts; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:np; 102, identifier:unique; 103, argument_list; 103, 104; 103, 106; 104, unary_operator:-; 104, 105; 105, identifier:T; 106, keyword_argument; 106, 107; 106, 108; 107, identifier:return_counts; 108, True; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:scores; 112, binary_operator:*; 112, 113; 112, 114; 113, identifier:weights; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:np; 117, identifier:exp; 118, argument_list; 118, 119; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:np; 122, identifier:dot; 123, argument_list; 123, 124; 123, 125; 124, identifier:X; 125, identifier:beta; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:pos; 129, identifier:n; 130, for_statement; 130, 131; 130, 132; 130, 133; 131, identifier:count_of_removals; 132, identifier:counts; 133, block; 133, 134; 133, 144; 133, 150; 133, 156; 133, 163; 133, 169; 133, 181; 133, 190; 133, 199; 133, 205; 133, 211; 133, 223; 133, 233; 133, 239; 133, 245; 133, 258; 133, 265; 133, 271; 133, 390; 133, 400; 133, 411; 133, 426; 133, 451; 133, 462; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:slice_; 137, call; 137, 138; 137, 139; 138, identifier:slice; 139, argument_list; 139, 140; 139, 143; 140, binary_operator:-; 140, 141; 140, 142; 141, identifier:pos; 142, identifier:count_of_removals; 143, identifier:pos; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:X_at_t; 147, subscript; 147, 148; 147, 149; 148, identifier:X; 149, identifier:slice_; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:weights_at_t; 153, subscript; 153, 154; 153, 155; 154, identifier:weights; 155, identifier:slice_; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:phi_i; 159, subscript; 159, 160; 159, 161; 159, 162; 160, identifier:scores; 161, identifier:slice_; 162, None; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:phi_x_i; 166, binary_operator:*; 166, 167; 166, 168; 167, identifier:phi_i; 168, identifier:X_at_t; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:phi_x_x_i; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:np; 175, identifier:dot; 176, argument_list; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:X_at_t; 179, identifier:T; 180, identifier:phi_x_i; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:risk_phi; 184, binary_operator:+; 184, 185; 184, 186; 185, identifier:risk_phi; 186, call; 186, 187; 186, 188; 187, identifier:array_sum_to_scalar; 188, argument_list; 188, 189; 189, identifier:phi_i; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:risk_phi_x; 193, binary_operator:+; 193, 194; 193, 195; 194, identifier:risk_phi_x; 195, call; 195, 196; 195, 197; 196, identifier:matrix_axis_0_sum_to_array; 197, argument_list; 197, 198; 198, identifier:phi_x_i; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:risk_phi_x_x; 202, binary_operator:+; 202, 203; 202, 204; 203, identifier:risk_phi_x_x; 204, identifier:phi_x_x_i; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:deaths; 208, subscript; 208, 209; 208, 210; 209, identifier:E; 210, identifier:slice_; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:tied_death_counts; 214, call; 214, 215; 214, 216; 215, identifier:array_sum_to_scalar; 216, argument_list; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:deaths; 220, identifier:astype; 221, argument_list; 221, 222; 222, identifier:int; 223, if_statement; 223, 224; 223, 227; 224, comparison_operator:==; 224, 225; 224, 226; 225, identifier:tied_death_counts; 226, integer:0; 227, block; 227, 228; 227, 232; 228, expression_statement; 228, 229; 229, augmented_assignment:-=; 229, 230; 229, 231; 230, identifier:pos; 231, identifier:count_of_removals; 232, continue_statement; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:xi_deaths; 236, subscript; 236, 237; 236, 238; 237, identifier:X_at_t; 238, identifier:deaths; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:weights_deaths; 242, subscript; 242, 243; 242, 244; 243, identifier:weights_at_t; 244, identifier:deaths; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:x_death_sum; 248, call; 248, 249; 248, 250; 249, identifier:matrix_axis_0_sum_to_array; 250, argument_list; 250, 251; 251, binary_operator:*; 251, 252; 251, 257; 252, subscript; 252, 253; 252, 254; 252, 256; 253, identifier:weights_deaths; 254, slice; 254, 255; 255, colon; 256, None; 257, identifier:xi_deaths; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:weight_count; 261, call; 261, 262; 261, 263; 262, identifier:array_sum_to_scalar; 263, argument_list; 263, 264; 264, identifier:weights_deaths; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:weighted_average; 268, binary_operator:/; 268, 269; 268, 270; 269, identifier:weight_count; 270, identifier:tied_death_counts; 271, if_statement; 271, 272; 271, 275; 271, 366; 272, comparison_operator:>; 272, 273; 272, 274; 273, identifier:tied_death_counts; 274, integer:1; 275, block; 275, 276; 275, 285; 275, 294; 275, 310; 275, 321; 275, 332; 275, 344; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:tie_phi; 279, call; 279, 280; 279, 281; 280, identifier:array_sum_to_scalar; 281, argument_list; 281, 282; 282, subscript; 282, 283; 282, 284; 283, identifier:phi_i; 284, identifier:deaths; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:tie_phi_x; 288, call; 288, 289; 288, 290; 289, identifier:matrix_axis_0_sum_to_array; 290, argument_list; 290, 291; 291, subscript; 291, 292; 291, 293; 292, identifier:phi_x_i; 293, identifier:deaths; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:tie_phi_x_x; 297, call; 297, 298; 297, 301; 298, attribute; 298, 299; 298, 300; 299, identifier:np; 300, identifier:dot; 301, argument_list; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:xi_deaths; 304, identifier:T; 305, binary_operator:*; 305, 306; 305, 309; 306, subscript; 306, 307; 306, 308; 307, identifier:phi_i; 308, identifier:deaths; 309, identifier:xi_deaths; 310, expression_statement; 310, 311; 311, assignment; 311, 312; 311, 313; 312, identifier:increasing_proportion; 313, binary_operator:/; 313, 314; 313, 320; 314, call; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, identifier:np; 317, identifier:arange; 318, argument_list; 318, 319; 319, identifier:tied_death_counts; 320, identifier:tied_death_counts; 321, expression_statement; 321, 322; 322, assignment; 322, 323; 322, 324; 323, identifier:denom; 324, binary_operator:/; 324, 325; 324, 326; 325, float:1.0; 326, parenthesized_expression; 326, 327; 327, binary_operator:-; 327, 328; 327, 329; 328, identifier:risk_phi; 329, binary_operator:*; 329, 330; 329, 331; 330, identifier:increasing_proportion; 331, identifier:tie_phi; 332, expression_statement; 332, 333; 333, assignment; 333, 334; 333, 335; 334, identifier:numer; 335, binary_operator:-; 335, 336; 335, 337; 336, identifier:risk_phi_x; 337, call; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:np; 340, identifier:outer; 341, argument_list; 341, 342; 341, 343; 342, identifier:increasing_proportion; 343, identifier:tie_phi_x; 344, expression_statement; 344, 345; 345, assignment; 345, 346; 345, 347; 346, identifier:a1; 347, binary_operator:-; 347, 348; 347, 356; 348, call; 348, 349; 348, 352; 349, attribute; 349, 350; 349, 351; 350, identifier:np; 351, identifier:einsum; 352, argument_list; 352, 353; 352, 354; 352, 355; 353, string:"ab,i->ab"; 354, identifier:risk_phi_x_x; 355, identifier:denom; 356, call; 356, 357; 356, 360; 357, attribute; 357, 358; 357, 359; 358, identifier:np; 359, identifier:einsum; 360, argument_list; 360, 361; 360, 362; 360, 363; 361, string:"ab,i->ab"; 362, identifier:tie_phi_x_x; 363, binary_operator:*; 363, 364; 363, 365; 364, identifier:increasing_proportion; 365, identifier:denom; 366, else_clause; 366, 367; 367, block; 367, 368; 367, 380; 367, 384; 368, expression_statement; 368, 369; 369, assignment; 369, 370; 369, 371; 370, identifier:denom; 371, binary_operator:/; 371, 372; 371, 373; 372, float:1.0; 373, call; 373, 374; 373, 377; 374, attribute; 374, 375; 374, 376; 375, identifier:np; 376, identifier:array; 377, argument_list; 377, 378; 378, list:[risk_phi]; 378, 379; 379, identifier:risk_phi; 380, expression_statement; 380, 381; 381, assignment; 381, 382; 381, 383; 382, identifier:numer; 383, identifier:risk_phi_x; 384, expression_statement; 384, 385; 385, assignment; 385, 386; 385, 387; 386, identifier:a1; 387, binary_operator:*; 387, 388; 387, 389; 388, identifier:risk_phi_x_x; 389, identifier:denom; 390, expression_statement; 390, 391; 391, assignment; 391, 392; 391, 393; 392, identifier:summand; 393, binary_operator:*; 393, 394; 393, 395; 394, identifier:numer; 395, subscript; 395, 396; 395, 397; 395, 399; 396, identifier:denom; 397, slice; 397, 398; 398, colon; 399, None; 400, expression_statement; 400, 401; 401, assignment; 401, 402; 401, 403; 402, identifier:a2; 403, call; 403, 404; 403, 409; 404, attribute; 404, 405; 404, 408; 405, attribute; 405, 406; 405, 407; 406, identifier:summand; 407, identifier:T; 408, identifier:dot; 409, argument_list; 409, 410; 410, identifier:summand; 411, expression_statement; 411, 412; 412, assignment; 412, 413; 412, 414; 413, identifier:gradient; 414, binary_operator:-; 414, 415; 414, 418; 415, binary_operator:+; 415, 416; 415, 417; 416, identifier:gradient; 417, identifier:x_death_sum; 418, binary_operator:*; 418, 419; 418, 420; 419, identifier:weighted_average; 420, call; 420, 421; 420, 424; 421, attribute; 421, 422; 421, 423; 422, identifier:summand; 423, identifier:sum; 424, argument_list; 424, 425; 425, integer:0; 426, expression_statement; 426, 427; 427, assignment; 427, 428; 427, 429; 428, identifier:log_lik; 429, binary_operator:+; 429, 430; 429, 439; 430, binary_operator:+; 430, 431; 430, 432; 431, identifier:log_lik; 432, call; 432, 433; 432, 436; 433, attribute; 433, 434; 433, 435; 434, identifier:np; 435, identifier:dot; 436, argument_list; 436, 437; 436, 438; 437, identifier:x_death_sum; 438, identifier:beta; 439, binary_operator:*; 439, 440; 439, 441; 440, identifier:weighted_average; 441, call; 441, 442; 441, 450; 442, attribute; 442, 443; 442, 449; 443, call; 443, 444; 443, 447; 444, attribute; 444, 445; 444, 446; 445, identifier:np; 446, identifier:log; 447, argument_list; 447, 448; 448, identifier:denom; 449, identifier:sum; 450, argument_list; 451, expression_statement; 451, 452; 452, assignment; 452, 453; 452, 454; 453, identifier:hessian; 454, binary_operator:+; 454, 455; 454, 456; 455, identifier:hessian; 456, binary_operator:*; 456, 457; 456, 458; 457, identifier:weighted_average; 458, parenthesized_expression; 458, 459; 459, binary_operator:-; 459, 460; 459, 461; 460, identifier:a2; 461, identifier:a1; 462, expression_statement; 462, 463; 463, augmented_assignment:-=; 463, 464; 463, 465; 464, identifier:pos; 465, identifier:count_of_removals; 466, return_statement; 466, 467; 467, expression_list; 467, 468; 467, 469; 467, 470; 468, identifier:hessian; 469, identifier:gradient; 470, identifier:log_lik | def _get_efron_values_batch(self, X, T, E, weights, beta):
n, d = X.shape
hessian = np.zeros((d, d))
gradient = np.zeros((d,))
log_lik = 0
risk_phi, tie_phi = 0, 0
risk_phi_x, tie_phi_x = np.zeros((d,)), np.zeros((d,))
risk_phi_x_x, tie_phi_x_x = np.zeros((d, d)), np.zeros((d, d))
_, counts = np.unique(-T, return_counts=True)
scores = weights * np.exp(np.dot(X, beta))
pos = n
for count_of_removals in counts:
slice_ = slice(pos - count_of_removals, pos)
X_at_t = X[slice_]
weights_at_t = weights[slice_]
phi_i = scores[slice_, None]
phi_x_i = phi_i * X_at_t
phi_x_x_i = np.dot(X_at_t.T, phi_x_i)
risk_phi = risk_phi + array_sum_to_scalar(phi_i)
risk_phi_x = risk_phi_x + matrix_axis_0_sum_to_array(phi_x_i)
risk_phi_x_x = risk_phi_x_x + phi_x_x_i
deaths = E[slice_]
tied_death_counts = array_sum_to_scalar(deaths.astype(int))
if tied_death_counts == 0:
pos -= count_of_removals
continue
xi_deaths = X_at_t[deaths]
weights_deaths = weights_at_t[deaths]
x_death_sum = matrix_axis_0_sum_to_array(weights_deaths[:, None] * xi_deaths)
weight_count = array_sum_to_scalar(weights_deaths)
weighted_average = weight_count / tied_death_counts
if tied_death_counts > 1:
tie_phi = array_sum_to_scalar(phi_i[deaths])
tie_phi_x = matrix_axis_0_sum_to_array(phi_x_i[deaths])
tie_phi_x_x = np.dot(xi_deaths.T, phi_i[deaths] * xi_deaths)
increasing_proportion = np.arange(tied_death_counts) / tied_death_counts
denom = 1.0 / (risk_phi - increasing_proportion * tie_phi)
numer = risk_phi_x - np.outer(increasing_proportion, tie_phi_x)
a1 = np.einsum("ab,i->ab", risk_phi_x_x, denom) - np.einsum(
"ab,i->ab", tie_phi_x_x, increasing_proportion * denom
)
else:
denom = 1.0 / np.array([risk_phi])
numer = risk_phi_x
a1 = risk_phi_x_x * denom
summand = numer * denom[:, None]
a2 = summand.T.dot(summand)
gradient = gradient + x_death_sum - weighted_average * summand.sum(0)
log_lik = log_lik + np.dot(x_death_sum, beta) + weighted_average * np.log(denom).sum()
hessian = hessian + weighted_average * (a2 - a1)
pos -= count_of_removals
return hessian, gradient, log_lik |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_treeify; 3, parameters; 3, 4; 4, identifier:values; 5, block; 5, 6; 5, 16; 5, 25; 5, 44; 5, 61; 5, 101; 5, 105; 5, 109; 5, 115; 5, 166; 6, if_statement; 6, 7; 6, 13; 7, comparison_operator:==; 7, 8; 7, 12; 8, call; 8, 9; 8, 10; 9, identifier:len; 10, argument_list; 10, 11; 11, identifier:values; 12, integer:1; 13, block; 13, 14; 14, return_statement; 14, 15; 15, identifier:values; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:tree; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:np; 22, identifier:empty_like; 23, argument_list; 23, 24; 24, identifier:values; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:last_full_row; 28, call; 28, 29; 28, 30; 29, identifier:int; 30, argument_list; 30, 31; 31, binary_operator:-; 31, 32; 31, 43; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:np; 35, identifier:log2; 36, argument_list; 36, 37; 37, binary_operator:+; 37, 38; 37, 42; 38, call; 38, 39; 38, 40; 39, identifier:len; 40, argument_list; 40, 41; 41, identifier:values; 42, integer:1; 43, integer:1; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:len_ragged_row; 47, binary_operator:-; 47, 48; 47, 52; 48, call; 48, 49; 48, 50; 49, identifier:len; 50, argument_list; 50, 51; 51, identifier:values; 52, parenthesized_expression; 52, 53; 53, binary_operator:-; 53, 54; 53, 60; 54, binary_operator:**; 54, 55; 54, 56; 55, integer:2; 56, parenthesized_expression; 56, 57; 57, binary_operator:+; 57, 58; 57, 59; 58, identifier:last_full_row; 59, integer:1; 60, integer:1; 61, if_statement; 61, 62; 61, 65; 62, comparison_operator:>; 62, 63; 62, 64; 63, identifier:len_ragged_row; 64, integer:0; 65, block; 65, 66; 65, 80; 65, 91; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:bottom_row_ix; 69, subscript; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:np; 72, identifier:s_; 73, slice; 73, 74; 73, 75; 73, 78; 73, 79; 74, colon; 75, binary_operator:*; 75, 76; 75, 77; 76, integer:2; 77, identifier:len_ragged_row; 78, colon; 79, integer:2; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 88; 82, subscript; 82, 83; 82, 84; 83, identifier:tree; 84, slice; 84, 85; 84, 87; 85, unary_operator:-; 85, 86; 86, identifier:len_ragged_row; 87, colon; 88, subscript; 88, 89; 88, 90; 89, identifier:values; 90, identifier:bottom_row_ix; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:values; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:np; 97, identifier:delete; 98, argument_list; 98, 99; 98, 100; 99, identifier:values; 100, identifier:bottom_row_ix; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:values_start; 104, integer:0; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:values_space; 108, integer:2; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:values_len; 112, binary_operator:**; 112, 113; 112, 114; 113, integer:2; 114, identifier:last_full_row; 115, while_statement; 115, 116; 115, 122; 116, comparison_operator:<; 116, 117; 116, 118; 117, identifier:values_start; 118, call; 118, 119; 118, 120; 119, identifier:len; 120, argument_list; 120, 121; 121, identifier:values; 122, block; 122, 123; 122, 144; 122, 153; 122, 157; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 137; 125, subscript; 125, 126; 125, 127; 126, identifier:tree; 127, slice; 127, 128; 127, 131; 127, 132; 128, binary_operator:-; 128, 129; 128, 130; 129, identifier:values_len; 130, integer:1; 131, colon; 132, binary_operator:-; 132, 133; 132, 136; 133, binary_operator:*; 133, 134; 133, 135; 134, integer:2; 135, identifier:values_len; 136, integer:1; 137, subscript; 137, 138; 137, 139; 138, identifier:values; 139, slice; 139, 140; 139, 141; 139, 142; 139, 143; 140, identifier:values_start; 141, colon; 142, colon; 143, identifier:values_space; 144, expression_statement; 144, 145; 145, augmented_assignment:+=; 145, 146; 145, 147; 146, identifier:values_start; 147, call; 147, 148; 147, 149; 148, identifier:int; 149, argument_list; 149, 150; 150, binary_operator:/; 150, 151; 150, 152; 151, identifier:values_space; 152, integer:2; 153, expression_statement; 153, 154; 154, augmented_assignment:*=; 154, 155; 154, 156; 155, identifier:values_space; 156, integer:2; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:values_len; 160, call; 160, 161; 160, 162; 161, identifier:int; 162, argument_list; 162, 163; 163, binary_operator:/; 163, 164; 163, 165; 164, identifier:values_len; 165, integer:2; 166, return_statement; 166, 167; 167, identifier:tree | def _treeify(values):
if len(values) == 1:
return values
tree = np.empty_like(values)
last_full_row = int(np.log2(len(values) + 1) - 1)
len_ragged_row = len(values) - (2 ** (last_full_row + 1) - 1)
if len_ragged_row > 0:
bottom_row_ix = np.s_[: 2 * len_ragged_row : 2]
tree[-len_ragged_row:] = values[bottom_row_ix]
values = np.delete(values, bottom_row_ix)
values_start = 0
values_space = 2
values_len = 2 ** last_full_row
while values_start < len(values):
tree[values_len - 1 : 2 * values_len - 1] = values[values_start::values_space]
values_start += int(values_space / 2)
values_space *= 2
values_len = int(values_len / 2)
return tree |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:nearest_neighbors; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:word; 6, default_parameter; 6, 7; 6, 8; 7, identifier:top_k; 8, integer:10; 9, block; 9, 10; 9, 16; 9, 24; 9, 38; 9, 53; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:point; 13, subscript; 13, 14; 13, 15; 14, identifier:self; 15, identifier:word; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:diff; 19, binary_operator:-; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:vectors; 23, identifier:point; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:distances; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:np; 31, identifier:linalg; 32, identifier:norm; 33, argument_list; 33, 34; 33, 35; 34, identifier:diff; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:axis; 37, integer:1; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:top_ids; 41, subscript; 41, 42; 41, 47; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:distances; 45, identifier:argsort; 46, argument_list; 47, slice; 47, 48; 47, 49; 47, 50; 48, integer:1; 49, colon; 50, binary_operator:+; 50, 51; 50, 52; 51, identifier:top_k; 52, integer:1; 53, return_statement; 53, 54; 54, list_comprehension; 54, 55; 54, 62; 55, subscript; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:vocabulary; 60, identifier:id_word; 61, identifier:i; 62, for_in_clause; 62, 63; 62, 64; 63, identifier:i; 64, identifier:top_ids | def nearest_neighbors(self, word, top_k=10):
point = self[word]
diff = self.vectors - point
distances = np.linalg.norm(diff, axis=1)
top_ids = distances.argsort()[1:top_k+1]
return [self.vocabulary.id_word[i] for i in top_ids] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:find_range; 3, parameters; 3, 4; 3, 5; 4, identifier:values; 5, default_parameter; 5, 6; 5, 7; 6, identifier:soft_range; 7, list:[]; 8, block; 8, 9; 9, try_statement; 9, 10; 9, 91; 10, block; 10, 11; 10, 20; 10, 39; 10, 56; 10, 77; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:values; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:np; 17, identifier:array; 18, argument_list; 18, 19; 19, identifier:values; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:values; 23, conditional_expression:if; 23, 24; 23, 30; 23, 38; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:np; 27, identifier:squeeze; 28, argument_list; 28, 29; 29, identifier:values; 30, comparison_operator:>; 30, 31; 30, 37; 31, call; 31, 32; 31, 33; 32, identifier:len; 33, argument_list; 33, 34; 34, attribute; 34, 35; 34, 36; 35, identifier:values; 36, identifier:shape; 37, integer:1; 38, identifier:values; 39, if_statement; 39, 40; 39, 44; 40, call; 40, 41; 40, 42; 41, identifier:len; 42, argument_list; 42, 43; 43, identifier:soft_range; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:values; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:np; 51, identifier:concatenate; 52, argument_list; 52, 53; 53, list:[values, soft_range]; 53, 54; 53, 55; 54, identifier:values; 55, identifier:soft_range; 56, if_statement; 56, 57; 56, 64; 57, comparison_operator:==; 57, 58; 57, 63; 58, attribute; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:values; 61, identifier:dtype; 62, identifier:kind; 63, string:'M'; 64, block; 64, 65; 65, return_statement; 65, 66; 66, expression_list; 66, 67; 66, 72; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:values; 70, identifier:min; 71, argument_list; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:values; 75, identifier:max; 76, argument_list; 77, return_statement; 77, 78; 78, expression_list; 78, 79; 78, 85; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:np; 82, identifier:nanmin; 83, argument_list; 83, 84; 84, identifier:values; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:np; 88, identifier:nanmax; 89, argument_list; 89, 90; 90, identifier:values; 91, except_clause; 91, 92; 92, block; 92, 93; 93, try_statement; 93, 94; 93, 111; 94, block; 94, 95; 94, 102; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:values; 98, call; 98, 99; 98, 100; 99, identifier:sorted; 100, argument_list; 100, 101; 101, identifier:values; 102, return_statement; 102, 103; 103, tuple; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:values; 106, integer:0; 107, subscript; 107, 108; 107, 109; 108, identifier:values; 109, unary_operator:-; 109, 110; 110, integer:1; 111, except_clause; 111, 112; 112, block; 112, 113; 113, return_statement; 113, 114; 114, tuple; 114, 115; 114, 116; 115, None; 116, None | def find_range(values, soft_range=[]):
try:
values = np.array(values)
values = np.squeeze(values) if len(values.shape) > 1 else values
if len(soft_range):
values = np.concatenate([values, soft_range])
if values.dtype.kind == 'M':
return values.min(), values.max()
return np.nanmin(values), np.nanmax(values)
except:
try:
values = sorted(values)
return (values[0], values[-1])
except:
return (None, None) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:dimension_sort; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:odict; 5, identifier:kdims; 6, identifier:vdims; 7, identifier:key_index; 8, block; 8, 9; 8, 13; 8, 20; 8, 26; 8, 57; 8, 77; 8, 143; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:sortkws; 12, dictionary; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:ndims; 16, call; 16, 17; 16, 18; 17, identifier:len; 18, argument_list; 18, 19; 19, identifier:kdims; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:dimensions; 23, binary_operator:+; 23, 24; 23, 25; 24, identifier:kdims; 25, identifier:vdims; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:indexes; 29, list_comprehension; 29, 30; 29, 54; 30, tuple; 30, 31; 30, 34; 30, 43; 31, subscript; 31, 32; 31, 33; 32, identifier:dimensions; 33, identifier:i; 34, call; 34, 35; 34, 36; 35, identifier:int; 36, argument_list; 36, 37; 37, comparison_operator:not; 37, 38; 37, 39; 38, identifier:i; 39, call; 39, 40; 39, 41; 40, identifier:range; 41, argument_list; 41, 42; 42, identifier:ndims; 43, conditional_expression:if; 43, 44; 43, 45; 43, 51; 44, identifier:i; 45, comparison_operator:in; 45, 46; 45, 47; 46, identifier:i; 47, call; 47, 48; 47, 49; 48, identifier:range; 49, argument_list; 49, 50; 50, identifier:ndims; 51, binary_operator:-; 51, 52; 51, 53; 52, identifier:i; 53, identifier:ndims; 54, for_in_clause; 54, 55; 54, 56; 55, identifier:i; 56, identifier:key_index; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:cached_values; 60, dictionary_comprehension; 60, 61; 60, 74; 61, pair; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:d; 64, identifier:name; 65, binary_operator:+; 65, 66; 65, 68; 66, list:[None]; 66, 67; 67, None; 68, call; 68, 69; 68, 70; 69, identifier:list; 70, argument_list; 70, 71; 71, attribute; 71, 72; 71, 73; 72, identifier:d; 73, identifier:values; 74, for_in_clause; 74, 75; 74, 76; 75, identifier:d; 76, identifier:dimensions; 77, if_statement; 77, 78; 77, 90; 77, 96; 78, comparison_operator:!=; 78, 79; 78, 86; 79, call; 79, 80; 79, 81; 80, identifier:len; 81, argument_list; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:set; 84, argument_list; 84, 85; 85, identifier:key_index; 86, call; 86, 87; 86, 88; 87, identifier:len; 88, argument_list; 88, 89; 89, identifier:key_index; 90, block; 90, 91; 91, raise_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:ValueError; 94, argument_list; 94, 95; 95, string:"Cannot sort on duplicated dimensions"; 96, else_clause; 96, 97; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:sortkws; 102, string:'key'; 103, lambda; 103, 104; 103, 106; 104, lambda_parameters; 104, 105; 105, identifier:x; 106, call; 106, 107; 106, 108; 107, identifier:tuple; 108, generator_expression; 108, 109; 108, 132; 109, conditional_expression:if; 109, 110; 109, 124; 109, 127; 110, call; 110, 111; 110, 118; 111, attribute; 111, 112; 111, 117; 112, subscript; 112, 113; 112, 114; 113, identifier:cached_values; 114, attribute; 114, 115; 114, 116; 115, identifier:dim; 116, identifier:name; 117, identifier:index; 118, argument_list; 118, 119; 119, subscript; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:x; 122, identifier:t; 123, identifier:d; 124, attribute; 124, 125; 124, 126; 125, identifier:dim; 126, identifier:values; 127, subscript; 127, 128; 127, 131; 128, subscript; 128, 129; 128, 130; 129, identifier:x; 130, identifier:t; 131, identifier:d; 132, for_in_clause; 132, 133; 132, 139; 133, pattern_list; 133, 134; 133, 135; 134, identifier:i; 135, tuple_pattern; 135, 136; 135, 137; 135, 138; 136, identifier:dim; 137, identifier:t; 138, identifier:d; 139, call; 139, 140; 139, 141; 140, identifier:enumerate; 141, argument_list; 141, 142; 142, identifier:indexes; 143, if_statement; 143, 144; 143, 151; 143, 163; 144, comparison_operator:==; 144, 145; 144, 150; 145, attribute; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:sys; 148, identifier:version_info; 149, identifier:major; 150, integer:3; 151, block; 151, 152; 152, return_statement; 152, 153; 153, call; 153, 154; 153, 155; 154, identifier:python2sort; 155, argument_list; 155, 156; 155, 161; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:odict; 159, identifier:items; 160, argument_list; 161, dictionary_splat; 161, 162; 162, identifier:sortkws; 163, else_clause; 163, 164; 164, block; 164, 165; 165, return_statement; 165, 166; 166, call; 166, 167; 166, 168; 167, identifier:sorted; 168, argument_list; 168, 169; 168, 174; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:odict; 172, identifier:items; 173, argument_list; 174, dictionary_splat; 174, 175; 175, identifier:sortkws | def dimension_sort(odict, kdims, vdims, key_index):
sortkws = {}
ndims = len(kdims)
dimensions = kdims+vdims
indexes = [(dimensions[i], int(i not in range(ndims)),
i if i in range(ndims) else i-ndims)
for i in key_index]
cached_values = {d.name: [None]+list(d.values) for d in dimensions}
if len(set(key_index)) != len(key_index):
raise ValueError("Cannot sort on duplicated dimensions")
else:
sortkws['key'] = lambda x: tuple(cached_values[dim.name].index(x[t][d])
if dim.values else x[t][d]
for i, (dim, t, d) in enumerate(indexes))
if sys.version_info.major == 3:
return python2sort(odict.items(), **sortkws)
else:
return sorted(odict.items(), **sortkws) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_topologically; 3, parameters; 3, 4; 4, identifier:graph; 5, block; 5, 6; 5, 10; 5, 17; 5, 38; 5, 143; 5, 152; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:levels_by_name; 9, dictionary; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:names_by_level; 13, call; 13, 14; 13, 15; 14, identifier:defaultdict; 15, argument_list; 15, 16; 16, identifier:list; 17, function_definition; 17, 18; 17, 19; 17, 22; 18, function_name:add_level_to_name; 19, parameters; 19, 20; 19, 21; 20, identifier:name; 21, identifier:level; 22, block; 22, 23; 22, 29; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, subscript; 25, 26; 25, 27; 26, identifier:levels_by_name; 27, identifier:name; 28, identifier:level; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 36; 31, attribute; 31, 32; 31, 35; 32, subscript; 32, 33; 32, 34; 33, identifier:names_by_level; 34, identifier:level; 35, identifier:append; 36, argument_list; 36, 37; 37, identifier:name; 38, function_definition; 38, 39; 38, 40; 38, 42; 39, function_name:walk_depth_first; 40, parameters; 40, 41; 41, identifier:name; 42, block; 42, 43; 42, 48; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:stack; 46, list:[name]; 46, 47; 47, identifier:name; 48, while_statement; 48, 49; 48, 51; 49, parenthesized_expression; 49, 50; 50, identifier:stack; 51, block; 51, 52; 51, 60; 51, 66; 51, 87; 51, 93; 51, 105; 51, 123; 51, 137; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:name; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:stack; 58, identifier:pop; 59, argument_list; 60, if_statement; 60, 61; 60, 64; 61, comparison_operator:in; 61, 62; 61, 63; 62, identifier:name; 63, identifier:levels_by_name; 64, block; 64, 65; 65, continue_statement; 66, if_statement; 66, 67; 66, 75; 67, boolean_operator:or; 67, 68; 67, 71; 68, comparison_operator:not; 68, 69; 68, 70; 69, identifier:name; 70, identifier:graph; 71, not_operator; 71, 72; 72, subscript; 72, 73; 72, 74; 73, identifier:graph; 74, identifier:name; 75, block; 75, 76; 75, 80; 75, 86; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:level; 79, integer:0; 80, expression_statement; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:add_level_to_name; 83, argument_list; 83, 84; 83, 85; 84, identifier:name; 85, identifier:level; 86, continue_statement; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:children; 90, subscript; 90, 91; 90, 92; 91, identifier:graph; 92, identifier:name; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:children_not_calculated; 96, list_comprehension; 96, 97; 96, 98; 96, 101; 97, identifier:child; 98, for_in_clause; 98, 99; 98, 100; 99, identifier:child; 100, identifier:children; 101, if_clause; 101, 102; 102, comparison_operator:not; 102, 103; 102, 104; 103, identifier:child; 104, identifier:levels_by_name; 105, if_statement; 105, 106; 105, 107; 106, identifier:children_not_calculated; 107, block; 107, 108; 107, 115; 107, 122; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:stack; 112, identifier:append; 113, argument_list; 113, 114; 114, identifier:name; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:stack; 119, identifier:extend; 120, argument_list; 120, 121; 121, identifier:children_not_calculated; 122, continue_statement; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:level; 126, binary_operator:+; 126, 127; 126, 128; 127, integer:1; 128, call; 128, 129; 128, 130; 129, identifier:max; 130, generator_expression; 130, 131; 130, 134; 131, subscript; 131, 132; 131, 133; 132, identifier:levels_by_name; 133, identifier:lname; 134, for_in_clause; 134, 135; 134, 136; 135, identifier:lname; 136, identifier:children; 137, expression_statement; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:add_level_to_name; 140, argument_list; 140, 141; 140, 142; 141, identifier:name; 142, identifier:level; 143, for_statement; 143, 144; 143, 145; 143, 146; 144, identifier:name; 145, identifier:graph; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 150; 149, identifier:walk_depth_first; 150, argument_list; 150, 151; 151, identifier:name; 152, return_statement; 152, 153; 153, call; 153, 154; 153, 155; 154, identifier:list; 155, argument_list; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:itertools; 159, identifier:takewhile; 160, argument_list; 160, 161; 160, 167; 161, lambda; 161, 162; 161, 164; 162, lambda_parameters; 162, 163; 163, identifier:x; 164, comparison_operator:is; 164, 165; 164, 166; 165, identifier:x; 166, None; 167, generator_expression; 167, 168; 167, 175; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:names_by_level; 171, identifier:get; 172, argument_list; 172, 173; 172, 174; 173, identifier:i; 174, None; 175, for_in_clause; 175, 176; 175, 177; 176, identifier:i; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:itertools; 180, identifier:count; 181, argument_list | def sort_topologically(graph):
levels_by_name = {}
names_by_level = defaultdict(list)
def add_level_to_name(name, level):
levels_by_name[name] = level
names_by_level[level].append(name)
def walk_depth_first(name):
stack = [name]
while(stack):
name = stack.pop()
if name in levels_by_name:
continue
if name not in graph or not graph[name]:
level = 0
add_level_to_name(name, level)
continue
children = graph[name]
children_not_calculated = [child for child in children if child not in levels_by_name]
if children_not_calculated:
stack.append(name)
stack.extend(children_not_calculated)
continue
level = 1 + max(levels_by_name[lname] for lname in children)
add_level_to_name(name, level)
for name in graph:
walk_depth_first(name)
return list(itertools.takewhile(lambda x: x is not None,
(names_by_level.get(i, None)
for i in itertools.count()))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:layer_sort; 3, parameters; 3, 4; 4, identifier:hmap; 5, block; 5, 6; 5, 10; 5, 89; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:orderings; 9, dictionary; 10, for_statement; 10, 11; 10, 12; 10, 13; 11, identifier:o; 12, identifier:hmap; 13, block; 13, 14; 13, 35; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:okeys; 17, list_comprehension; 17, 18; 17, 24; 18, call; 18, 19; 18, 20; 19, identifier:get_overlay_spec; 20, argument_list; 20, 21; 20, 22; 20, 23; 21, identifier:o; 22, identifier:k; 23, identifier:v; 24, for_in_clause; 24, 25; 24, 28; 25, pattern_list; 25, 26; 25, 27; 26, identifier:k; 27, identifier:v; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:o; 32, identifier:data; 33, identifier:items; 34, argument_list; 35, if_statement; 35, 36; 35, 49; 35, 58; 36, boolean_operator:and; 36, 37; 36, 43; 37, comparison_operator:==; 37, 38; 37, 42; 38, call; 38, 39; 38, 40; 39, identifier:len; 40, argument_list; 40, 41; 41, identifier:okeys; 42, integer:1; 43, not_operator; 43, 44; 44, comparison_operator:in; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:okeys; 47, integer:0; 48, identifier:orderings; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 57; 52, subscript; 52, 53; 52, 54; 53, identifier:orderings; 54, subscript; 54, 55; 54, 56; 55, identifier:okeys; 56, integer:0; 57, list:[]; 58, else_clause; 58, 59; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:orderings; 64, identifier:update; 65, argument_list; 65, 66; 66, dictionary_comprehension; 66, 67; 66, 76; 67, pair; 67, 68; 67, 69; 68, identifier:k; 69, conditional_expression:if; 69, 70; 69, 71; 69, 74; 70, list:[]; 71, comparison_operator:==; 71, 72; 71, 73; 72, identifier:k; 73, identifier:v; 74, list:[v]; 74, 75; 75, identifier:v; 76, for_in_clause; 76, 77; 76, 80; 77, pattern_list; 77, 78; 77, 79; 78, identifier:k; 79, identifier:v; 80, call; 80, 81; 80, 82; 81, identifier:zip; 82, argument_list; 82, 83; 82, 88; 83, subscript; 83, 84; 83, 85; 84, identifier:okeys; 85, slice; 85, 86; 85, 87; 86, integer:1; 87, colon; 88, identifier:okeys; 89, return_statement; 89, 90; 90, list_comprehension; 90, 91; 90, 92; 90, 98; 91, identifier:i; 92, for_in_clause; 92, 93; 92, 94; 93, identifier:g; 94, call; 94, 95; 94, 96; 95, identifier:sort_topologically; 96, argument_list; 96, 97; 97, identifier:orderings; 98, for_in_clause; 98, 99; 98, 100; 99, identifier:i; 100, call; 100, 101; 100, 102; 101, identifier:sorted; 102, argument_list; 102, 103; 103, identifier:g | def layer_sort(hmap):
orderings = {}
for o in hmap:
okeys = [get_overlay_spec(o, k, v) for k, v in o.data.items()]
if len(okeys) == 1 and not okeys[0] in orderings:
orderings[okeys[0]] = []
else:
orderings.update({k: [] if k == v else [v] for k, v in zip(okeys[1:], okeys)})
return [i for g in sort_topologically(orderings) for i in sorted(g)] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:arglexsort; 3, parameters; 3, 4; 4, identifier:arrays; 5, block; 5, 6; 5, 22; 5, 39; 5, 56; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:dtypes; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, string:','; 12, identifier:join; 13, generator_expression; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:array; 17, identifier:dtype; 18, identifier:str; 19, for_in_clause; 19, 20; 19, 21; 20, identifier:array; 21, identifier:arrays; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:recarray; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:np; 28, identifier:empty; 29, argument_list; 29, 30; 29, 36; 30, call; 30, 31; 30, 32; 31, identifier:len; 32, argument_list; 32, 33; 33, subscript; 33, 34; 33, 35; 34, identifier:arrays; 35, integer:0; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:dtype; 38, identifier:dtypes; 39, for_statement; 39, 40; 39, 43; 39, 47; 40, pattern_list; 40, 41; 40, 42; 41, identifier:i; 42, identifier:array; 43, call; 43, 44; 43, 45; 44, identifier:enumerate; 45, argument_list; 45, 46; 46, identifier:arrays; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 55; 50, subscript; 50, 51; 50, 52; 51, identifier:recarray; 52, binary_operator:%; 52, 53; 52, 54; 53, string:'f%s'; 54, identifier:i; 55, identifier:array; 56, return_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:recarray; 60, identifier:argsort; 61, argument_list | def arglexsort(arrays):
dtypes = ','.join(array.dtype.str for array in arrays)
recarray = np.empty(len(arrays[0]), dtype=dtypes)
for i, array in enumerate(arrays):
recarray['f%s' % i] = array
return recarray.argsort() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, block; 11, 12; 11, 36; 11, 49; 12, if_statement; 12, 13; 12, 16; 12, 23; 13, comparison_operator:is; 13, 14; 13, 15; 14, identifier:by; 15, None; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:by; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:kdims; 23, elif_clause; 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:by; 29, identifier:list; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:by; 34, list:[by]; 34, 35; 35, identifier:by; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:sorted_columns; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:interface; 44, identifier:sort; 45, argument_list; 45, 46; 45, 47; 45, 48; 46, identifier:self; 47, identifier:by; 48, identifier:reverse; 49, return_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:clone; 54, argument_list; 54, 55; 55, identifier:sorted_columns | def sort(self, by=None, reverse=False):
if by is None:
by = self.kdims
elif not isinstance(by, list):
by = [by]
sorted_columns = self.interface.sort(self, by, reverse)
return self.clone(sorted_columns) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:glyph_order; 3, parameters; 3, 4; 3, 5; 4, identifier:keys; 5, default_parameter; 5, 6; 5, 7; 6, identifier:draw_order; 7, list:[]; 8, block; 8, 9; 8, 16; 8, 60; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:keys; 12, call; 12, 13; 12, 14; 13, identifier:sorted; 14, argument_list; 14, 15; 15, identifier:keys; 16, function_definition; 16, 17; 16, 18; 16, 20; 17, function_name:order_fn; 18, parameters; 18, 19; 19, identifier:glyph; 20, block; 20, 21; 20, 36; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:matches; 24, list_comprehension; 24, 25; 24, 26; 24, 29; 25, identifier:item; 26, for_in_clause; 26, 27; 26, 28; 27, identifier:item; 28, identifier:draw_order; 29, if_clause; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:glyph; 33, identifier:startswith; 34, argument_list; 34, 35; 35, identifier:item; 36, return_statement; 36, 37; 37, parenthesized_expression; 37, 38; 38, conditional_expression:if; 38, 39; 38, 49; 38, 50; 39, tuple; 39, 40; 39, 48; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:draw_order; 43, identifier:index; 44, argument_list; 44, 45; 45, subscript; 45, 46; 45, 47; 46, identifier:matches; 47, integer:0; 48, identifier:glyph; 49, identifier:matches; 50, tuple; 50, 51; 50, 59; 51, binary_operator:+; 51, 52; 51, 53; 52, float:1e9; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:keys; 56, identifier:index; 57, argument_list; 57, 58; 58, identifier:glyph; 59, identifier:glyph; 60, return_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:sorted; 63, argument_list; 63, 64; 63, 65; 64, identifier:keys; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:key; 67, identifier:order_fn | def glyph_order(keys, draw_order=[]):
keys = sorted(keys)
def order_fn(glyph):
matches = [item for item in draw_order if glyph.startswith(item)]
return ((draw_order.index(matches[0]), glyph) if matches else
(1e9+keys.index(glyph), glyph))
return sorted(keys, key=order_fn) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_coords; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:obj; 6, block; 6, 7; 6, 24; 6, 34; 6, 44; 6, 63; 6, 69; 6, 73; 6, 187; 6, 248; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 12; 9, pattern_list; 9, 10; 9, 11; 10, identifier:xdim; 11, identifier:ydim; 12, subscript; 12, 13; 12, 21; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:obj; 16, identifier:dimensions; 17, argument_list; 17, 18; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:label; 20, True; 21, slice; 21, 22; 21, 23; 22, colon; 23, integer:2; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:xcoords; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:obj; 30, identifier:dimension_values; 31, argument_list; 31, 32; 31, 33; 32, identifier:xdim; 33, False; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:ycoords; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:obj; 40, identifier:dimension_values; 41, argument_list; 41, 42; 41, 43; 42, identifier:ydim; 43, False; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:grouped; 47, call; 47, 48; 47, 62; 48, attribute; 48, 49; 48, 61; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:obj; 52, identifier:groupby; 53, argument_list; 53, 54; 53, 55; 53, 58; 54, identifier:xdim; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:container_type; 57, identifier:OrderedDict; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:group_type; 60, identifier:Dataset; 61, identifier:values; 62, argument_list; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:orderings; 66, call; 66, 67; 66, 68; 67, identifier:OrderedDict; 68, argument_list; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:sort; 72, True; 73, for_statement; 73, 74; 73, 75; 73, 76; 74, identifier:group; 75, identifier:grouped; 76, block; 76, 77; 76, 87; 76, 140; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:vals; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:group; 83, identifier:dimension_values; 84, argument_list; 84, 85; 84, 86; 85, identifier:ydim; 86, False; 87, if_statement; 87, 88; 87, 94; 87, 106; 88, comparison_operator:==; 88, 89; 88, 93; 89, call; 89, 90; 89, 91; 90, identifier:len; 91, argument_list; 91, 92; 92, identifier:vals; 93, integer:1; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 102; 97, subscript; 97, 98; 97, 99; 98, identifier:orderings; 99, subscript; 99, 100; 99, 101; 100, identifier:vals; 101, integer:0; 102, list:[vals[0]]; 102, 103; 103, subscript; 103, 104; 103, 105; 104, identifier:vals; 105, integer:0; 106, else_clause; 106, 107; 107, block; 107, 108; 108, for_statement; 108, 109; 108, 110; 108, 119; 109, identifier:i; 110, call; 110, 111; 110, 112; 111, identifier:range; 112, argument_list; 112, 113; 113, binary_operator:-; 113, 114; 113, 118; 114, call; 114, 115; 114, 116; 115, identifier:len; 116, argument_list; 116, 117; 117, identifier:vals; 118, integer:1; 119, block; 119, 120; 119, 133; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, pattern_list; 122, 123; 122, 124; 123, identifier:p1; 124, identifier:p2; 125, subscript; 125, 126; 125, 127; 126, identifier:vals; 127, slice; 127, 128; 127, 129; 127, 130; 128, identifier:i; 129, colon; 130, binary_operator:+; 130, 131; 130, 132; 131, identifier:i; 132, integer:2; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:orderings; 137, identifier:p1; 138, list:[p2]; 138, 139; 139, identifier:p2; 140, if_statement; 140, 141; 140, 142; 141, identifier:sort; 142, block; 142, 143; 143, if_statement; 143, 144; 143, 153; 143, 170; 144, comparison_operator:in; 144, 145; 144, 150; 145, attribute; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:vals; 148, identifier:dtype; 149, identifier:kind; 150, tuple; 150, 151; 150, 152; 151, string:'i'; 152, string:'f'; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:sort; 157, call; 157, 158; 157, 169; 158, attribute; 158, 159; 158, 168; 159, parenthesized_expression; 159, 160; 160, comparison_operator:>=; 160, 161; 160, 167; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:np; 164, identifier:diff; 165, argument_list; 165, 166; 166, identifier:vals; 167, integer:0; 168, identifier:all; 169, argument_list; 170, else_clause; 170, 171; 171, block; 171, 172; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:sort; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:np; 178, identifier:array_equal; 179, argument_list; 179, 180; 179, 186; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:np; 183, identifier:sort; 184, argument_list; 184, 185; 185, identifier:vals; 186, identifier:vals; 187, if_statement; 187, 188; 187, 195; 187, 205; 188, boolean_operator:or; 188, 189; 188, 190; 189, identifier:sort; 190, call; 190, 191; 190, 192; 191, identifier:one_to_one; 192, argument_list; 192, 193; 192, 194; 193, identifier:orderings; 194, identifier:ycoords; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:ycoords; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:np; 202, identifier:sort; 203, argument_list; 203, 204; 204, identifier:ycoords; 205, elif_clause; 205, 206; 205, 211; 206, not_operator; 206, 207; 207, call; 207, 208; 207, 209; 208, identifier:is_cyclic; 209, argument_list; 209, 210; 210, identifier:orderings; 211, block; 211, 212; 211, 228; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:coords; 215, call; 215, 216; 215, 217; 216, identifier:list; 217, argument_list; 217, 218; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:itertools; 221, identifier:chain; 222, argument_list; 222, 223; 223, list_splat; 223, 224; 224, call; 224, 225; 224, 226; 225, identifier:sort_topologically; 226, argument_list; 226, 227; 227, identifier:orderings; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:ycoords; 231, conditional_expression:if; 231, 232; 231, 233; 231, 242; 232, identifier:coords; 233, comparison_operator:==; 233, 234; 233, 238; 234, call; 234, 235; 234, 236; 235, identifier:len; 236, argument_list; 236, 237; 237, identifier:coords; 238, call; 238, 239; 238, 240; 239, identifier:len; 240, argument_list; 240, 241; 241, identifier:ycoords; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:np; 245, identifier:sort; 246, argument_list; 246, 247; 247, identifier:ycoords; 248, return_statement; 248, 249; 249, expression_list; 249, 250; 249, 251; 250, identifier:xcoords; 251, identifier:ycoords | def _get_coords(self, obj):
xdim, ydim = obj.dimensions(label=True)[:2]
xcoords = obj.dimension_values(xdim, False)
ycoords = obj.dimension_values(ydim, False)
grouped = obj.groupby(xdim, container_type=OrderedDict,
group_type=Dataset).values()
orderings = OrderedDict()
sort = True
for group in grouped:
vals = group.dimension_values(ydim, False)
if len(vals) == 1:
orderings[vals[0]] = [vals[0]]
else:
for i in range(len(vals)-1):
p1, p2 = vals[i:i+2]
orderings[p1] = [p2]
if sort:
if vals.dtype.kind in ('i', 'f'):
sort = (np.diff(vals)>=0).all()
else:
sort = np.array_equal(np.sort(vals), vals)
if sort or one_to_one(orderings, ycoords):
ycoords = np.sort(ycoords)
elif not is_cyclic(orderings):
coords = list(itertools.chain(*sort_topologically(orderings)))
ycoords = coords if len(coords) == len(ycoords) else np.sort(ycoords)
return xcoords, ycoords |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:most_frequent_terms; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:count; 7, integer:0; 8, block; 8, 9; 8, 31; 8, 43; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:terms; 12, call; 12, 13; 12, 14; 13, identifier:sorted; 14, argument_list; 14, 15; 14, 22; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_terms; 20, identifier:items; 21, argument_list; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:key; 24, lambda; 24, 25; 24, 27; 25, lambda_parameters; 25, 26; 26, identifier:i; 27, unary_operator:-; 27, 28; 28, subscript; 28, 29; 28, 30; 29, identifier:i; 30, integer:1; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:terms; 34, call; 34, 35; 34, 36; 35, identifier:tuple; 36, generator_expression; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:i; 39, integer:0; 40, for_in_clause; 40, 41; 40, 42; 41, identifier:i; 42, identifier:terms; 43, if_statement; 43, 44; 43, 47; 43, 50; 43, 61; 44, comparison_operator:==; 44, 45; 44, 46; 45, identifier:count; 46, integer:0; 47, block; 47, 48; 48, return_statement; 48, 49; 49, identifier:terms; 50, elif_clause; 50, 51; 50, 54; 51, comparison_operator:>; 51, 52; 51, 53; 52, identifier:count; 53, integer:0; 54, block; 54, 55; 55, return_statement; 55, 56; 56, subscript; 56, 57; 56, 58; 57, identifier:terms; 58, slice; 58, 59; 58, 60; 59, colon; 60, identifier:count; 61, else_clause; 61, 62; 62, block; 62, 63; 63, raise_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:ValueError; 66, argument_list; 66, 67; 67, string:"Only non-negative values are allowed for count of terms." | def most_frequent_terms(self, count=0):
terms = sorted(self._terms.items(), key=lambda i: -i[1])
terms = tuple(i[0] for i in terms)
if count == 0:
return terms
elif count > 0:
return terms[:count]
else:
raise ValueError(
"Only non-negative values are allowed for count of terms.") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ascending; 7, False; 8, block; 8, 9; 9, if_statement; 9, 10; 9, 15; 9, 101; 10, comparison_operator:is; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:index_type; 14, None; 15, block; 15, 16; 15, 28; 15, 40; 15, 51; 15, 65; 15, 81; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:index_expr; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:grizzly_impl; 22, identifier:get_field; 23, argument_list; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:expr; 27, integer:0; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:column_expr; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:grizzly_impl; 34, identifier:get_field; 35, argument_list; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:expr; 39, integer:1; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:zip_expr; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:grizzly_impl; 46, identifier:zip_columns; 47, argument_list; 47, 48; 48, list:[index_expr, column_expr]; 48, 49; 48, 50; 49, identifier:index_expr; 50, identifier:column_expr; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:result_expr; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:grizzly_impl; 57, identifier:sort; 58, argument_list; 58, 59; 58, 60; 58, 61; 58, 64; 59, identifier:zip_expr; 60, integer:1; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:weld_type; 64, identifier:ascending; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:unzip_expr; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:grizzly_impl; 71, identifier:unzip_columns; 72, argument_list; 72, 73; 72, 74; 73, identifier:result_expr; 74, list:[self.index_type, self.weld_type]; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:index_type; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:weld_type; 81, return_statement; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:SeriesWeld; 84, argument_list; 84, 85; 84, 86; 84, 89; 84, 92; 84, 95; 84, 98; 85, identifier:unzip_expr; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:weld_type; 89, attribute; 89, 90; 89, 91; 90, identifier:self; 91, identifier:df; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:column_name; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:index_type; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:index_name; 101, else_clause; 101, 102; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:result_expr; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:grizzly_impl; 109, identifier:sort; 110, argument_list; 110, 111; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:expr | def sort_values(self, ascending=False):
if self.index_type is not None:
index_expr = grizzly_impl.get_field(self.expr, 0)
column_expr = grizzly_impl.get_field(self.expr, 1)
zip_expr = grizzly_impl.zip_columns([index_expr, column_expr])
result_expr = grizzly_impl.sort(zip_expr, 1, self.weld_type, ascending)
unzip_expr = grizzly_impl.unzip_columns(
result_expr,
[self.index_type, self.weld_type]
)
return SeriesWeld(
unzip_expr,
self.weld_type,
self.df,
self.column_name,
self.index_type,
self.index_name
)
else:
result_expr = grizzly_impl.sort(self.expr) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:expr; 5, default_parameter; 5, 6; 5, 7; 6, identifier:field; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:keytype; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ascending; 13, True; 14, block; 14, 15; 14, 23; 14, 32; 14, 53; 14, 70; 14, 82; 14, 98; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:weld_obj; 18, call; 18, 19; 18, 20; 19, identifier:WeldObject; 20, argument_list; 20, 21; 20, 22; 21, identifier:encoder_; 22, identifier:decoder_; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:expr_var; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:weld_obj; 29, identifier:update; 30, argument_list; 30, 31; 31, identifier:expr; 32, if_statement; 32, 33; 32, 38; 33, call; 33, 34; 33, 35; 34, identifier:isinstance; 35, argument_list; 35, 36; 35, 37; 36, identifier:expr; 37, identifier:WeldObject; 38, block; 38, 39; 38, 45; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:expr_var; 42, attribute; 42, 43; 42, 44; 43, identifier:expr; 44, identifier:obj_id; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 52; 47, subscript; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:weld_obj; 50, identifier:dependencies; 51, identifier:expr_var; 52, identifier:expr; 53, if_statement; 53, 54; 53, 57; 53, 64; 54, comparison_operator:is; 54, 55; 54, 56; 55, identifier:field; 56, None; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:key_str; 61, binary_operator:%; 61, 62; 61, 63; 62, string:"x.$%s"; 63, identifier:field; 64, else_clause; 64, 65; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:key_str; 69, string:"x"; 70, if_statement; 70, 71; 70, 73; 71, not_operator; 71, 72; 72, identifier:ascending; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:key_str; 77, binary_operator:+; 77, 78; 77, 79; 78, identifier:key_str; 79, binary_operator:%; 79, 80; 79, 81; 80, string:"* %s(-1)"; 81, identifier:keytype; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:weld_template; 85, assignment; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:weld_obj; 88, identifier:weld_code; 89, binary_operator:%; 89, 90; 89, 91; 90, identifier:weld_template; 91, dictionary; 91, 92; 91, 95; 92, pair; 92, 93; 92, 94; 93, string:"expr"; 94, identifier:expr_var; 95, pair; 95, 96; 95, 97; 96, string:"key"; 97, identifier:key_str; 98, return_statement; 98, 99; 99, identifier:weld_obj | def sort(expr, field = None, keytype=None, ascending=True):
weld_obj = WeldObject(encoder_, decoder_)
expr_var = weld_obj.update(expr)
if isinstance(expr, WeldObject):
expr_var = expr.obj_id
weld_obj.dependencies[expr_var] = expr
if field is not None:
key_str = "x.$%s" % field
else:
key_str = "x"
if not ascending:
key_str = key_str + "* %s(-1)" % keytype
weld_template =
weld_obj.weld_code = weld_template % {"expr":expr_var, "key":key_str}
return weld_obj |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:expand_filename_pattern; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:pattern; 6, identifier:base_dir; 7, default_parameter; 7, 8; 7, 9; 8, identifier:sourcefile; 9, None; 10, block; 10, 11; 10, 21; 10, 28; 10, 34; 10, 48; 10, 58; 10, 64; 10, 76; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:expandedPattern; 14, call; 14, 15; 14, 16; 15, identifier:substitute_vars; 16, argument_list; 16, 17; 16, 19; 16, 20; 17, list:[pattern]; 17, 18; 18, identifier:pattern; 19, identifier:self; 20, identifier:sourcefile; 21, assert_statement; 21, 22; 22, comparison_operator:==; 22, 23; 22, 27; 23, call; 23, 24; 23, 25; 24, identifier:len; 25, argument_list; 25, 26; 26, identifier:expandedPattern; 27, integer:1; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:expandedPattern; 31, subscript; 31, 32; 31, 33; 32, identifier:expandedPattern; 33, integer:0; 34, if_statement; 34, 35; 34, 38; 35, comparison_operator:!=; 35, 36; 35, 37; 36, identifier:expandedPattern; 37, identifier:pattern; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:logging; 43, identifier:debug; 44, argument_list; 44, 45; 44, 46; 44, 47; 45, string:"Expanded variables in expression %r to %r."; 46, identifier:pattern; 47, identifier:expandedPattern; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:fileList; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:util; 54, identifier:expand_filename_pattern; 55, argument_list; 55, 56; 55, 57; 56, identifier:expandedPattern; 57, identifier:base_dir; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:fileList; 62, identifier:sort; 63, argument_list; 64, if_statement; 64, 65; 64, 67; 65, not_operator; 65, 66; 66, identifier:fileList; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:logging; 72, identifier:warning; 73, argument_list; 73, 74; 73, 75; 74, string:"No files found matching %r."; 75, identifier:pattern; 76, return_statement; 76, 77; 77, identifier:fileList | def expand_filename_pattern(self, pattern, base_dir, sourcefile=None):
expandedPattern = substitute_vars([pattern], self, sourcefile)
assert len(expandedPattern) == 1
expandedPattern = expandedPattern[0]
if expandedPattern != pattern:
logging.debug("Expanded variables in expression %r to %r.",
pattern, expandedPattern)
fileList = util.expand_filename_pattern(expandedPattern, base_dir)
fileList.sort()
if not fileList:
logging.warning("No files found matching %r.", pattern)
return fileList |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_file_list; 3, parameters; 3, 4; 4, identifier:shortFile; 5, block; 5, 6; 5, 14; 5, 32; 5, 41; 5, 65; 6, if_statement; 6, 7; 6, 10; 7, comparison_operator:in; 7, 8; 7, 9; 8, string:"://"; 9, identifier:shortFile; 10, block; 10, 11; 11, return_statement; 11, 12; 12, list:[shortFile]; 12, 13; 13, identifier:shortFile; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:expandedFile; 17, call; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:os; 21, identifier:path; 22, identifier:expandvars; 23, argument_list; 23, 24; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:os; 28, identifier:path; 29, identifier:expanduser; 30, argument_list; 30, 31; 31, identifier:shortFile; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:fileList; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:glob; 38, identifier:glob; 39, argument_list; 39, 40; 40, identifier:expandedFile; 41, if_statement; 41, 42; 41, 48; 41, 55; 42, comparison_operator:!=; 42, 43; 42, 47; 43, call; 43, 44; 43, 45; 44, identifier:len; 45, argument_list; 45, 46; 46, identifier:fileList; 47, integer:0; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:fileList; 53, identifier:sort; 54, argument_list; 55, else_clause; 55, 56; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:logging; 61, identifier:warning; 62, argument_list; 62, 63; 62, 64; 63, string:"No file matches '%s'."; 64, identifier:shortFile; 65, return_statement; 65, 66; 66, identifier:fileList | def get_file_list(shortFile):
if "://" in shortFile:
return [shortFile]
expandedFile = os.path.expandvars(os.path.expanduser(shortFile))
fileList = glob.glob(expandedFile)
if len(fileList) != 0:
fileList.sort()
else:
logging.warning("No file matches '%s'.", shortFile)
return fileList |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:FPS; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:name; 5, identifier:sort; 6, default_parameter; 6, 7; 6, 8; 7, identifier:explicit_name; 8, None; 9, block; 9, 10; 9, 29; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:n; 13, call; 13, 14; 13, 15; 14, identifier:_make_name; 15, argument_list; 15, 16; 15, 17; 15, 20; 15, 26; 16, identifier:name; 17, attribute; 17, 18; 17, 19; 18, identifier:sort; 19, identifier:length; 20, conditional_expression:if; 20, 21; 20, 22; 20, 25; 21, False; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:explicit_name; 24, None; 25, identifier:explicit_name; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:prefix; 28, string:'FP_'; 29, return_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:FP; 32, argument_list; 32, 33; 32, 34; 32, 37; 32, 41; 32, 44; 33, string:'FPS'; 34, tuple; 34, 35; 34, 36; 35, identifier:n; 36, identifier:sort; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:variables; 39, set; 39, 40; 40, identifier:n; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:symbolic; 43, True; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:length; 46, attribute; 46, 47; 46, 48; 47, identifier:sort; 48, identifier:length | def FPS(name, sort, explicit_name=None):
n = _make_name(name, sort.length, False if explicit_name is None else explicit_name, prefix='FP_')
return FP('FPS', (n, sort), variables={n}, symbolic=True, length=sort.length) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:to_fp; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:sort; 6, default_parameter; 6, 7; 6, 8; 7, identifier:rm; 8, None; 9, block; 9, 10; 9, 25; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:rm; 13, None; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:rm; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:fp; 22, identifier:RM; 23, identifier:default; 24, argument_list; 25, return_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:fpToFP; 28, argument_list; 28, 29; 28, 30; 28, 31; 29, identifier:rm; 30, identifier:self; 31, identifier:sort | def to_fp(self, sort, rm=None):
if rm is None:
rm = fp.RM.default()
return fpToFP(rm, self, sort) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:val_to_fp; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:sort; 6, default_parameter; 6, 7; 6, 8; 7, identifier:signed; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:rm; 11, None; 12, block; 12, 13; 12, 30; 12, 50; 12, 61; 13, if_statement; 13, 14; 13, 17; 14, comparison_operator:is; 14, 15; 14, 16; 15, identifier:rm; 16, None; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:rm; 21, call; 21, 22; 21, 29; 22, attribute; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:fp; 26, identifier:fp; 27, identifier:RM; 28, identifier:default; 29, argument_list; 30, if_statement; 30, 31; 30, 34; 31, comparison_operator:is; 31, 32; 31, 33; 32, identifier:sort; 33, None; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:sort; 38, call; 38, 39; 38, 46; 39, attribute; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:fp; 43, identifier:fp; 44, identifier:FSort; 45, identifier:from_size; 46, argument_list; 46, 47; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:length; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:op; 53, conditional_expression:if; 53, 54; 53, 57; 53, 58; 54, attribute; 54, 55; 54, 56; 55, identifier:fp; 56, identifier:fpToFP; 57, identifier:signed; 58, attribute; 58, 59; 58, 60; 59, identifier:fp; 60, identifier:fpToFPUnsigned; 61, return_statement; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:op; 64, argument_list; 64, 65; 64, 66; 64, 67; 65, identifier:rm; 66, identifier:self; 67, identifier:sort | def val_to_fp(self, sort, signed=True, rm=None):
if rm is None:
rm = fp.fp.RM.default()
if sort is None:
sort = fp.fp.FSort.from_size(self.length)
op = fp.fpToFP if signed else fp.fpToFPUnsigned
return op(rm, self, sort) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_orbitals; 3, parameters; 3, 4; 4, identifier:element_pdos; 5, block; 5, 6; 5, 29; 5, 37; 5, 41; 5, 57; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:sorted_orbitals; 9, list:['s', 'p', 'py', 'pz', 'px',
'd', 'dxy', 'dyz', 'dz2', 'dxz', 'dx2',
'f', 'f_3', 'f_2', 'f_1', 'f_0', 'f1', 'f2', 'f3']; 9, 10; 9, 11; 9, 12; 9, 13; 9, 14; 9, 15; 9, 16; 9, 17; 9, 18; 9, 19; 9, 20; 9, 21; 9, 22; 9, 23; 9, 24; 9, 25; 9, 26; 9, 27; 9, 28; 10, string:'s'; 11, string:'p'; 12, string:'py'; 13, string:'pz'; 14, string:'px'; 15, string:'d'; 16, string:'dxy'; 17, string:'dyz'; 18, string:'dz2'; 19, string:'dxz'; 20, string:'dx2'; 21, string:'f'; 22, string:'f_3'; 23, string:'f_2'; 24, string:'f_1'; 25, string:'f_0'; 26, string:'f1'; 27, string:'f2'; 28, string:'f3'; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:unsorted_keys; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:element_pdos; 35, identifier:keys; 36, argument_list; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:sorted_keys; 40, list:[]; 41, for_statement; 41, 42; 41, 43; 41, 44; 42, identifier:key; 43, identifier:sorted_orbitals; 44, block; 44, 45; 45, if_statement; 45, 46; 45, 49; 46, comparison_operator:in; 46, 47; 46, 48; 47, identifier:key; 48, identifier:unsorted_keys; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:sorted_keys; 54, identifier:append; 55, argument_list; 55, 56; 56, identifier:key; 57, return_statement; 57, 58; 58, identifier:sorted_keys | def sort_orbitals(element_pdos):
sorted_orbitals = ['s', 'p', 'py', 'pz', 'px',
'd', 'dxy', 'dyz', 'dz2', 'dxz', 'dx2',
'f', 'f_3', 'f_2', 'f_1', 'f_0', 'f1', 'f2', 'f3']
unsorted_keys = element_pdos.keys()
sorted_keys = []
for key in sorted_orbitals:
if key in unsorted_keys:
sorted_keys.append(key)
return sorted_keys |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:find_vasprun_files; 3, parameters; 4, block; 4, 5; 4, 14; 4, 25; 4, 29; 4, 111; 5, expression_statement; 5, 6; 6, assignment; 6, 7; 6, 8; 7, identifier:folders; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:glob; 11, identifier:glob; 12, argument_list; 12, 13; 13, string:'split-*'; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:folders; 17, conditional_expression:if; 17, 18; 17, 22; 17, 23; 18, call; 18, 19; 18, 20; 19, identifier:sorted; 20, argument_list; 20, 21; 21, identifier:folders; 22, identifier:folders; 23, list:['.']; 23, 24; 24, string:'.'; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:filenames; 28, list:[]; 29, for_statement; 29, 30; 29, 31; 29, 32; 30, identifier:fol; 31, identifier:folders; 32, block; 32, 33; 32, 45; 32, 57; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:vr_file; 36, call; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:os; 40, identifier:path; 41, identifier:join; 42, argument_list; 42, 43; 42, 44; 43, identifier:fol; 44, string:'vasprun.xml'; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:vr_file_gz; 48, call; 48, 49; 48, 54; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:os; 52, identifier:path; 53, identifier:join; 54, argument_list; 54, 55; 54, 56; 55, identifier:fol; 56, string:'vasprun.xml.gz'; 57, if_statement; 57, 58; 57, 66; 57, 74; 57, 91; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:os; 62, identifier:path; 63, identifier:exists; 64, argument_list; 64, 65; 65, identifier:vr_file; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:filenames; 71, identifier:append; 72, argument_list; 72, 73; 73, identifier:vr_file; 74, elif_clause; 74, 75; 74, 83; 75, call; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:os; 79, identifier:path; 80, identifier:exists; 81, argument_list; 81, 82; 82, identifier:vr_file_gz; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:filenames; 88, identifier:append; 89, argument_list; 89, 90; 90, identifier:vr_file_gz; 91, else_clause; 91, 92; 92, block; 92, 93; 92, 105; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:logging; 97, identifier:error; 98, argument_list; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, string:'ERROR: No vasprun.xml found in {}!'; 102, identifier:format; 103, argument_list; 103, 104; 104, identifier:fol; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:sys; 109, identifier:exit; 110, argument_list; 111, return_statement; 111, 112; 112, identifier:filenames | def find_vasprun_files():
folders = glob.glob('split-*')
folders = sorted(folders) if folders else ['.']
filenames = []
for fol in folders:
vr_file = os.path.join(fol, 'vasprun.xml')
vr_file_gz = os.path.join(fol, 'vasprun.xml.gz')
if os.path.exists(vr_file):
filenames.append(vr_file)
elif os.path.exists(vr_file_gz):
filenames.append(vr_file_gz)
else:
logging.error('ERROR: No vasprun.xml found in {}!'.format(fol))
sys.exit()
return filenames |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:feed; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:byts; 6, block; 6, 7; 6, 9; 6, 18; 6, 22; 6, 74; 7, expression_statement; 7, 8; 8, string:'''
Feed bytes to the unpacker and return completed objects.
Args:
byts (bytes): Bytes to unpack.
Notes:
It is intended that this function is called multiple times with
bytes from some sort of a stream, as it will unpack and return
objects as they are available.
Returns:
list: List of tuples containing the item size and the unpacked item.
'''; 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:unpk; 15, identifier:feed; 16, argument_list; 16, 17; 17, identifier:byts; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:retn; 21, list:[]; 22, while_statement; 22, 23; 22, 24; 23, True; 24, block; 24, 25; 25, try_statement; 25, 26; 25, 66; 26, block; 26, 27; 26, 37; 26, 47; 26, 60; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:item; 30, call; 30, 31; 30, 36; 31, attribute; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:unpk; 35, identifier:unpack; 36, argument_list; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:tell; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:unpk; 45, identifier:tell; 46, argument_list; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:retn; 51, identifier:append; 52, argument_list; 52, 53; 53, tuple; 53, 54; 53, 59; 54, binary_operator:-; 54, 55; 54, 56; 55, identifier:tell; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:size; 59, identifier:item; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:size; 65, identifier:tell; 66, except_clause; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:msgpack; 70, identifier:exceptions; 71, identifier:OutOfData; 72, block; 72, 73; 73, break_statement; 74, return_statement; 74, 75; 75, identifier:retn | def feed(self, byts):
'''
Feed bytes to the unpacker and return completed objects.
Args:
byts (bytes): Bytes to unpack.
Notes:
It is intended that this function is called multiple times with
bytes from some sort of a stream, as it will unpack and return
objects as they are available.
Returns:
list: List of tuples containing the item size and the unpacked item.
'''
self.unpk.feed(byts)
retn = []
while True:
try:
item = self.unpk.unpack()
tell = self.unpk.tell()
retn.append((tell - self.size, item))
self.size = tell
except msgpack.exceptions.OutOfData:
break
return retn |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:maximum_consecutive_dry_days; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:pr; 5, default_parameter; 5, 6; 5, 7; 6, identifier:thresh; 7, string:'1 mm/day'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:freq; 10, string:'YS'; 11, block; 11, 12; 11, 14; 11, 25; 11, 39; 12, expression_statement; 12, 13; 13, identifier:r; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:t; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:utils; 20, identifier:convert_units_to; 21, argument_list; 21, 22; 21, 23; 21, 24; 22, identifier:thresh; 23, identifier:pr; 24, string:'hydro'; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:group; 28, call; 28, 29; 28, 35; 29, attribute; 29, 30; 29, 34; 30, parenthesized_expression; 30, 31; 31, comparison_operator:<; 31, 32; 31, 33; 32, identifier:pr; 33, identifier:t; 34, identifier:resample; 35, argument_list; 35, 36; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:time; 38, identifier:freq; 39, return_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:group; 43, identifier:apply; 44, argument_list; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:rl; 47, identifier:longest_run; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:dim; 50, string:'time' | def maximum_consecutive_dry_days(pr, thresh='1 mm/day', freq='YS'):
r
t = utils.convert_units_to(thresh, pr, 'hydro')
group = (pr < t).resample(time=freq)
return group.apply(rl.longest_run, dim='time') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:daily_downsampler; 3, parameters; 3, 4; 3, 5; 4, identifier:da; 5, default_parameter; 5, 6; 5, 7; 6, identifier:freq; 7, string:'YS'; 8, block; 8, 9; 8, 11; 8, 108; 8, 127; 8, 135; 8, 242; 8, 250; 8, 260; 9, expression_statement; 9, 10; 10, identifier:r; 11, if_statement; 11, 12; 11, 25; 11, 68; 12, call; 12, 13; 12, 14; 13, identifier:isinstance; 14, argument_list; 14, 15; 14, 22; 15, subscript; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:da; 19, identifier:time; 20, identifier:values; 21, integer:0; 22, attribute; 22, 23; 22, 24; 23, identifier:np; 24, identifier:datetime64; 25, block; 25, 26; 25, 47; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:years; 29, list_comprehension; 29, 30; 29, 36; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, string:'{:04d}'; 33, identifier:format; 34, argument_list; 34, 35; 35, identifier:y; 36, for_in_clause; 36, 37; 36, 38; 37, identifier:y; 38, attribute; 38, 39; 38, 46; 39, attribute; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:da; 43, identifier:time; 44, identifier:dt; 45, identifier:year; 46, identifier:values; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:months; 50, list_comprehension; 50, 51; 50, 57; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, string:'{:02d}'; 54, identifier:format; 55, argument_list; 55, 56; 56, identifier:m; 57, for_in_clause; 57, 58; 57, 59; 58, identifier:m; 59, attribute; 59, 60; 59, 67; 60, attribute; 60, 61; 60, 66; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:da; 64, identifier:time; 65, identifier:dt; 66, identifier:month; 67, identifier:values; 68, else_clause; 68, 69; 69, block; 69, 70; 69, 89; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:years; 73, list_comprehension; 73, 74; 73, 82; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, string:'{:04d}'; 77, identifier:format; 78, argument_list; 78, 79; 79, attribute; 79, 80; 79, 81; 80, identifier:v; 81, identifier:year; 82, for_in_clause; 82, 83; 82, 84; 83, identifier:v; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:da; 87, identifier:time; 88, identifier:values; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:months; 92, list_comprehension; 92, 93; 92, 101; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, string:'{:02d}'; 96, identifier:format; 97, argument_list; 97, 98; 98, attribute; 98, 99; 98, 100; 99, identifier:v; 100, identifier:month; 101, for_in_clause; 101, 102; 101, 103; 102, identifier:v; 103, attribute; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:da; 106, identifier:time; 107, identifier:values; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:seasons; 111, list_comprehension; 111, 112; 111, 124; 112, subscript; 112, 113; 112, 118; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, string:'DJF DJF MAM MAM MAM JJA JJA JJA SON SON SON DJF'; 116, identifier:split; 117, argument_list; 118, binary_operator:-; 118, 119; 118, 123; 119, call; 119, 120; 119, 121; 120, identifier:int; 121, argument_list; 121, 122; 122, identifier:m; 123, integer:1; 124, for_in_clause; 124, 125; 124, 126; 125, identifier:m; 126, identifier:months; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:n_t; 130, attribute; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:da; 133, identifier:time; 134, identifier:size; 135, if_statement; 135, 136; 135, 139; 135, 144; 135, 166; 135, 230; 136, comparison_operator:==; 136, 137; 136, 138; 137, identifier:freq; 138, string:'YS'; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:l_tags; 143, identifier:years; 144, elif_clause; 144, 145; 144, 148; 145, comparison_operator:==; 145, 146; 145, 147; 146, identifier:freq; 147, string:'MS'; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:l_tags; 152, list_comprehension; 152, 153; 152, 160; 153, binary_operator:+; 153, 154; 153, 157; 154, subscript; 154, 155; 154, 156; 155, identifier:years; 156, identifier:i; 157, subscript; 157, 158; 157, 159; 158, identifier:months; 159, identifier:i; 160, for_in_clause; 160, 161; 160, 162; 161, identifier:i; 162, call; 162, 163; 162, 164; 163, identifier:range; 164, argument_list; 164, 165; 165, identifier:n_t; 166, elif_clause; 166, 167; 166, 170; 167, comparison_operator:==; 167, 168; 167, 169; 168, identifier:freq; 169, string:'QS-DEC'; 170, block; 170, 171; 170, 175; 170, 226; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:ys; 174, list:[]; 175, for_statement; 175, 176; 175, 177; 175, 181; 176, identifier:i; 177, call; 177, 178; 177, 179; 178, identifier:range; 179, argument_list; 179, 180; 180, identifier:n_t; 181, block; 181, 182; 181, 188; 181, 194; 181, 200; 181, 217; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:m; 185, subscript; 185, 186; 185, 187; 186, identifier:months; 187, identifier:i; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:s; 191, subscript; 191, 192; 191, 193; 192, identifier:seasons; 193, identifier:i; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:y; 197, subscript; 197, 198; 197, 199; 198, identifier:years; 199, identifier:i; 200, if_statement; 200, 201; 200, 204; 201, comparison_operator:==; 201, 202; 201, 203; 202, identifier:m; 203, string:'12'; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:y; 208, call; 208, 209; 208, 210; 209, identifier:str; 210, argument_list; 210, 211; 211, binary_operator:+; 211, 212; 211, 216; 212, call; 212, 213; 212, 214; 213, identifier:int; 214, argument_list; 214, 215; 215, identifier:y; 216, integer:1; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:ys; 221, identifier:append; 222, argument_list; 222, 223; 223, binary_operator:+; 223, 224; 223, 225; 224, identifier:y; 225, identifier:s; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:l_tags; 229, identifier:ys; 230, else_clause; 230, 231; 231, block; 231, 232; 232, raise_statement; 232, 233; 233, call; 233, 234; 233, 235; 234, identifier:RuntimeError; 235, argument_list; 235, 236; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, string:'freqency {:s} not implemented'; 239, identifier:format; 240, argument_list; 240, 241; 241, identifier:freq; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:buffer; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:da; 248, identifier:copy; 249, argument_list; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 257; 252, subscript; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:buffer; 255, identifier:coords; 256, string:'tags'; 257, tuple; 257, 258; 257, 259; 258, string:'time'; 259, identifier:l_tags; 260, return_statement; 260, 261; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:buffer; 264, identifier:groupby; 265, argument_list; 265, 266; 266, string:'tags' | def daily_downsampler(da, freq='YS'):
r
if isinstance(da.time.values[0], np.datetime64):
years = ['{:04d}'.format(y) for y in da.time.dt.year.values]
months = ['{:02d}'.format(m) for m in da.time.dt.month.values]
else:
years = ['{:04d}'.format(v.year) for v in da.time.values]
months = ['{:02d}'.format(v.month) for v in da.time.values]
seasons = ['DJF DJF MAM MAM MAM JJA JJA JJA SON SON SON DJF'.split()[int(m) - 1] for m in months]
n_t = da.time.size
if freq == 'YS':
l_tags = years
elif freq == 'MS':
l_tags = [years[i] + months[i] for i in range(n_t)]
elif freq == 'QS-DEC':
ys = []
for i in range(n_t):
m = months[i]
s = seasons[i]
y = years[i]
if m == '12':
y = str(int(y) + 1)
ys.append(y + s)
l_tags = ys
else:
raise RuntimeError('freqency {:s} not implemented'.format(freq))
buffer = da.copy()
buffer.coords['tags'] = ('time', l_tags)
return buffer.groupby('tags') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:identify_vertex_neighbours; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:vertex; 6, block; 6, 7; 6, 13; 6, 26; 6, 47; 6, 54; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:simplices; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:simplices; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 18; 15, pattern_list; 15, 16; 15, 17; 16, identifier:ridx; 17, identifier:cidx; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:np; 21, identifier:where; 22, argument_list; 22, 23; 23, comparison_operator:==; 23, 24; 23, 25; 24, identifier:simplices; 25, identifier:vertex; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:neighbour_array; 29, call; 29, 30; 29, 46; 30, attribute; 30, 31; 30, 45; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:np; 34, identifier:unique; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:np; 39, identifier:hstack; 40, argument_list; 40, 41; 41, list:[simplices[ridx]]; 41, 42; 42, subscript; 42, 43; 42, 44; 43, identifier:simplices; 44, identifier:ridx; 45, identifier:tolist; 46, argument_list; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:neighbour_array; 51, identifier:remove; 52, argument_list; 52, 53; 53, identifier:vertex; 54, return_statement; 54, 55; 55, identifier:neighbour_array | def identify_vertex_neighbours(self, vertex):
simplices = self.simplices
ridx, cidx = np.where(simplices == vertex)
neighbour_array = np.unique(np.hstack([simplices[ridx]])).tolist()
neighbour_array.remove(vertex)
return neighbour_array |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:json_encode; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:out; 6, default_parameter; 6, 7; 6, 8; 7, identifier:limit; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort_keys; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:indent; 14, None; 15, block; 15, 16; 15, 18; 15, 27; 15, 41; 16, expression_statement; 16, 17; 17, string:'''Encode the results of this paged response as JSON writing to the
provided file-like `out` object. This function will iteratively read
as many pages as present, streaming the contents out as JSON.
:param file-like out: an object with a `write` function
:param int limit: optional maximum number of items to write
:param bool sort_keys: if True, output keys sorted, default is False
:param bool indent: if True, indent output, default is False
'''; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:stream; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:_json_stream; 25, argument_list; 25, 26; 26, identifier:limit; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:enc; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:json; 33, identifier:JSONEncoder; 34, argument_list; 34, 35; 34, 38; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:indent; 37, identifier:indent; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:sort_keys; 40, identifier:sort_keys; 41, for_statement; 41, 42; 41, 43; 41, 49; 42, identifier:chunk; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:enc; 46, identifier:iterencode; 47, argument_list; 47, 48; 48, identifier:stream; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:out; 54, identifier:write; 55, argument_list; 55, 56; 56, binary_operator:%; 56, 57; 56, 58; 57, string:u'%s'; 58, identifier:chunk | def json_encode(self, out, limit=None, sort_keys=False, indent=None):
'''Encode the results of this paged response as JSON writing to the
provided file-like `out` object. This function will iteratively read
as many pages as present, streaming the contents out as JSON.
:param file-like out: an object with a `write` function
:param int limit: optional maximum number of items to write
:param bool sort_keys: if True, output keys sorted, default is False
:param bool indent: if True, indent output, default is False
'''
stream = self._json_stream(limit)
enc = json.JSONEncoder(indent=indent, sort_keys=sort_keys)
for chunk in enc.iterencode(stream):
out.write(u'%s' % chunk) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:quick_search; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:request; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kw; 8, block; 8, 9; 8, 11; 8, 20; 8, 29; 9, expression_statement; 9, 10; 10, string:'''Execute a quick search with the specified request.
:param request: see :ref:`api-search-request`
:param **kw: See Options below
:returns: :py:class:`planet.api.models.Items`
:raises planet.api.exceptions.APIException: On API error.
:Options:
* page_size (int): Size of response pages
* sort (string): Sorting order in the form `field (asc|desc)`
'''; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:body; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:json; 17, identifier:dumps; 18, argument_list; 18, 19; 19, identifier:request; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:params; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_params; 27, argument_list; 27, 28; 28, identifier:kw; 29, return_statement; 29, 30; 30, call; 30, 31; 30, 68; 31, attribute; 31, 32; 31, 67; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:dispatcher; 37, identifier:response; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:models; 42, identifier:Request; 43, argument_list; 43, 44; 43, 50; 43, 53; 43, 56; 43, 61; 43, 64; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_url; 48, argument_list; 48, 49; 49, string:'data/v1/quick-search'; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:auth; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:params; 55, identifier:params; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:body_type; 58, attribute; 58, 59; 58, 60; 59, identifier:models; 60, identifier:Items; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:data; 63, identifier:body; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:method; 66, string:'POST'; 67, identifier:get_body; 68, argument_list | def quick_search(self, request, **kw):
'''Execute a quick search with the specified request.
:param request: see :ref:`api-search-request`
:param **kw: See Options below
:returns: :py:class:`planet.api.models.Items`
:raises planet.api.exceptions.APIException: On API error.
:Options:
* page_size (int): Size of response pages
* sort (string): Sorting order in the form `field (asc|desc)`
'''
body = json.dumps(request)
params = self._params(kw)
return self.dispatcher.response(models.Request(
self._url('data/v1/quick-search'), self.auth, params=params,
body_type=models.Items, data=body, method='POST')).get_body() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:saved_search; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:sid; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kw; 8, block; 8, 9; 8, 11; 8, 17; 8, 26; 9, expression_statement; 9, 10; 10, string:'''Execute a saved search by search id.
:param sid string: The id of the search
:returns: :py:class:`planet.api.models.Items`
:raises planet.api.exceptions.APIException: On API error.
:Options:
* page_size (int): Size of response pages
* sort (string): Sorting order in the form `field (asc|desc)`
'''; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:path; 14, binary_operator:%; 14, 15; 14, 16; 15, string:'data/v1/searches/%s/results'; 16, identifier:sid; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:params; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_params; 24, argument_list; 24, 25; 25, identifier:kw; 26, return_statement; 26, 27; 27, call; 27, 28; 27, 49; 28, attribute; 28, 29; 28, 48; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:_get; 33, argument_list; 33, 34; 33, 40; 33, 45; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_url; 38, argument_list; 38, 39; 39, identifier:path; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:body_type; 42, attribute; 42, 43; 42, 44; 43, identifier:models; 44, identifier:Items; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:params; 47, identifier:params; 48, identifier:get_body; 49, argument_list | def saved_search(self, sid, **kw):
'''Execute a saved search by search id.
:param sid string: The id of the search
:returns: :py:class:`planet.api.models.Items`
:raises planet.api.exceptions.APIException: On API error.
:Options:
* page_size (int): Size of response pages
* sort (string): Sorting order in the form `field (asc|desc)`
'''
path = 'data/v1/searches/%s/results' % sid
params = self._params(kw)
return self._get(self._url(path), body_type=models.Items,
params=params).get_body() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sortValue_isItalic; 3, parameters; 3, 4; 4, identifier:font; 5, block; 5, 6; 5, 12; 5, 18; 5, 29; 5, 40; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:info; 9, attribute; 9, 10; 9, 11; 10, identifier:font; 11, identifier:info; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:styleMapStyleName; 15, attribute; 15, 16; 15, 17; 16, identifier:info; 17, identifier:styleMapStyleName; 18, if_statement; 18, 19; 18, 26; 19, boolean_operator:and; 19, 20; 19, 23; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:styleMapStyleName; 22, None; 23, comparison_operator:in; 23, 24; 23, 25; 24, string:"italic"; 25, identifier:styleMapStyleName; 26, block; 26, 27; 27, return_statement; 27, 28; 28, integer:0; 29, if_statement; 29, 30; 29, 37; 30, comparison_operator:not; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:info; 33, identifier:italicAngle; 34, tuple; 34, 35; 34, 36; 35, None; 36, integer:0; 37, block; 37, 38; 38, return_statement; 38, 39; 39, integer:0; 40, return_statement; 40, 41; 41, integer:1 | def _sortValue_isItalic(font):
info = font.info
styleMapStyleName = info.styleMapStyleName
if styleMapStyleName is not None and "italic" in styleMapStyleName:
return 0
if info.italicAngle not in (None, 0):
return 0
return 1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sortValue_isMonospace; 3, parameters; 3, 4; 4, identifier:font; 5, block; 5, 6; 5, 15; 5, 24; 5, 28; 5, 54; 6, if_statement; 6, 7; 6, 12; 7, attribute; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:font; 10, identifier:info; 11, identifier:postscriptIsFixedPitch; 12, block; 12, 13; 13, return_statement; 13, 14; 14, integer:0; 15, if_statement; 15, 16; 15, 21; 16, not_operator; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:len; 19, argument_list; 19, 20; 20, identifier:font; 21, block; 21, 22; 22, return_statement; 22, 23; 23, integer:1; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:testWidth; 27, None; 28, for_statement; 28, 29; 28, 30; 28, 31; 29, identifier:glyph; 30, identifier:font; 31, block; 31, 32; 32, if_statement; 32, 33; 32, 36; 32, 43; 33, comparison_operator:is; 33, 34; 33, 35; 34, identifier:testWidth; 35, None; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:testWidth; 40, attribute; 40, 41; 40, 42; 41, identifier:glyph; 42, identifier:width; 43, else_clause; 43, 44; 44, block; 44, 45; 45, if_statement; 45, 46; 45, 51; 46, comparison_operator:!=; 46, 47; 46, 48; 47, identifier:testWidth; 48, attribute; 48, 49; 48, 50; 49, identifier:glyph; 50, identifier:width; 51, block; 51, 52; 52, return_statement; 52, 53; 53, integer:1; 54, return_statement; 54, 55; 55, integer:0 | def _sortValue_isMonospace(font):
if font.info.postscriptIsFixedPitch:
return 0
if not len(font):
return 1
testWidth = None
for glyph in font:
if testWidth is None:
testWidth = glyph.width
else:
if testWidth != glyph.width:
return 1
return 0 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:flair_template_sync; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, identifier:self; 5, identifier:editable; 6, identifier:limit; 7, identifier:static; 8, identifier:sort; 9, identifier:use_css; 10, identifier:use_text; 11, block; 11, 12; 11, 24; 11, 30; 11, 50; 11, 54; 11, 116; 11, 138; 11, 219; 11, 228; 11, 268; 11, 278; 11, 290; 12, if_statement; 12, 13; 12, 18; 13, boolean_operator:and; 13, 14; 13, 16; 14, not_operator; 14, 15; 15, identifier:use_text; 16, not_operator; 16, 17; 17, identifier:use_css; 18, block; 18, 19; 19, raise_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:Exception; 22, argument_list; 22, 23; 23, string:'At least one of use_text or use_css must be True'; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:sorts; 27, tuple; 27, 28; 27, 29; 28, string:'alpha'; 29, string:'size'; 30, if_statement; 30, 31; 30, 34; 31, comparison_operator:not; 31, 32; 31, 33; 32, identifier:sort; 33, identifier:sorts; 34, block; 34, 35; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:Exception; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, string:'Sort must be one of: {}'; 42, identifier:format; 43, argument_list; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, string:', '; 47, identifier:join; 48, argument_list; 48, 49; 49, identifier:sorts; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:counter; 53, dictionary; 54, if_statement; 54, 55; 54, 56; 55, identifier:static; 56, block; 56, 57; 57, for_statement; 57, 58; 57, 59; 57, 60; 58, identifier:key; 59, identifier:static; 60, block; 60, 61; 60, 110; 61, if_statement; 61, 62; 61, 65; 62, boolean_operator:and; 62, 63; 62, 64; 63, identifier:use_css; 64, identifier:use_text; 65, block; 65, 66; 65, 85; 65, 106; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:parts; 69, call; 69, 70; 69, 71; 70, identifier:tuple; 71, generator_expression; 71, 72; 71, 77; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:x; 75, identifier:strip; 76, argument_list; 77, for_in_clause; 77, 78; 77, 79; 78, identifier:x; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:key; 82, identifier:split; 83, argument_list; 83, 84; 84, string:','; 85, if_statement; 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:parts; 91, integer:2; 92, block; 92, 93; 93, raise_statement; 93, 94; 94, call; 94, 95; 94, 96; 95, identifier:Exception; 96, argument_list; 96, 97; 97, call; 97, 98; 97, 104; 98, attribute; 98, 99; 98, 103; 99, concatenated_string; 99, 100; 99, 101; 99, 102; 100, string:'--static argument {!r} must have two '; 101, string:'parts (comma separated) when using '; 102, string:'both text and css.'; 103, identifier:format; 104, argument_list; 104, 105; 105, identifier:parts; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:key; 109, identifier:parts; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 115; 112, subscript; 112, 113; 112, 114; 113, identifier:counter; 114, identifier:key; 115, identifier:limit; 116, if_statement; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:verbose; 120, block; 120, 121; 120, 130; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:sys; 126, identifier:stdout; 127, identifier:write; 128, argument_list; 128, 129; 129, string:'Retrieving current flair\n'; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:sys; 135, identifier:stdout; 136, identifier:flush; 137, argument_list; 138, for_statement; 138, 139; 138, 140; 138, 145; 139, identifier:flair; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:current_flair; 144, argument_list; 145, block; 145, 146; 145, 168; 145, 200; 146, if_statement; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:verbose; 150, block; 150, 151; 150, 160; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 158; 153, attribute; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:sys; 156, identifier:stdout; 157, identifier:write; 158, argument_list; 158, 159; 159, string:'.'; 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:sys; 165, identifier:stdout; 166, identifier:flush; 167, argument_list; 168, if_statement; 168, 169; 168, 172; 168, 183; 168, 192; 169, boolean_operator:and; 169, 170; 169, 171; 170, identifier:use_text; 171, identifier:use_css; 172, block; 172, 173; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:key; 176, tuple; 176, 177; 176, 180; 177, subscript; 177, 178; 177, 179; 178, identifier:flair; 179, string:'flair_text'; 180, subscript; 180, 181; 180, 182; 181, identifier:flair; 182, string:'flair_css_class'; 183, elif_clause; 183, 184; 183, 185; 184, identifier:use_text; 185, block; 185, 186; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:key; 189, subscript; 189, 190; 189, 191; 190, identifier:flair; 191, string:'flair_text'; 192, else_clause; 192, 193; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:key; 197, subscript; 197, 198; 197, 199; 198, identifier:flair; 199, string:'flair_css_class'; 200, if_statement; 200, 201; 200, 204; 200, 211; 201, comparison_operator:in; 201, 202; 201, 203; 202, identifier:key; 203, identifier:counter; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, augmented_assignment:+=; 206, 207; 206, 210; 207, subscript; 207, 208; 207, 209; 208, identifier:counter; 209, identifier:key; 210, integer:1; 211, else_clause; 211, 212; 212, block; 212, 213; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 218; 215, subscript; 215, 216; 215, 217; 216, identifier:counter; 217, identifier:key; 218, integer:1; 219, if_statement; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:self; 222, identifier:verbose; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, call; 225, 226; 225, 227; 226, identifier:print; 227, argument_list; 228, if_statement; 228, 229; 228, 232; 228, 244; 229, comparison_operator:==; 229, 230; 229, 231; 230, identifier:sort; 231, string:'alpha'; 232, block; 232, 233; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:items; 236, call; 236, 237; 236, 238; 237, identifier:sorted; 238, argument_list; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:counter; 242, identifier:items; 243, argument_list; 244, else_clause; 244, 245; 245, block; 245, 246; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:items; 249, call; 249, 250; 249, 251; 250, identifier:sorted; 251, argument_list; 251, 252; 251, 257; 251, 265; 252, call; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:counter; 255, identifier:items; 256, argument_list; 257, keyword_argument; 257, 258; 257, 259; 258, identifier:key; 259, lambda; 259, 260; 259, 262; 260, lambda_parameters; 260, 261; 261, identifier:x; 262, subscript; 262, 263; 262, 264; 263, identifier:x; 264, integer:1; 265, keyword_argument; 265, 266; 265, 267; 266, identifier:reverse; 267, True; 268, if_statement; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:self; 271, identifier:verbose; 272, block; 272, 273; 273, expression_statement; 273, 274; 274, call; 274, 275; 274, 276; 275, identifier:print; 276, argument_list; 276, 277; 277, string:'Clearing current flair templates'; 278, expression_statement; 278, 279; 279, call; 279, 280; 279, 289; 280, attribute; 280, 281; 280, 288; 281, attribute; 281, 282; 281, 287; 282, attribute; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:self; 285, identifier:sub; 286, identifier:flair; 287, identifier:templates; 288, identifier:clear; 289, argument_list; 290, for_statement; 290, 291; 290, 294; 290, 295; 291, pattern_list; 291, 292; 291, 293; 292, identifier:key; 293, identifier:count; 294, identifier:items; 295, block; 295, 296; 295, 310; 295, 342; 295, 358; 296, if_statement; 296, 297; 296, 303; 297, boolean_operator:or; 297, 298; 297, 300; 298, not_operator; 298, 299; 299, identifier:key; 300, comparison_operator:<; 300, 301; 300, 302; 301, identifier:count; 302, identifier:limit; 303, block; 303, 304; 303, 309; 304, expression_statement; 304, 305; 305, call; 305, 306; 305, 307; 306, identifier:print; 307, argument_list; 307, 308; 308, string:'a'; 309, continue_statement; 310, if_statement; 310, 311; 310, 314; 310, 321; 310, 332; 311, boolean_operator:and; 311, 312; 311, 313; 312, identifier:use_text; 313, identifier:use_css; 314, block; 314, 315; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 320; 317, pattern_list; 317, 318; 317, 319; 318, identifier:text; 319, identifier:css; 320, identifier:key; 321, elif_clause; 321, 322; 321, 323; 322, identifier:use_text; 323, block; 323, 324; 324, expression_statement; 324, 325; 325, assignment; 325, 326; 325, 329; 326, pattern_list; 326, 327; 326, 328; 327, identifier:text; 328, identifier:css; 329, expression_list; 329, 330; 329, 331; 330, identifier:key; 331, string:''; 332, else_clause; 332, 333; 333, block; 333, 334; 334, expression_statement; 334, 335; 335, assignment; 335, 336; 335, 339; 336, pattern_list; 336, 337; 336, 338; 337, identifier:text; 338, identifier:css; 339, expression_list; 339, 340; 339, 341; 340, string:''; 341, identifier:key; 342, if_statement; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:self; 345, identifier:verbose; 346, block; 346, 347; 347, expression_statement; 347, 348; 348, call; 348, 349; 348, 350; 349, identifier:print; 350, argument_list; 350, 351; 351, call; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, string:'Adding template: text: {!r} css: {!r}'; 354, identifier:format; 355, argument_list; 355, 356; 355, 357; 356, identifier:text; 357, identifier:css; 358, expression_statement; 358, 359; 359, call; 359, 360; 359, 369; 360, attribute; 360, 361; 360, 368; 361, attribute; 361, 362; 361, 367; 362, attribute; 362, 363; 362, 366; 363, attribute; 363, 364; 363, 365; 364, identifier:self; 365, identifier:sub; 366, identifier:flair; 367, identifier:templates; 368, identifier:add; 369, argument_list; 369, 370; 369, 371; 369, 372; 370, identifier:text; 371, identifier:css; 372, identifier:editable | def flair_template_sync(self, editable, limit,
static, sort, use_css, use_text):
if not use_text and not use_css:
raise Exception('At least one of use_text or use_css must be True')
sorts = ('alpha', 'size')
if sort not in sorts:
raise Exception('Sort must be one of: {}'.format(', '.join(sorts)))
counter = {}
if static:
for key in static:
if use_css and use_text:
parts = tuple(x.strip() for x in key.split(','))
if len(parts) != 2:
raise Exception('--static argument {!r} must have two '
'parts (comma separated) when using '
'both text and css.'.format(parts))
key = parts
counter[key] = limit
if self.verbose:
sys.stdout.write('Retrieving current flair\n')
sys.stdout.flush()
for flair in self.current_flair():
if self.verbose:
sys.stdout.write('.')
sys.stdout.flush()
if use_text and use_css:
key = (flair['flair_text'], flair['flair_css_class'])
elif use_text:
key = flair['flair_text']
else:
key = flair['flair_css_class']
if key in counter:
counter[key] += 1
else:
counter[key] = 1
if self.verbose:
print()
if sort == 'alpha':
items = sorted(counter.items())
else:
items = sorted(counter.items(), key=lambda x: x[1], reverse=True)
if self.verbose:
print('Clearing current flair templates')
self.sub.flair.templates.clear()
for key, count in items:
if not key or count < limit:
print('a')
continue
if use_text and use_css:
text, css = key
elif use_text:
text, css = key, ''
else:
text, css = '', key
if self.verbose:
print('Adding template: text: {!r} css: {!r}'
.format(text, css))
self.sub.flair.templates.add(text, css, editable) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:props; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:element; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:mode; 10, string:'all'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:deep; 13, False; 14, block; 14, 15; 14, 17; 14, 28; 14, 35; 14, 52; 14, 71; 14, 128; 14, 184; 14, 213; 14, 222; 14, 244; 14, 256; 14, 266; 14, 346; 15, expression_statement; 15, 16; 16, identifier:r; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:element; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_parse_element; 24, argument_list; 24, 25; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:element; 27, identifier:element; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:allowed_modes; 31, list:['all', 'constants', 'models']; 31, 32; 31, 33; 31, 34; 32, string:'all'; 33, string:'constants'; 34, string:'models'; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:mode; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_parse_mode; 42, argument_list; 42, 43; 42, 46; 42, 49; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:mode; 45, identifier:mode; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:allowed; 48, identifier:allowed_modes; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:single; 51, True; 52, if_statement; 52, 53; 52, 56; 53, comparison_operator:==; 53, 54; 53, 55; 54, identifier:mode; 55, string:'all'; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:vals; 60, call; 60, 61; 60, 62; 61, identifier:set; 62, argument_list; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:keys; 67, argument_list; 67, 68; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:mode; 70, string:'props'; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:==; 72, 73; 72, 74; 73, identifier:mode; 74, string:'constants'; 75, block; 75, 76; 76, if_statement; 76, 77; 76, 82; 76, 112; 77, call; 77, 78; 77, 79; 78, identifier:hasattr; 79, argument_list; 79, 80; 79, 81; 80, identifier:self; 81, string:'models'; 82, block; 82, 83; 82, 97; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:temp; 86, call; 86, 87; 86, 88; 87, identifier:set; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:keys; 93, argument_list; 93, 94; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:mode; 96, string:'props'; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:vals; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:temp; 103, identifier:difference; 104, argument_list; 104, 105; 105, call; 105, 106; 105, 111; 106, attribute; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:models; 110, identifier:keys; 111, argument_list; 112, else_clause; 112, 113; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:vals; 117, call; 117, 118; 117, 119; 118, identifier:set; 119, argument_list; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:keys; 124, argument_list; 124, 125; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:mode; 127, string:'props'; 128, if_statement; 128, 129; 128, 132; 129, comparison_operator:==; 129, 130; 129, 131; 130, identifier:mode; 131, string:'models'; 132, block; 132, 133; 133, if_statement; 133, 134; 133, 139; 133, 169; 134, call; 134, 135; 134, 136; 135, identifier:hasattr; 136, argument_list; 136, 137; 136, 138; 137, identifier:self; 138, string:'models'; 139, block; 139, 140; 139, 154; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:temp; 143, call; 143, 144; 143, 145; 144, identifier:set; 145, argument_list; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:keys; 150, argument_list; 150, 151; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:mode; 153, string:'props'; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:vals; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:temp; 160, identifier:intersection; 161, argument_list; 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:models; 167, identifier:keys; 168, argument_list; 169, else_clause; 169, 170; 170, block; 170, 171; 170, 178; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:logger; 175, identifier:warning; 176, argument_list; 176, 177; 177, string:'Object does not have a models attribute'; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:vals; 181, call; 181, 182; 181, 183; 182, identifier:set; 183, argument_list; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:hide; 187, call; 187, 188; 187, 189; 188, identifier:set; 189, argument_list; 189, 190; 190, list_comprehension; 190, 191; 190, 192; 190, 199; 191, identifier:i; 192, for_in_clause; 192, 193; 192, 194; 193, identifier:i; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:self; 197, identifier:keys; 198, argument_list; 199, if_clause; 199, 200; 200, call; 200, 201; 200, 211; 201, attribute; 201, 202; 201, 210; 202, subscript; 202, 203; 202, 209; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:i; 206, identifier:split; 207, argument_list; 207, 208; 208, string:'.'; 209, integer:1; 210, identifier:startswith; 211, argument_list; 211, 212; 212, string:'_'; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:vals; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:vals; 219, identifier:difference; 220, argument_list; 220, 221; 221, identifier:hide; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:temp; 225, call; 225, 226; 225, 227; 226, identifier:set; 227, argument_list; 227, 228; 228, list_comprehension; 228, 229; 228, 230; 228, 233; 229, identifier:i; 230, for_in_clause; 230, 231; 230, 232; 231, identifier:i; 232, identifier:vals; 233, if_clause; 233, 234; 234, comparison_operator:not; 234, 235; 234, 243; 235, subscript; 235, 236; 235, 242; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:i; 239, identifier:split; 240, argument_list; 240, 241; 241, string:'.'; 242, integer:0; 243, identifier:element; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 247; 246, identifier:vals; 247, call; 247, 248; 247, 254; 248, attribute; 248, 249; 248, 253; 249, call; 249, 250; 249, 251; 250, identifier:set; 251, argument_list; 251, 252; 252, identifier:vals; 253, identifier:difference; 254, argument_list; 254, 255; 255, identifier:temp; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 258, identifier:vals; 259, call; 259, 260; 259, 261; 260, identifier:PrintableList; 261, argument_list; 261, 262; 262, call; 262, 263; 262, 264; 263, identifier:list; 264, argument_list; 264, 265; 265, identifier:vals; 266, if_statement; 266, 267; 266, 268; 267, identifier:deep; 268, block; 268, 269; 268, 307; 269, if_statement; 269, 270; 269, 276; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:self; 273, identifier:_isa; 274, argument_list; 274, 275; 275, string:'phase'; 276, block; 276, 277; 277, for_statement; 277, 278; 277, 279; 277, 289; 278, identifier:item; 279, call; 279, 280; 279, 285; 280, attribute; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:self; 283, identifier:project; 284, identifier:find_physics; 285, argument_list; 285, 286; 286, keyword_argument; 286, 287; 286, 288; 287, identifier:phase; 288, identifier:self; 289, block; 289, 290; 290, expression_statement; 290, 291; 291, augmented_assignment:+=; 291, 292; 291, 293; 292, identifier:vals; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:item; 296, identifier:props; 297, argument_list; 297, 298; 297, 301; 297, 304; 298, keyword_argument; 298, 299; 298, 300; 299, identifier:element; 300, identifier:element; 301, keyword_argument; 301, 302; 301, 303; 302, identifier:mode; 303, identifier:mode; 304, keyword_argument; 304, 305; 304, 306; 305, identifier:deep; 306, False; 307, if_statement; 307, 308; 307, 314; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:self; 311, identifier:_isa; 312, argument_list; 312, 313; 313, string:'network'; 314, block; 314, 315; 315, for_statement; 315, 316; 315, 317; 315, 328; 316, identifier:item; 317, call; 317, 318; 317, 327; 318, attribute; 318, 319; 318, 326; 319, call; 319, 320; 319, 325; 320, attribute; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:self; 323, identifier:project; 324, identifier:geometries; 325, argument_list; 326, identifier:values; 327, argument_list; 328, block; 328, 329; 329, expression_statement; 329, 330; 330, augmented_assignment:+=; 330, 331; 330, 332; 331, identifier:vals; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:item; 335, identifier:props; 336, argument_list; 336, 337; 336, 340; 336, 343; 337, keyword_argument; 337, 338; 337, 339; 338, identifier:element; 339, identifier:element; 340, keyword_argument; 340, 341; 340, 342; 341, identifier:mode; 342, identifier:mode; 343, keyword_argument; 343, 344; 343, 345; 344, identifier:deep; 345, False; 346, return_statement; 346, 347; 347, identifier:vals | def props(self, element=None, mode='all', deep=False):
r
element = self._parse_element(element=element)
allowed_modes = ['all', 'constants', 'models']
mode = self._parse_mode(mode=mode, allowed=allowed_modes, single=True)
if mode == 'all':
vals = set(self.keys(mode='props'))
if mode == 'constants':
if hasattr(self, 'models'):
temp = set(self.keys(mode='props'))
vals = temp.difference(self.models.keys())
else:
vals = set(self.keys(mode='props'))
if mode == 'models':
if hasattr(self, 'models'):
temp = set(self.keys(mode='props'))
vals = temp.intersection(self.models.keys())
else:
logger.warning('Object does not have a models attribute')
vals = set()
hide = set([i for i in self.keys() if i.split('.')[1].startswith('_')])
vals = vals.difference(hide)
temp = set([i for i in vals if i.split('.')[0] not in element])
vals = set(vals).difference(temp)
vals = PrintableList(list(vals))
if deep:
if self._isa('phase'):
for item in self.project.find_physics(phase=self):
vals += item.props(element=element, mode=mode, deep=False)
if self._isa('network'):
for item in self.project.geometries().values():
vals += item.props(element=element, mode=mode, deep=False)
return vals |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:set_residual; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:pores; 7, list:[]; 8, default_parameter; 8, 9; 8, 10; 9, identifier:overwrite; 10, False; 11, block; 11, 12; 11, 14; 11, 23; 11, 32; 11, 40; 11, 46; 11, 54; 11, 60; 11, 70; 11, 84; 11, 95; 11, 298; 11, 312; 12, expression_statement; 12, 13; 13, identifier:r; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:Ps; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_parse_indices; 21, argument_list; 21, 22; 22, identifier:pores; 23, if_statement; 23, 24; 23, 25; 24, identifier:overwrite; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 31; 28, subscript; 28, 29; 28, 30; 29, identifier:self; 30, string:'pore.residual'; 31, False; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 39; 34, subscript; 34, 35; 34, 38; 35, subscript; 35, 36; 35, 37; 36, identifier:self; 37, string:'pore.residual'; 38, identifier:Ps; 39, True; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:residual; 43, subscript; 43, 44; 43, 45; 44, identifier:self; 45, string:'pore.residual'; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:net; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:project; 53, identifier:network; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:conns; 57, subscript; 57, 58; 57, 59; 58, identifier:net; 59, string:'throat.conns'; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:rclusters; 63, attribute; 63, 64; 63, 69; 64, call; 64, 65; 64, 66; 65, identifier:site_percolation; 66, argument_list; 66, 67; 66, 68; 67, identifier:conns; 68, identifier:residual; 69, identifier:sites; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:rcluster_ids; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:np; 76, identifier:unique; 77, argument_list; 77, 78; 78, subscript; 78, 79; 78, 80; 79, identifier:rclusters; 80, comparison_operator:>; 80, 81; 80, 82; 81, identifier:rclusters; 82, unary_operator:-; 82, 83; 83, integer:1; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:initial_num; 87, binary_operator:-; 87, 88; 87, 94; 88, call; 88, 89; 88, 90; 89, identifier:len; 90, argument_list; 90, 91; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:queue; 94, integer:1; 95, for_statement; 95, 96; 95, 97; 95, 98; 96, identifier:rcluster_id; 97, identifier:rcluster_ids; 98, block; 98, 99; 98, 105; 98, 118; 98, 127; 98, 161; 98, 169; 98, 177; 98, 194; 98, 202; 98, 210; 98, 218; 98, 229; 98, 240; 98, 257; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:rPs; 102, comparison_operator:==; 102, 103; 102, 104; 103, identifier:rclusters; 104, identifier:rcluster_id; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:existing; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:np; 111, identifier:unique; 112, argument_list; 112, 113; 113, subscript; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:self; 116, string:'pore.cluster'; 117, identifier:rPs; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:existing; 121, subscript; 121, 122; 121, 123; 122, identifier:existing; 123, comparison_operator:>; 123, 124; 123, 125; 124, identifier:existing; 125, unary_operator:-; 125, 126; 126, integer:1; 127, if_statement; 127, 128; 127, 134; 127, 141; 128, comparison_operator:>; 128, 129; 128, 133; 129, call; 129, 130; 129, 131; 130, identifier:len; 131, argument_list; 131, 132; 132, identifier:existing; 133, integer:0; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:cluster_num; 138, subscript; 138, 139; 138, 140; 139, identifier:existing; 140, integer:0; 141, else_clause; 141, 142; 142, block; 142, 143; 142, 152; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:cluster_num; 146, call; 146, 147; 146, 148; 147, identifier:len; 148, argument_list; 148, 149; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:queue; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:queue; 158, identifier:append; 159, argument_list; 159, 160; 160, list:[]; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:queue; 164, subscript; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:self; 167, identifier:queue; 168, identifier:cluster_num; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 176; 171, subscript; 171, 172; 171, 175; 172, subscript; 172, 173; 172, 174; 173, identifier:self; 174, string:'pore.cluster'; 175, identifier:rPs; 176, identifier:cluster_num; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:Ts; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:net; 183, identifier:find_neighbor_throats; 184, argument_list; 184, 185; 184, 188; 184, 191; 185, keyword_argument; 185, 186; 185, 187; 186, identifier:pores; 187, identifier:rPs; 188, keyword_argument; 188, 189; 188, 190; 189, identifier:flatten; 190, True; 191, keyword_argument; 191, 192; 191, 193; 192, identifier:mode; 193, string:'xnor'; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 201; 196, subscript; 196, 197; 196, 200; 197, subscript; 197, 198; 197, 199; 198, identifier:self; 199, string:'throat.cluster'; 200, identifier:Ts; 201, identifier:cluster_num; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 209; 204, subscript; 204, 205; 204, 208; 205, subscript; 205, 206; 205, 207; 206, identifier:self; 207, string:'pore.invasion_sequence'; 208, identifier:rPs; 209, integer:0; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 217; 212, subscript; 212, 213; 212, 216; 213, subscript; 213, 214; 213, 215; 214, identifier:self; 215, string:'throat.invasion_sequence'; 216, identifier:Ts; 217, integer:0; 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:self; 223, string:'pore.invasion_pressure'; 224, identifier:rPs; 225, unary_operator:-; 225, 226; 226, attribute; 226, 227; 226, 228; 227, identifier:np; 228, identifier:inf; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 236; 231, subscript; 231, 232; 231, 235; 232, subscript; 232, 233; 232, 234; 233, identifier:self; 234, string:'throat.invasion_pressure'; 235, identifier:Ts; 236, unary_operator:-; 236, 237; 237, attribute; 237, 238; 237, 239; 238, identifier:np; 239, identifier:inf; 240, expression_statement; 240, 241; 241, assignment; 241, 242; 241, 243; 242, identifier:Ts; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:net; 246, identifier:find_neighbor_throats; 247, argument_list; 247, 248; 247, 251; 247, 254; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:pores; 250, identifier:rPs; 251, keyword_argument; 251, 252; 251, 253; 252, identifier:flatten; 253, True; 254, keyword_argument; 254, 255; 254, 256; 255, identifier:mode; 256, string:'exclusive_or'; 257, for_statement; 257, 258; 257, 259; 257, 260; 258, identifier:T; 259, identifier:Ts; 260, block; 260, 261; 260, 265; 260, 276; 260, 283; 260, 290; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:data; 264, list:[]; 265, expression_statement; 265, 266; 266, call; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:data; 269, identifier:append; 270, argument_list; 270, 271; 271, subscript; 271, 272; 271, 275; 272, subscript; 272, 273; 272, 274; 273, identifier:self; 274, string:'throat.entry_pressure'; 275, identifier:T; 276, expression_statement; 276, 277; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:data; 280, identifier:append; 281, argument_list; 281, 282; 282, identifier:T; 283, expression_statement; 283, 284; 284, call; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:data; 287, identifier:append; 288, argument_list; 288, 289; 289, string:'throat'; 290, expression_statement; 290, 291; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:hq; 294, identifier:heappush; 295, argument_list; 295, 296; 295, 297; 296, identifier:queue; 297, identifier:data; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:self; 302, identifier:invasion_running; 303, binary_operator:*; 303, 304; 303, 306; 304, list:[True]; 304, 305; 305, True; 306, call; 306, 307; 306, 308; 307, identifier:len; 308, argument_list; 308, 309; 309, attribute; 309, 310; 309, 311; 310, identifier:self; 311, identifier:queue; 312, for_statement; 312, 313; 312, 314; 312, 323; 313, identifier:c_num; 314, call; 314, 315; 314, 316; 315, identifier:range; 316, argument_list; 316, 317; 317, call; 317, 318; 317, 319; 318, identifier:len; 319, argument_list; 319, 320; 320, attribute; 320, 321; 320, 322; 321, identifier:self; 322, identifier:queue; 323, block; 323, 324; 324, if_statement; 324, 325; 324, 328; 325, comparison_operator:>; 325, 326; 325, 327; 326, identifier:c_num; 327, identifier:initial_num; 328, block; 328, 329; 329, expression_statement; 329, 330; 330, assignment; 330, 331; 330, 336; 331, subscript; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:self; 334, identifier:invasion_running; 335, identifier:c_num; 336, False | def set_residual(self, pores=[], overwrite=False):
r
Ps = self._parse_indices(pores)
if overwrite:
self['pore.residual'] = False
self['pore.residual'][Ps] = True
residual = self['pore.residual']
net = self.project.network
conns = net['throat.conns']
rclusters = site_percolation(conns, residual).sites
rcluster_ids = np.unique(rclusters[rclusters > -1])
initial_num = len(self.queue)-1
for rcluster_id in rcluster_ids:
rPs = rclusters == rcluster_id
existing = np.unique(self['pore.cluster'][rPs])
existing = existing[existing > -1]
if len(existing) > 0:
cluster_num = existing[0]
else:
cluster_num = len(self.queue)
self.queue.append([])
queue = self.queue[cluster_num]
self['pore.cluster'][rPs] = cluster_num
Ts = net.find_neighbor_throats(pores=rPs,
flatten=True,
mode='xnor')
self['throat.cluster'][Ts] = cluster_num
self['pore.invasion_sequence'][rPs] = 0
self['throat.invasion_sequence'][Ts] = 0
self['pore.invasion_pressure'][rPs] = -np.inf
self['throat.invasion_pressure'][Ts] = -np.inf
Ts = net.find_neighbor_throats(pores=rPs,
flatten=True,
mode='exclusive_or')
for T in Ts:
data = []
data.append(self['throat.entry_pressure'][T])
data.append(T)
data.append('throat')
hq.heappush(queue, data)
self.invasion_running = [True]*len(self.queue)
for c_num in range(len(self.queue)):
if c_num > initial_num:
self.invasion_running[c_num] = False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:results; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:Pc; 6, block; 6, 7; 6, 9; 6, 17; 6, 25; 6, 29; 6, 43; 6, 57; 7, expression_statement; 7, 8; 8, identifier:r; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:Psatn; 12, comparison_operator:<=; 12, 13; 12, 16; 13, subscript; 13, 14; 13, 15; 14, identifier:self; 15, string:'pore.invasion_pressure'; 16, identifier:Pc; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:Tsatn; 20, comparison_operator:<=; 20, 21; 20, 24; 21, subscript; 21, 22; 21, 23; 22, identifier:self; 23, string:'throat.invasion_pressure'; 24, identifier:Pc; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:inv_phase; 28, dictionary; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, subscript; 31, 32; 31, 33; 32, identifier:inv_phase; 33, string:'pore.occupancy'; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:sp; 37, identifier:array; 38, argument_list; 38, 39; 38, 40; 39, identifier:Psatn; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:dtype; 42, identifier:float; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:inv_phase; 47, string:'throat.occupancy'; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:sp; 51, identifier:array; 52, argument_list; 52, 53; 52, 54; 53, identifier:Tsatn; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:dtype; 56, identifier:float; 57, return_statement; 57, 58; 58, identifier:inv_phase | def results(self, Pc):
r
Psatn = self['pore.invasion_pressure'] <= Pc
Tsatn = self['throat.invasion_pressure'] <= Pc
inv_phase = {}
inv_phase['pore.occupancy'] = sp.array(Psatn, dtype=float)
inv_phase['throat.occupancy'] = sp.array(Tsatn, dtype=float)
return inv_phase |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:folderitems; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 15; 5, 22; 5, 35; 5, 42; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:items; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:BaseView; 12, identifier:folderitems; 13, argument_list; 13, 14; 14, identifier:self; 15, expression_statement; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:fill_empty_slots; 20, argument_list; 20, 21; 21, identifier:items; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:items; 25, call; 25, 26; 25, 27; 26, identifier:sorted; 27, argument_list; 27, 28; 27, 29; 28, identifier:items; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:key; 31, call; 31, 32; 31, 33; 32, identifier:itemgetter; 33, argument_list; 33, 34; 34, string:"pos_sortkey"; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:fill_slots_headers; 40, argument_list; 40, 41; 41, identifier:items; 42, return_statement; 42, 43; 43, identifier:items | def folderitems(self):
items = BaseView.folderitems(self)
self.fill_empty_slots(items)
items = sorted(items, key=itemgetter("pos_sortkey"))
self.fill_slots_headers(items)
return items |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:resort_client_actions; 3, parameters; 3, 4; 4, identifier:portal; 5, block; 5, 6; 5, 21; 5, 32; 5, 49; 5, 66; 5, 86; 5, 96; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:sorted_actions; 9, list:[
"edit",
"contacts",
"view",
"analysisrequests",
"batches",
"samplepoints",
"profiles",
"templates",
"specs",
"orders",
"reports_listing"
]; 9, 10; 9, 11; 9, 12; 9, 13; 9, 14; 9, 15; 9, 16; 9, 17; 9, 18; 9, 19; 9, 20; 10, string:"edit"; 11, string:"contacts"; 12, string:"view"; 13, string:"analysisrequests"; 14, string:"batches"; 15, string:"samplepoints"; 16, string:"profiles"; 17, string:"templates"; 18, string:"specs"; 19, string:"orders"; 20, string:"reports_listing"; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:type_info; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:portal; 28, identifier:portal_types; 29, identifier:getTypeInfo; 30, argument_list; 30, 31; 31, string:"Client"; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:actions; 35, call; 35, 36; 35, 37; 36, identifier:filter; 37, argument_list; 37, 38; 37, 46; 38, lambda; 38, 39; 38, 41; 39, lambda_parameters; 39, 40; 40, identifier:act; 41, comparison_operator:in; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:act; 44, identifier:id; 45, identifier:sorted_actions; 46, attribute; 46, 47; 46, 48; 47, identifier:type_info; 48, identifier:_actions; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:missing; 52, call; 52, 53; 52, 54; 53, identifier:filter; 54, argument_list; 54, 55; 54, 63; 55, lambda; 55, 56; 55, 58; 56, lambda_parameters; 56, 57; 57, identifier:act; 58, comparison_operator:not; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:act; 61, identifier:id; 62, identifier:sorted_actions; 63, attribute; 63, 64; 63, 65; 64, identifier:type_info; 65, identifier:_actions; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:actions; 69, call; 69, 70; 69, 71; 70, identifier:sorted; 71, argument_list; 71, 72; 71, 73; 72, identifier:actions; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:key; 75, lambda; 75, 76; 75, 78; 76, lambda_parameters; 76, 77; 77, identifier:act; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:sorted_actions; 81, identifier:index; 82, argument_list; 82, 83; 83, attribute; 83, 84; 83, 85; 84, identifier:act; 85, identifier:id; 86, if_statement; 86, 87; 86, 88; 87, identifier:missing; 88, block; 88, 89; 89, expression_statement; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:actions; 93, identifier:extend; 94, argument_list; 94, 95; 95, identifier:missing; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:type_info; 100, identifier:_actions; 101, identifier:actions | def resort_client_actions(portal):
sorted_actions = [
"edit",
"contacts",
"view",
"analysisrequests",
"batches",
"samplepoints",
"profiles",
"templates",
"specs",
"orders",
"reports_listing"
]
type_info = portal.portal_types.getTypeInfo("Client")
actions = filter(lambda act: act.id in sorted_actions, type_info._actions)
missing = filter(lambda act: act.id not in sorted_actions, type_info._actions)
actions = sorted(actions, key=lambda act: sorted_actions.index(act.id))
if missing:
actions.extend(missing)
type_info._actions = actions |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:reindex_sortable_title; 3, parameters; 3, 4; 4, identifier:portal; 5, block; 5, 6; 5, 13; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:catalogs; 9, list:[
"bika_catalog",
"bika_setup_catalog",
"portal_catalog",
]; 9, 10; 9, 11; 9, 12; 10, string:"bika_catalog"; 11, string:"bika_setup_catalog"; 12, string:"portal_catalog"; 13, for_statement; 13, 14; 13, 15; 13, 16; 14, identifier:catalog_name; 15, identifier:catalogs; 16, block; 16, 17; 16, 29; 16, 38; 16, 47; 16, 58; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:logger; 21, identifier:info; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, string:"Reindexing sortable_title for {} ..."; 26, identifier:format; 27, argument_list; 27, 28; 28, identifier:catalog_name; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:handler; 32, call; 32, 33; 32, 34; 33, identifier:ZLogHandler; 34, argument_list; 34, 35; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:steps; 37, integer:100; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:catalog; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:api; 44, identifier:get_tool; 45, argument_list; 45, 46; 46, identifier:catalog_name; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:catalog; 51, identifier:reindexIndex; 52, argument_list; 52, 53; 52, 54; 52, 55; 53, string:"sortable_title"; 54, None; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:pghandler; 57, identifier:handler; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:commit_transaction; 61, argument_list; 61, 62; 62, identifier:portal | def reindex_sortable_title(portal):
catalogs = [
"bika_catalog",
"bika_setup_catalog",
"portal_catalog",
]
for catalog_name in catalogs:
logger.info("Reindexing sortable_title for {} ...".format(catalog_name))
handler = ZLogHandler(steps=100)
catalog = api.get_tool(catalog_name)
catalog.reindexIndex("sortable_title", None, pghandler=handler)
commit_transaction(portal) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:folderitems; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:full_objects; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:classic; 10, True; 11, block; 11, 12; 11, 22; 11, 36; 11, 65; 11, 77; 11, 120; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:bsc; 15, call; 15, 16; 15, 17; 16, identifier:getToolByName; 17, argument_list; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:context; 21, string:"bika_setup_catalog"; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:an_cats; 27, call; 27, 28; 27, 29; 28, identifier:bsc; 29, argument_list; 29, 30; 29, 33; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:portal_type; 32, string:"AnalysisCategory"; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:sort_on; 35, string:"sortable_title"; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:an_cats_order; 41, call; 41, 42; 41, 43; 42, identifier:dict; 43, argument_list; 43, 44; 44, list_comprehension; 44, 45; 44, 55; 45, tuple; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:b; 48, identifier:Title; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, string:"{:04}"; 52, identifier:format; 53, argument_list; 53, 54; 54, identifier:a; 55, for_in_clause; 55, 56; 55, 59; 56, pattern_list; 56, 57; 56, 58; 57, identifier:a; 58, identifier:b; 59, call; 59, 60; 59, 61; 60, identifier:enumerate; 61, argument_list; 61, 62; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:an_cats; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:items; 68, call; 68, 69; 68, 76; 69, attribute; 69, 70; 69, 75; 70, call; 70, 71; 70, 72; 71, identifier:super; 72, argument_list; 72, 73; 72, 74; 73, identifier:AnalysisServicesView; 74, identifier:self; 75, identifier:folderitems; 76, argument_list; 77, if_statement; 77, 78; 77, 81; 77, 110; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:do_cats; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:categories; 87, call; 87, 88; 87, 89; 88, identifier:map; 89, argument_list; 89, 90; 89, 96; 90, lambda; 90, 91; 90, 93; 91, lambda_parameters; 91, 92; 92, identifier:x; 93, subscript; 93, 94; 93, 95; 94, identifier:x; 95, integer:0; 96, call; 96, 97; 96, 98; 97, identifier:sorted; 98, argument_list; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:categories; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:key; 104, lambda; 104, 105; 104, 107; 105, lambda_parameters; 105, 106; 106, identifier:x; 107, subscript; 107, 108; 107, 109; 108, identifier:x; 109, integer:1; 110, else_clause; 110, 111; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 119; 114, attribute; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:categories; 118, identifier:sort; 119, argument_list; 120, return_statement; 120, 121; 121, identifier:items | def folderitems(self, full_objects=False, classic=True):
bsc = getToolByName(self.context, "bika_setup_catalog")
self.an_cats = bsc(
portal_type="AnalysisCategory",
sort_on="sortable_title")
self.an_cats_order = dict([
(b.Title, "{:04}".format(a))
for a, b in enumerate(self.an_cats)])
items = super(AnalysisServicesView, self).folderitems()
if self.do_cats:
self.categories = map(lambda x: x[0],
sorted(self.categories, key=lambda x: x[1]))
else:
self.categories.sort()
return items |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:to_display_list; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:pairs; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort_by; 7, string:"key"; 8, default_parameter; 8, 9; 8, 10; 9, identifier:allow_empty; 10, True; 11, block; 11, 12; 11, 18; 11, 31; 11, 68; 11, 79; 11, 105; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:dl; 15, call; 15, 16; 15, 17; 16, identifier:DisplayList; 17, argument_list; 18, if_statement; 18, 19; 18, 24; 19, call; 19, 20; 19, 21; 20, identifier:isinstance; 21, argument_list; 21, 22; 21, 23; 22, identifier:pairs; 23, identifier:basestring; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:pairs; 28, list:[pairs, pairs]; 28, 29; 28, 30; 29, identifier:pairs; 30, identifier:pairs; 31, for_statement; 31, 32; 31, 33; 31, 34; 32, identifier:pair; 33, identifier:pairs; 34, block; 34, 35; 34, 52; 35, if_statement; 35, 36; 35, 43; 36, call; 36, 37; 36, 38; 37, identifier:isinstance; 38, argument_list; 38, 39; 38, 40; 39, identifier:pair; 40, tuple; 40, 41; 40, 42; 41, identifier:tuple; 42, identifier:list; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:dl; 48, identifier:add; 49, argument_list; 49, 50; 50, list_splat; 50, 51; 51, identifier:pair; 52, if_statement; 52, 53; 52, 58; 53, call; 53, 54; 53, 55; 54, identifier:isinstance; 55, argument_list; 55, 56; 55, 57; 56, identifier:pair; 57, identifier:basestring; 58, block; 58, 59; 58, 67; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:dl; 63, identifier:add; 64, argument_list; 64, 65; 65, list_splat; 65, 66; 66, identifier:pairs; 67, break_statement; 68, if_statement; 68, 69; 68, 70; 69, identifier:allow_empty; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:dl; 75, identifier:add; 76, argument_list; 76, 77; 76, 78; 77, string:""; 78, string:""; 79, if_statement; 79, 80; 79, 83; 79, 92; 80, comparison_operator:==; 80, 81; 80, 82; 81, identifier:sort_by; 82, string:"key"; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:dl; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:dl; 90, identifier:sortedByKey; 91, argument_list; 92, elif_clause; 92, 93; 92, 96; 93, comparison_operator:==; 93, 94; 93, 95; 94, identifier:sort_by; 95, string:"value"; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:dl; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:dl; 103, identifier:sortedByValue; 104, argument_list; 105, return_statement; 105, 106; 106, identifier:dl | def to_display_list(pairs, sort_by="key", allow_empty=True):
dl = DisplayList()
if isinstance(pairs, basestring):
pairs = [pairs, pairs]
for pair in pairs:
if isinstance(pair, (tuple, list)):
dl.add(*pair)
if isinstance(pair, basestring):
dl.add(*pairs)
break
if allow_empty:
dl.add("", "")
if sort_by == "key":
dl = dl.sortedByKey()
elif sort_by == "value":
dl = dl.sortedByValue()
return dl |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sortable_title; 3, parameters; 3, 4; 4, identifier:instance; 5, block; 5, 6; 5, 13; 5, 25; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:title; 9, call; 9, 10; 9, 11; 10, identifier:plone_sortable_title; 11, argument_list; 11, 12; 12, identifier:instance; 13, if_statement; 13, 14; 13, 18; 14, call; 14, 15; 14, 16; 15, identifier:safe_callable; 16, argument_list; 16, 17; 17, identifier:title; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:title; 22, call; 22, 23; 22, 24; 23, identifier:title; 24, argument_list; 25, return_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:title; 29, identifier:lower; 30, argument_list | def sortable_title(instance):
title = plone_sortable_title(instance)
if safe_callable(title):
title = title()
return title.lower() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sortable_sortkey_title; 3, parameters; 3, 4; 4, identifier:instance; 5, block; 5, 6; 5, 13; 5, 25; 5, 33; 5, 42; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:title; 9, call; 9, 10; 9, 11; 10, identifier:sortable_title; 11, argument_list; 11, 12; 12, identifier:instance; 13, if_statement; 13, 14; 13, 18; 14, call; 14, 15; 14, 16; 15, identifier:safe_callable; 16, argument_list; 16, 17; 17, identifier:title; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:title; 22, call; 22, 23; 22, 24; 23, identifier:title; 24, argument_list; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:sort_key; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:instance; 31, identifier:getSortKey; 32, argument_list; 33, if_statement; 33, 34; 33, 37; 34, comparison_operator:is; 34, 35; 34, 36; 35, identifier:sort_key; 36, None; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:sort_key; 41, integer:999999; 42, return_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, string:"{:010.3f}{}"; 46, identifier:format; 47, argument_list; 47, 48; 47, 49; 48, identifier:sort_key; 49, identifier:title | def sortable_sortkey_title(instance):
title = sortable_title(instance)
if safe_callable(title):
title = title()
sort_key = instance.getSortKey()
if sort_key is None:
sort_key = 999999
return "{:010.3f}{}".format(sort_key, title) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sorted_analyses; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:analyses; 6, block; 6, 7; 6, 24; 6, 44; 6, 48; 6, 52; 6, 56; 6, 105; 6, 112; 6, 119; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:analyses; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, argument_list; 12, 13; 12, 14; 13, identifier:analyses; 14, keyword_argument; 14, 15; 14, 16; 15, identifier:key; 16, lambda; 16, 17; 16, 19; 17, lambda_parameters; 17, 18; 18, identifier:an; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:an; 22, identifier:getRequestID; 23, argument_list; 24, function_definition; 24, 25; 24, 26; 24, 28; 25, function_name:sorted_by_sortkey; 26, parameters; 26, 27; 27, identifier:objs; 28, block; 28, 29; 29, return_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:sorted; 32, argument_list; 32, 33; 32, 34; 33, identifier:objs; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:key; 36, lambda; 36, 37; 36, 39; 37, lambda_parameters; 37, 38; 38, identifier:an; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:an; 42, identifier:getPrioritySortkey; 43, argument_list; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:current_sample_id; 47, None; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:current_analyses; 51, list:[]; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:sorted_analyses; 55, list:[]; 56, for_statement; 56, 57; 56, 58; 56, 59; 57, identifier:analysis; 58, identifier:analyses; 59, block; 59, 60; 59, 68; 59, 97; 59, 104; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:sample_id; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:analysis; 66, identifier:getRequestID; 67, argument_list; 68, if_statement; 68, 69; 68, 74; 69, boolean_operator:and; 69, 70; 69, 71; 70, identifier:sample_id; 71, comparison_operator:!=; 71, 72; 71, 73; 72, identifier:current_sample_id; 73, identifier:sample_id; 74, block; 74, 75; 74, 82; 74, 89; 74, 93; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:current_analyses; 78, call; 78, 79; 78, 80; 79, identifier:sorted_by_sortkey; 80, argument_list; 80, 81; 81, identifier:current_analyses; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:sorted_analyses; 86, identifier:extend; 87, argument_list; 87, 88; 88, identifier:current_analyses; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:current_sample_id; 92, identifier:sample_id; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:current_analyses; 96, list:[]; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:current_analyses; 101, identifier:append; 102, argument_list; 102, 103; 103, identifier:analysis; 104, continue_statement; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:current_analyses; 108, call; 108, 109; 108, 110; 109, identifier:sorted_by_sortkey; 110, argument_list; 110, 111; 111, identifier:current_analyses; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:sorted_analyses; 116, identifier:extend; 117, argument_list; 117, 118; 118, identifier:current_analyses; 119, return_statement; 119, 120; 120, identifier:sorted_analyses | def sorted_analyses(self, analyses):
analyses = sorted(analyses, key=lambda an: an.getRequestID())
def sorted_by_sortkey(objs):
return sorted(objs, key=lambda an: an.getPrioritySortkey())
current_sample_id = None
current_analyses = []
sorted_analyses = []
for analysis in analyses:
sample_id = analysis.getRequestID()
if sample_id and current_sample_id != sample_id:
current_analyses = sorted_by_sortkey(current_analyses)
sorted_analyses.extend(current_analyses)
current_sample_id = sample_id
current_analyses = []
current_analyses.append(analysis)
continue
current_analyses = sorted_by_sortkey(current_analyses)
sorted_analyses.extend(current_analyses)
return sorted_analyses |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_sorted_attachments; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 13; 5, 21; 5, 29; 5, 93; 5, 103; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:inf; 9, call; 9, 10; 9, 11; 10, identifier:float; 11, argument_list; 11, 12; 12, string:"inf"; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:order; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:get_attachments_order; 20, argument_list; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:attachments; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:get_attachments; 28, argument_list; 29, function_definition; 29, 30; 29, 31; 29, 34; 30, function_name:att_cmp; 31, parameters; 31, 32; 31, 33; 32, identifier:att1; 33, identifier:att2; 34, block; 34, 35; 34, 44; 34, 53; 34, 70; 34, 87; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:_n1; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:att1; 41, identifier:get; 42, argument_list; 42, 43; 43, string:'UID'; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:_n2; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:att2; 50, identifier:get; 51, argument_list; 51, 52; 52, string:'UID'; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:_i1; 56, boolean_operator:or; 56, 57; 56, 69; 57, boolean_operator:and; 57, 58; 57, 61; 58, comparison_operator:in; 58, 59; 58, 60; 59, identifier:_n1; 60, identifier:order; 61, binary_operator:+; 61, 62; 61, 68; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:order; 65, identifier:index; 66, argument_list; 66, 67; 67, identifier:_n1; 68, integer:1; 69, identifier:inf; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:_i2; 73, boolean_operator:or; 73, 74; 73, 86; 74, boolean_operator:and; 74, 75; 74, 78; 75, comparison_operator:in; 75, 76; 75, 77; 76, identifier:_n2; 77, identifier:order; 78, binary_operator:+; 78, 79; 78, 85; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:order; 82, identifier:index; 83, argument_list; 83, 84; 84, identifier:_n2; 85, integer:1; 86, identifier:inf; 87, return_statement; 87, 88; 88, call; 88, 89; 88, 90; 89, identifier:cmp; 90, argument_list; 90, 91; 90, 92; 91, identifier:_i1; 92, identifier:_i2; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:sorted_attachments; 96, call; 96, 97; 96, 98; 97, identifier:sorted; 98, argument_list; 98, 99; 98, 100; 99, identifier:attachments; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:cmp; 102, identifier:att_cmp; 103, return_statement; 103, 104; 104, identifier:sorted_attachments | def get_sorted_attachments(self):
inf = float("inf")
order = self.get_attachments_order()
attachments = self.get_attachments()
def att_cmp(att1, att2):
_n1 = att1.get('UID')
_n2 = att2.get('UID')
_i1 = _n1 in order and order.index(_n1) + 1 or inf
_i2 = _n2 in order and order.index(_n2) + 1 or inf
return cmp(_i1, _i2)
sorted_attachments = sorted(attachments, cmp=att_cmp)
return sorted_attachments |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_analyses_at; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:slot; 6, block; 6, 7; 6, 14; 6, 23; 6, 29; 6, 37; 6, 77; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:slot; 10, call; 10, 11; 10, 12; 11, identifier:to_int; 12, argument_list; 12, 13; 13, identifier:slot; 14, if_statement; 14, 15; 14, 18; 15, comparison_operator:<; 15, 16; 15, 17; 16, identifier:slot; 17, integer:1; 18, block; 18, 19; 19, return_statement; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:list; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:analyses; 26, call; 26, 27; 26, 28; 27, identifier:list; 28, argument_list; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:layout; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:getLayout; 36, argument_list; 37, for_statement; 37, 38; 37, 39; 37, 40; 38, identifier:pos; 39, identifier:layout; 40, block; 40, 41; 40, 50; 40, 56; 40, 65; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:layout_slot; 44, call; 44, 45; 44, 46; 45, identifier:to_int; 46, argument_list; 46, 47; 47, subscript; 47, 48; 47, 49; 48, identifier:pos; 49, string:'position'; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:uid; 53, subscript; 53, 54; 53, 55; 54, identifier:pos; 55, string:'analysis_uid'; 56, if_statement; 56, 57; 56, 63; 57, boolean_operator:or; 57, 58; 57, 61; 58, comparison_operator:!=; 58, 59; 58, 60; 59, identifier:layout_slot; 60, identifier:slot; 61, not_operator; 61, 62; 62, identifier:uid; 63, block; 63, 64; 64, continue_statement; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:analyses; 69, identifier:append; 70, argument_list; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:api; 74, identifier:get_object_by_uid; 75, argument_list; 75, 76; 76, identifier:uid; 77, return_statement; 77, 78; 78, identifier:analyses | def get_analyses_at(self, slot):
slot = to_int(slot)
if slot < 1:
return list()
analyses = list()
layout = self.getLayout()
for pos in layout:
layout_slot = to_int(pos['position'])
uid = pos['analysis_uid']
if layout_slot != slot or not uid:
continue
analyses.append(api.get_object_by_uid(uid))
return analyses |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:rejectionOptionsList; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 14; 5, 20; 5, 42; 5, 53; 5, 65; 5, 69; 5, 86; 6, expression_statement; 6, 7; 7, string:"Return a sorted list with the options defined in bikasetup"; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:plone; 11, call; 11, 12; 11, 13; 12, identifier:getSite; 13, argument_list; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:settings; 17, attribute; 17, 18; 17, 19; 18, identifier:plone; 19, identifier:bika_setup; 20, if_statement; 20, 21; 20, 29; 20, 38; 21, comparison_operator:>; 21, 22; 21, 28; 22, call; 22, 23; 22, 24; 23, identifier:len; 24, argument_list; 24, 25; 25, attribute; 25, 26; 25, 27; 26, identifier:settings; 27, identifier:RejectionReasons; 28, integer:0; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:reject_reasons; 33, subscript; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:settings; 36, identifier:RejectionReasons; 37, integer:0; 38, else_clause; 38, 39; 39, block; 39, 40; 40, return_statement; 40, 41; 41, list:[]; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:sorted_keys; 45, call; 45, 46; 45, 47; 46, identifier:sorted; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:reject_reasons; 51, identifier:keys; 52, argument_list; 53, if_statement; 53, 54; 53, 57; 54, comparison_operator:in; 54, 55; 54, 56; 55, string:'checkbox'; 56, identifier:sorted_keys; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:sorted_keys; 62, identifier:remove; 63, argument_list; 63, 64; 64, string:'checkbox'; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:items; 68, list:[]; 69, for_statement; 69, 70; 69, 71; 69, 72; 70, identifier:key; 71, identifier:sorted_keys; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:items; 77, identifier:append; 78, argument_list; 78, 79; 79, call; 79, 80; 79, 85; 80, attribute; 80, 81; 80, 84; 81, subscript; 81, 82; 81, 83; 82, identifier:reject_reasons; 83, identifier:key; 84, identifier:strip; 85, argument_list; 86, return_statement; 86, 87; 87, identifier:items | def rejectionOptionsList(self):
"Return a sorted list with the options defined in bikasetup"
plone = getSite()
settings = plone.bika_setup
if len(settings.RejectionReasons) > 0:
reject_reasons = settings.RejectionReasons[0]
else:
return []
sorted_keys = sorted(reject_reasons.keys())
if 'checkbox' in sorted_keys:
sorted_keys.remove('checkbox')
items = []
for key in sorted_keys:
items.append(reject_reasons[key].strip())
return items |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_sorted_cond_keys; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:keys_list; 6, block; 6, 7; 6, 11; 6, 30; 6, 36; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:cond_list; 10, list:[]; 11, for_statement; 11, 12; 11, 13; 11, 14; 12, identifier:key; 13, identifier:keys_list; 14, block; 14, 15; 15, if_statement; 15, 16; 15, 22; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:key; 19, identifier:startswith; 20, argument_list; 20, 21; 21, string:'analysisservice-'; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:cond_list; 27, identifier:append; 28, argument_list; 28, 29; 29, identifier:key; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:cond_list; 34, identifier:sort; 35, argument_list; 36, return_statement; 36, 37; 37, identifier:cond_list | def _get_sorted_cond_keys(self, keys_list):
cond_list = []
for key in keys_list:
if key.startswith('analysisservice-'):
cond_list.append(key)
cond_list.sort()
return cond_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_get_sorted_action_keys; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:keys_list; 6, block; 6, 7; 6, 11; 6, 30; 6, 36; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:action_list; 10, list:[]; 11, for_statement; 11, 12; 11, 13; 11, 14; 12, identifier:key; 13, identifier:keys_list; 14, block; 14, 15; 15, if_statement; 15, 16; 15, 22; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:key; 19, identifier:startswith; 20, argument_list; 20, 21; 21, string:'action-'; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:action_list; 27, identifier:append; 28, argument_list; 28, 29; 29, identifier:key; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:action_list; 34, identifier:sort; 35, argument_list; 36, return_statement; 36, 37; 37, identifier:action_list | def _get_sorted_action_keys(self, keys_list):
action_list = []
for key in keys_list:
if key.startswith('action-'):
action_list.append(key)
action_list.sort()
return action_list |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:getLinkedRequests; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 15; 5, 25; 5, 44; 5, 52; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:rc; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:api; 12, identifier:get_tool; 13, argument_list; 13, 14; 14, string:"reference_catalog"; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:refs; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:rc; 21, identifier:getBackReferences; 22, argument_list; 22, 23; 22, 24; 23, identifier:self; 24, string:"AnalysisRequestAttachment"; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:ars; 28, call; 28, 29; 28, 30; 29, identifier:map; 30, argument_list; 30, 31; 30, 43; 31, lambda; 31, 32; 31, 34; 32, lambda_parameters; 32, 33; 33, identifier:ref; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:api; 37, identifier:get_object_by_uid; 38, argument_list; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:ref; 41, identifier:sourceUID; 42, None; 43, identifier:refs; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:ars; 47, call; 47, 48; 47, 49; 48, identifier:filter; 49, argument_list; 49, 50; 49, 51; 50, None; 51, identifier:ars; 52, return_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:sorted; 55, argument_list; 55, 56; 55, 57; 55, 62; 56, identifier:ars; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:key; 59, attribute; 59, 60; 59, 61; 60, identifier:api; 61, identifier:get_path; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:reverse; 64, True | def getLinkedRequests(self):
rc = api.get_tool("reference_catalog")
refs = rc.getBackReferences(self, "AnalysisRequestAttachment")
ars = map(lambda ref: api.get_object_by_uid(ref.sourceUID, None), refs)
ars = filter(None, ars)
return sorted(ars, key=api.get_path, reverse=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:getLinkedAnalyses; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 31; 5, 39; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:refs; 9, call; 9, 10; 9, 11; 10, identifier:get_backreferences; 11, argument_list; 11, 12; 11, 13; 12, identifier:self; 13, string:"AnalysisAttachment"; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:ans; 17, call; 17, 18; 17, 19; 18, identifier:map; 19, argument_list; 19, 20; 19, 30; 20, lambda; 20, 21; 20, 23; 21, lambda_parameters; 21, 22; 22, identifier:uid; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:api; 26, identifier:get_object_by_uid; 27, argument_list; 27, 28; 27, 29; 28, identifier:uid; 29, None; 30, identifier:refs; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:ans; 34, call; 34, 35; 34, 36; 35, identifier:filter; 36, argument_list; 36, 37; 36, 38; 37, None; 38, identifier:ans; 39, return_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:sorted; 42, argument_list; 42, 43; 42, 44; 42, 49; 43, identifier:ans; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:key; 46, attribute; 46, 47; 46, 48; 47, identifier:api; 48, identifier:get_path; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:reverse; 51, True | def getLinkedAnalyses(self):
refs = get_backreferences(self, "AnalysisAttachment")
ans = map(lambda uid: api.get_object_by_uid(uid, None), refs)
ans = filter(None, ans)
return sorted(ans, key=api.get_path, reverse=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_sorted_fields; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 13; 5, 21; 5, 83; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:inf; 9, call; 9, 10; 9, 11; 10, identifier:float; 11, argument_list; 11, 12; 12, string:"inf"; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:order; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:get_field_order; 20, argument_list; 21, function_definition; 21, 22; 21, 23; 21, 26; 22, function_name:field_cmp; 23, parameters; 23, 24; 23, 25; 24, identifier:field1; 25, identifier:field2; 26, block; 26, 27; 26, 35; 26, 43; 26, 60; 26, 77; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:_n1; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:field1; 33, identifier:getName; 34, argument_list; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:_n2; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:field2; 41, identifier:getName; 42, argument_list; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:_i1; 46, boolean_operator:or; 46, 47; 46, 59; 47, boolean_operator:and; 47, 48; 47, 51; 48, comparison_operator:in; 48, 49; 48, 50; 49, identifier:_n1; 50, identifier:order; 51, binary_operator:+; 51, 52; 51, 58; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:order; 55, identifier:index; 56, argument_list; 56, 57; 57, identifier:_n1; 58, integer:1; 59, identifier:inf; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:_i2; 63, boolean_operator:or; 63, 64; 63, 76; 64, boolean_operator:and; 64, 65; 64, 68; 65, comparison_operator:in; 65, 66; 65, 67; 66, identifier:_n2; 67, identifier:order; 68, binary_operator:+; 68, 69; 68, 75; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:order; 72, identifier:index; 73, argument_list; 73, 74; 74, identifier:_n2; 75, integer:1; 76, identifier:inf; 77, return_statement; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:cmp; 80, argument_list; 80, 81; 80, 82; 81, identifier:_i1; 82, identifier:_i2; 83, return_statement; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:sorted; 86, argument_list; 86, 87; 86, 92; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:get_fields; 91, argument_list; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:cmp; 94, identifier:field_cmp | def get_sorted_fields(self):
inf = float("inf")
order = self.get_field_order()
def field_cmp(field1, field2):
_n1 = field1.getName()
_n2 = field2.getName()
_i1 = _n1 in order and order.index(_n1) + 1 or inf
_i2 = _n2 in order and order.index(_n2) + 1 or inf
return cmp(_i1, _i2)
return sorted(self.get_fields(), cmp=field_cmp) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:resolve_sorting; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:query; 6, block; 6, 7; 6, 11; 6, 21; 6, 33; 6, 43; 6, 124; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:sorting; 10, dictionary; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:sort_on; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:query; 17, identifier:get; 18, argument_list; 18, 19; 18, 20; 19, string:"sidx"; 20, None; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:sort_on; 24, boolean_operator:or; 24, 25; 24, 26; 25, identifier:sort_on; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:query; 29, identifier:get; 30, argument_list; 30, 31; 30, 32; 31, string:"sort_on"; 32, None; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:sort_on; 36, boolean_operator:or; 36, 37; 36, 42; 37, boolean_operator:and; 37, 38; 37, 41; 38, comparison_operator:==; 38, 39; 38, 40; 39, identifier:sort_on; 40, string:"Title"; 41, string:"sortable_title"; 42, identifier:sort_on; 43, if_statement; 43, 44; 43, 45; 44, identifier:sort_on; 45, block; 45, 46; 45, 52; 45, 62; 45, 74; 45, 97; 45, 115; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 51; 48, subscript; 48, 49; 48, 50; 49, identifier:sorting; 50, string:"sort_on"; 51, identifier:sort_on; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:sort_order; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:query; 58, identifier:get; 59, argument_list; 59, 60; 59, 61; 60, string:"sord"; 61, None; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:sort_order; 65, boolean_operator:or; 65, 66; 65, 67; 66, identifier:sort_order; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:query; 70, identifier:get; 71, argument_list; 71, 72; 71, 73; 72, string:"sort_order"; 73, None; 74, if_statement; 74, 75; 74, 82; 74, 89; 75, comparison_operator:in; 75, 76; 75, 77; 76, identifier:sort_order; 77, list:["desc", "reverse", "rev", "descending"]; 77, 78; 77, 79; 77, 80; 77, 81; 78, string:"desc"; 79, string:"reverse"; 80, string:"rev"; 81, string:"descending"; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:sorting; 87, string:"sort_order"; 88, string:"descending"; 89, else_clause; 89, 90; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 96; 93, subscript; 93, 94; 93, 95; 94, identifier:sorting; 95, string:"sort_order"; 96, string:"ascending"; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:sort_limit; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:api; 103, identifier:to_int; 104, argument_list; 104, 105; 104, 112; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:query; 108, identifier:get; 109, argument_list; 109, 110; 109, 111; 110, string:"limit"; 111, integer:30; 112, keyword_argument; 112, 113; 112, 114; 113, identifier:default; 114, integer:30; 115, if_statement; 115, 116; 115, 117; 116, identifier:sort_limit; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 123; 120, subscript; 120, 121; 120, 122; 121, identifier:sorting; 122, string:"sort_limit"; 123, identifier:sort_limit; 124, return_statement; 124, 125; 125, identifier:sorting | def resolve_sorting(self, query):
sorting = {}
sort_on = query.get("sidx", None)
sort_on = sort_on or query.get("sort_on", None)
sort_on = sort_on == "Title" and "sortable_title" or sort_on
if sort_on:
sorting["sort_on"] = sort_on
sort_order = query.get("sord", None)
sort_order = sort_order or query.get("sort_order", None)
if sort_order in ["desc", "reverse", "rev", "descending"]:
sorting["sort_order"] = "descending"
else:
sorting["sort_order"] = "ascending"
sort_limit = api.to_int(query.get("limit", 30), default=30)
if sort_limit:
sorting["sort_limit"] = sort_limit
return sorting |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:is_sortable_index; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:index_name; 6, identifier:catalog; 7, block; 7, 8; 7, 18; 7, 24; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:index; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:get_index; 15, argument_list; 15, 16; 15, 17; 16, identifier:index_name; 17, identifier:catalog; 18, if_statement; 18, 19; 18, 21; 19, not_operator; 19, 20; 20, identifier:index; 21, block; 21, 22; 22, return_statement; 22, 23; 23, False; 24, return_statement; 24, 25; 25, comparison_operator:in; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:index; 28, identifier:meta_type; 29, list:["FieldIndex", "DateIndex"]; 29, 30; 29, 31; 30, string:"FieldIndex"; 31, string:"DateIndex" | def is_sortable_index(self, index_name, catalog):
index = self.get_index(index_name, catalog)
if not index:
return False
return index.meta_type in ["FieldIndex", "DateIndex"] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sortable_title; 3, parameters; 3, 4; 3, 5; 4, identifier:portal; 5, identifier:title; 6, block; 6, 7; 6, 13; 6, 23; 6, 38; 6, 48; 6, 97; 7, if_statement; 7, 8; 7, 10; 8, not_operator; 8, 9; 9, identifier:title; 10, block; 10, 11; 11, return_statement; 11, 12; 12, string:''; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:def_charset; 16, call; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:portal; 20, identifier:plone_utils; 21, identifier:getSiteEncoding; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:sortabletitle; 26, call; 26, 27; 26, 28; 27, identifier:str; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 37; 30, attribute; 30, 31; 30, 36; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:title; 34, identifier:lower; 35, argument_list; 36, identifier:strip; 37, argument_list; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:sortabletitle; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:num_sort_regex; 44, identifier:sub; 45, argument_list; 45, 46; 45, 47; 46, identifier:zero_fill; 47, identifier:sortabletitle; 48, for_statement; 48, 49; 48, 50; 48, 54; 49, identifier:charset; 50, list:[def_charset, 'latin-1', 'utf-8']; 50, 51; 50, 52; 50, 53; 51, identifier:def_charset; 52, string:'latin-1'; 53, string:'utf-8'; 54, block; 54, 55; 55, try_statement; 55, 56; 55, 81; 55, 85; 56, block; 56, 57; 56, 69; 56, 80; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:sortabletitle; 60, subscript; 60, 61; 60, 66; 61, call; 61, 62; 61, 63; 62, identifier:safe_unicode; 63, argument_list; 63, 64; 63, 65; 64, identifier:sortabletitle; 65, identifier:charset; 66, slice; 66, 67; 66, 68; 67, colon; 68, integer:30; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:sortabletitle; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:sortabletitle; 75, identifier:encode; 76, argument_list; 76, 77; 77, boolean_operator:or; 77, 78; 77, 79; 78, identifier:def_charset; 79, string:'utf-8'; 80, break_statement; 81, except_clause; 81, 82; 81, 83; 82, identifier:UnicodeError; 83, block; 83, 84; 84, pass_statement; 85, except_clause; 85, 86; 85, 87; 86, identifier:TypeError; 87, block; 87, 88; 87, 96; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:sortabletitle; 91, subscript; 91, 92; 91, 93; 92, identifier:sortabletitle; 93, slice; 93, 94; 93, 95; 94, colon; 95, integer:30; 96, break_statement; 97, return_statement; 97, 98; 98, identifier:sortabletitle | def sortable_title(portal, title):
if not title:
return ''
def_charset = portal.plone_utils.getSiteEncoding()
sortabletitle = str(title.lower().strip())
sortabletitle = num_sort_regex.sub(zero_fill, sortabletitle)
for charset in [def_charset, 'latin-1', 'utf-8']:
try:
sortabletitle = safe_unicode(sortabletitle, charset)[:30]
sortabletitle = sortabletitle.encode(def_charset or 'utf-8')
break
except UnicodeError:
pass
except TypeError:
sortabletitle = sortabletitle[:30]
break
return sortabletitle |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_sort_column; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:column; 6, identifier:reverse; 7, block; 7, 8; 7, 20; 7, 41; 7, 65; 7, 85; 8, if_statement; 8, 9; 8, 18; 9, comparison_operator:in; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:tk; 12, identifier:DISABLED; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:state; 17, argument_list; 18, block; 18, 19; 19, return_statement; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:l; 23, list_comprehension; 23, 24; 23, 33; 24, tuple; 24, 25; 24, 32; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:set; 29, argument_list; 29, 30; 29, 31; 30, identifier:child; 31, identifier:column; 32, identifier:child; 33, for_in_clause; 33, 34; 33, 35; 34, identifier:child; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:get_children; 39, argument_list; 39, 40; 40, string:''; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:l; 45, identifier:sort; 46, argument_list; 46, 47; 46, 50; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:reverse; 49, identifier:reverse; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:key; 52, lambda; 52, 53; 52, 55; 53, lambda_parameters; 53, 54; 54, identifier:x; 55, call; 55, 56; 55, 61; 56, subscript; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_column_types; 60, identifier:column; 61, argument_list; 61, 62; 62, subscript; 62, 63; 62, 64; 63, identifier:x; 64, integer:0; 65, for_statement; 65, 66; 65, 71; 65, 75; 66, pattern_list; 66, 67; 66, 68; 67, identifier:index; 68, tuple_pattern; 68, 69; 68, 70; 69, identifier:val; 70, identifier:child; 71, call; 71, 72; 71, 73; 72, identifier:enumerate; 73, argument_list; 73, 74; 74, identifier:l; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:move; 81, argument_list; 81, 82; 81, 83; 81, 84; 82, identifier:child; 83, string:""; 84, identifier:index; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:heading; 90, argument_list; 90, 91; 90, 92; 91, identifier:column; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:command; 94, lambda; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:_sort_column; 99, argument_list; 99, 100; 99, 101; 100, identifier:column; 101, not_operator; 101, 102; 102, identifier:reverse | def _sort_column(self, column, reverse):
if tk.DISABLED in self.state():
return
l = [(self.set(child, column), child) for child in self.get_children('')]
l.sort(reverse=reverse, key=lambda x: self._column_types[column](x[0]))
for index, (val, child) in enumerate(l):
self.move(child, "", index)
self.heading(column, command=lambda: self._sort_column(column, not reverse)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:column; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:column; 6, default_parameter; 6, 7; 6, 8; 7, identifier:option; 8, None; 9, dictionary_splat_pattern; 9, 10; 10, identifier:kw; 11, block; 11, 12; 11, 16; 11, 49; 11, 73; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:config; 15, False; 16, if_statement; 16, 17; 16, 20; 16, 27; 17, comparison_operator:==; 17, 18; 17, 19; 18, identifier:option; 19, string:'type'; 20, block; 20, 21; 21, return_statement; 21, 22; 22, subscript; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:_column_types; 26, identifier:column; 27, elif_clause; 27, 28; 27, 31; 28, comparison_operator:in; 28, 29; 28, 30; 29, string:'type'; 30, identifier:kw; 31, block; 31, 32; 31, 36; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:config; 35, True; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 43; 38, subscript; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_column_types; 42, identifier:column; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:kw; 46, identifier:pop; 47, argument_list; 47, 48; 48, string:'type'; 49, if_statement; 49, 50; 49, 51; 50, identifier:kw; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 59; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:_visual_drag; 58, identifier:column; 59, argument_list; 59, 60; 59, 70; 59, 71; 60, call; 60, 61; 60, 66; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:ttk; 64, identifier:Treeview; 65, identifier:column; 66, argument_list; 66, 67; 66, 68; 66, 69; 67, identifier:self; 68, identifier:column; 69, string:'id'; 70, identifier:option; 71, dictionary_splat; 71, 72; 72, identifier:kw; 73, if_statement; 73, 74; 73, 77; 73, 91; 74, boolean_operator:or; 74, 75; 74, 76; 75, identifier:kw; 76, identifier:option; 77, block; 77, 78; 78, return_statement; 78, 79; 79, call; 79, 80; 79, 85; 80, attribute; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:ttk; 83, identifier:Treeview; 84, identifier:column; 85, argument_list; 85, 86; 85, 87; 85, 88; 85, 89; 86, identifier:self; 87, identifier:column; 88, identifier:option; 89, dictionary_splat; 89, 90; 90, identifier:kw; 91, elif_clause; 91, 92; 91, 94; 92, not_operator; 92, 93; 93, identifier:config; 94, block; 94, 95; 94, 110; 94, 120; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:res; 98, call; 98, 99; 98, 104; 99, attribute; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:ttk; 102, identifier:Treeview; 103, identifier:column; 104, argument_list; 104, 105; 104, 106; 104, 107; 104, 108; 105, identifier:self; 106, identifier:column; 107, identifier:option; 108, dictionary_splat; 108, 109; 109, identifier:kw; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 115; 112, subscript; 112, 113; 112, 114; 113, identifier:res; 114, string:'type'; 115, subscript; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:_column_types; 119, identifier:column; 120, return_statement; 120, 121; 121, identifier:res | def column(self, column, option=None, **kw):
config = False
if option == 'type':
return self._column_types[column]
elif 'type' in kw:
config = True
self._column_types[column] = kw.pop('type')
if kw:
self._visual_drag.column(ttk.Treeview.column(self, column, 'id'), option, **kw)
if kw or option:
return ttk.Treeview.column(self, column, option, **kw)
elif not config:
res = ttk.Treeview.column(self, column, option, **kw)
res['type'] = self._column_types[column]
return res |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_config_sortable; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:sortable; 6, block; 6, 7; 6, 42; 7, for_statement; 7, 8; 7, 9; 7, 12; 8, identifier:col; 9, subscript; 9, 10; 9, 11; 10, identifier:self; 11, string:"columns"; 12, block; 12, 13; 12, 32; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:command; 16, conditional_expression:if; 16, 17; 16, 30; 16, 31; 17, parenthesized_expression; 17, 18; 18, lambda; 18, 19; 18, 23; 19, lambda_parameters; 19, 20; 20, default_parameter; 20, 21; 20, 22; 21, identifier:c; 22, identifier:col; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_sort_column; 27, argument_list; 27, 28; 27, 29; 28, identifier:c; 29, True; 30, identifier:sortable; 31, string:""; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:heading; 37, argument_list; 37, 38; 37, 39; 38, identifier:col; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:command; 41, identifier:command; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:_sortable; 47, identifier:sortable | def _config_sortable(self, sortable):
for col in self["columns"]:
command = (lambda c=col: self._sort_column(c, True)) if sortable else ""
self.heading(col, command=command)
self._sortable = sortable |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:iter_items; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:cls; 5, identifier:repo; 6, default_parameter; 6, 7; 6, 8; 7, identifier:common_path; 8, None; 9, block; 9, 10; 10, return_statement; 10, 11; 11, generator_expression; 11, 12; 11, 13; 11, 22; 12, identifier:r; 13, for_in_clause; 13, 14; 13, 15; 14, identifier:r; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:cls; 18, identifier:_iter_items; 19, argument_list; 19, 20; 19, 21; 20, identifier:repo; 21, identifier:common_path; 22, if_clause; 22, 23; 23, boolean_operator:or; 23, 24; 23, 29; 24, comparison_operator:==; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:r; 27, identifier:__class__; 28, identifier:SymbolicReference; 29, not_operator; 29, 30; 30, attribute; 30, 31; 30, 32; 31, identifier:r; 32, identifier:is_detached | def iter_items(cls, repo, common_path=None):
return (r for r in cls._iter_items(repo, common_path) if r.__class__ == SymbolicReference or not r.is_detached) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:write_cache; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:entries; 5, identifier:stream; 6, default_parameter; 6, 7; 6, 8; 7, identifier:extension_data; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:ShaStreamCls; 11, identifier:IndexFileSHA1Writer; 12, block; 12, 13; 12, 20; 12, 26; 12, 32; 12, 36; 12, 41; 12, 54; 12, 191; 12, 203; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:stream; 16, call; 16, 17; 16, 18; 17, identifier:ShaStreamCls; 18, argument_list; 18, 19; 19, identifier:stream; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:tell; 23, attribute; 23, 24; 23, 25; 24, identifier:stream; 25, identifier:tell; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:write; 29, attribute; 29, 30; 29, 31; 30, identifier:stream; 31, identifier:write; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:version; 35, integer:2; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:write; 39, argument_list; 39, 40; 40, string:b"DIRC"; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:write; 44, argument_list; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:pack; 47, argument_list; 47, 48; 47, 49; 47, 50; 48, string:">LL"; 49, identifier:version; 50, call; 50, 51; 50, 52; 51, identifier:len; 52, argument_list; 52, 53; 53, identifier:entries; 54, for_statement; 54, 55; 54, 56; 54, 57; 55, identifier:entry; 56, identifier:entries; 57, block; 57, 58; 57, 64; 57, 71; 57, 78; 57, 84; 57, 94; 57, 103; 57, 115; 57, 126; 57, 156; 57, 161; 57, 176; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:beginoffset; 61, call; 61, 62; 61, 63; 62, identifier:tell; 63, argument_list; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:write; 67, argument_list; 67, 68; 68, subscript; 68, 69; 68, 70; 69, identifier:entry; 70, integer:4; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:write; 74, argument_list; 74, 75; 75, subscript; 75, 76; 75, 77; 76, identifier:entry; 77, integer:5; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:path; 81, subscript; 81, 82; 81, 83; 82, identifier:entry; 83, integer:3; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:path; 87, call; 87, 88; 87, 89; 88, identifier:force_bytes; 89, argument_list; 89, 90; 89, 91; 90, identifier:path; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:encoding; 93, identifier:defenc; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:plen; 97, binary_operator:&; 97, 98; 97, 102; 98, call; 98, 99; 98, 100; 99, identifier:len; 100, argument_list; 100, 101; 101, identifier:path; 102, identifier:CE_NAMEMASK; 103, assert_statement; 103, 104; 103, 110; 104, comparison_operator:==; 104, 105; 104, 106; 105, identifier:plen; 106, call; 106, 107; 106, 108; 107, identifier:len; 108, argument_list; 108, 109; 109, identifier:path; 110, binary_operator:%; 110, 111; 110, 112; 111, string:"Path %s too long to fit into index"; 112, subscript; 112, 113; 112, 114; 113, identifier:entry; 114, integer:3; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:flags; 118, binary_operator:|; 118, 119; 118, 120; 119, identifier:plen; 120, parenthesized_expression; 120, 121; 121, binary_operator:&; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:entry; 124, integer:2; 125, identifier:CE_NAMEMASK_INV; 126, expression_statement; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:write; 129, argument_list; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:pack; 132, argument_list; 132, 133; 132, 134; 132, 137; 132, 140; 132, 143; 132, 146; 132, 149; 132, 152; 132, 155; 133, string:">LLLLLL20sH"; 134, subscript; 134, 135; 134, 136; 135, identifier:entry; 136, integer:6; 137, subscript; 137, 138; 137, 139; 138, identifier:entry; 139, integer:7; 140, subscript; 140, 141; 140, 142; 141, identifier:entry; 142, integer:0; 143, subscript; 143, 144; 143, 145; 144, identifier:entry; 145, integer:8; 146, subscript; 146, 147; 146, 148; 147, identifier:entry; 148, integer:9; 149, subscript; 149, 150; 149, 151; 150, identifier:entry; 151, integer:10; 152, subscript; 152, 153; 152, 154; 153, identifier:entry; 154, integer:1; 155, identifier:flags; 156, expression_statement; 156, 157; 157, call; 157, 158; 157, 159; 158, identifier:write; 159, argument_list; 159, 160; 160, identifier:path; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:real_size; 164, parenthesized_expression; 164, 165; 165, binary_operator:&; 165, 166; 165, 174; 166, parenthesized_expression; 166, 167; 167, binary_operator:+; 167, 168; 167, 173; 168, binary_operator:-; 168, 169; 168, 172; 169, call; 169, 170; 169, 171; 170, identifier:tell; 171, argument_list; 172, identifier:beginoffset; 173, integer:8; 174, unary_operator:~; 174, 175; 175, integer:7; 176, expression_statement; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:write; 179, argument_list; 179, 180; 180, binary_operator:*; 180, 181; 180, 182; 181, string:b"\0"; 182, parenthesized_expression; 182, 183; 183, binary_operator:-; 183, 184; 183, 188; 184, parenthesized_expression; 184, 185; 185, binary_operator:+; 185, 186; 185, 187; 186, identifier:beginoffset; 187, identifier:real_size; 188, call; 188, 189; 188, 190; 189, identifier:tell; 190, argument_list; 191, if_statement; 191, 192; 191, 195; 192, comparison_operator:is; 192, 193; 192, 194; 193, identifier:extension_data; 194, None; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:stream; 200, identifier:write; 201, argument_list; 201, 202; 202, identifier:extension_data; 203, expression_statement; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:stream; 207, identifier:write_sha; 208, argument_list | def write_cache(entries, stream, extension_data=None, ShaStreamCls=IndexFileSHA1Writer):
stream = ShaStreamCls(stream)
tell = stream.tell
write = stream.write
version = 2
write(b"DIRC")
write(pack(">LL", version, len(entries)))
for entry in entries:
beginoffset = tell()
write(entry[4])
write(entry[5])
path = entry[3]
path = force_bytes(path, encoding=defenc)
plen = len(path) & CE_NAMEMASK
assert plen == len(path), "Path %s too long to fit into index" % entry[3]
flags = plen | (entry[2] & CE_NAMEMASK_INV)
write(pack(">LLLLLL20sH", entry[6], entry[7], entry[0],
entry[8], entry[9], entry[10], entry[1], flags))
write(path)
real_size = ((tell() - beginoffset + 8) & ~7)
write(b"\0" * ((beginoffset + real_size) - tell()))
if extension_data is not None:
stream.write(extension_data)
stream.write_sha() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:write_tree_from_cache; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:entries; 5, identifier:odb; 6, identifier:sl; 7, default_parameter; 7, 8; 7, 9; 8, identifier:si; 9, integer:0; 10, block; 10, 11; 10, 15; 10, 21; 10, 27; 10, 33; 10, 190; 10, 196; 10, 204; 10, 211; 10, 232; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:tree_items; 14, list:[]; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:tree_items_append; 18, attribute; 18, 19; 18, 20; 19, identifier:tree_items; 20, identifier:append; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:ci; 24, attribute; 24, 25; 24, 26; 25, identifier:sl; 26, identifier:start; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:end; 30, attribute; 30, 31; 30, 32; 31, identifier:sl; 32, identifier:stop; 33, while_statement; 33, 34; 33, 37; 34, comparison_operator:<; 34, 35; 34, 36; 35, identifier:ci; 36, identifier:end; 37, block; 37, 38; 37, 44; 37, 56; 37, 60; 37, 72; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:entry; 41, subscript; 41, 42; 41, 43; 42, identifier:entries; 43, identifier:ci; 44, if_statement; 44, 45; 44, 50; 45, comparison_operator:!=; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:entry; 48, identifier:stage; 49, integer:0; 50, block; 50, 51; 51, raise_statement; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:UnmergedEntriesError; 54, argument_list; 54, 55; 55, identifier:entry; 56, expression_statement; 56, 57; 57, augmented_assignment:+=; 57, 58; 57, 59; 58, identifier:ci; 59, integer:1; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:rbound; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:entry; 67, identifier:path; 68, identifier:find; 69, argument_list; 69, 70; 69, 71; 70, string:'/'; 71, identifier:si; 72, if_statement; 72, 73; 72, 77; 72, 96; 73, comparison_operator:==; 73, 74; 73, 75; 74, identifier:rbound; 75, unary_operator:-; 75, 76; 76, integer:1; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:tree_items_append; 81, argument_list; 81, 82; 82, tuple; 82, 83; 82, 86; 82, 89; 83, attribute; 83, 84; 83, 85; 84, identifier:entry; 85, identifier:binsha; 86, attribute; 86, 87; 86, 88; 87, identifier:entry; 88, identifier:mode; 89, subscript; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:entry; 92, identifier:path; 93, slice; 93, 94; 93, 95; 94, identifier:si; 95, colon; 96, else_clause; 96, 97; 97, block; 97, 98; 97, 109; 97, 113; 97, 158; 97, 178; 97, 186; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:base; 101, subscript; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:entry; 104, identifier:path; 105, slice; 105, 106; 105, 107; 105, 108; 106, identifier:si; 107, colon; 108, identifier:rbound; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:xi; 112, identifier:ci; 113, while_statement; 113, 114; 113, 117; 114, comparison_operator:<; 114, 115; 114, 116; 115, identifier:xi; 116, identifier:end; 117, block; 117, 118; 117, 124; 117, 136; 117, 154; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:oentry; 121, subscript; 121, 122; 121, 123; 122, identifier:entries; 123, identifier:xi; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:orbound; 127, call; 127, 128; 127, 133; 128, attribute; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:oentry; 131, identifier:path; 132, identifier:find; 133, argument_list; 133, 134; 133, 135; 134, string:'/'; 135, identifier:si; 136, if_statement; 136, 137; 136, 152; 137, boolean_operator:or; 137, 138; 137, 142; 138, comparison_operator:==; 138, 139; 138, 140; 139, identifier:orbound; 140, unary_operator:-; 140, 141; 141, integer:1; 142, comparison_operator:!=; 142, 143; 142, 151; 143, subscript; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:oentry; 146, identifier:path; 147, slice; 147, 148; 147, 149; 147, 150; 148, identifier:si; 149, colon; 150, identifier:orbound; 151, identifier:base; 152, block; 152, 153; 153, break_statement; 154, expression_statement; 154, 155; 155, augmented_assignment:+=; 155, 156; 155, 157; 156, identifier:xi; 157, integer:1; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 163; 160, pattern_list; 160, 161; 160, 162; 161, identifier:sha; 162, identifier:tree_entry_list; 163, call; 163, 164; 163, 165; 164, identifier:write_tree_from_cache; 165, argument_list; 165, 166; 165, 167; 165, 168; 165, 175; 166, identifier:entries; 167, identifier:odb; 168, call; 168, 169; 168, 170; 169, identifier:slice; 170, argument_list; 170, 171; 170, 174; 171, binary_operator:-; 171, 172; 171, 173; 172, identifier:ci; 173, integer:1; 174, identifier:xi; 175, binary_operator:+; 175, 176; 175, 177; 176, identifier:rbound; 177, integer:1; 178, expression_statement; 178, 179; 179, call; 179, 180; 179, 181; 180, identifier:tree_items_append; 181, argument_list; 181, 182; 182, tuple; 182, 183; 182, 184; 182, 185; 183, identifier:sha; 184, identifier:S_IFDIR; 185, identifier:base; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:ci; 189, identifier:xi; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:sio; 193, call; 193, 194; 193, 195; 194, identifier:BytesIO; 195, argument_list; 196, expression_statement; 196, 197; 197, call; 197, 198; 197, 199; 198, identifier:tree_to_stream; 199, argument_list; 199, 200; 199, 201; 200, identifier:tree_items; 201, attribute; 201, 202; 201, 203; 202, identifier:sio; 203, identifier:write; 204, expression_statement; 204, 205; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:sio; 208, identifier:seek; 209, argument_list; 209, 210; 210, integer:0; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:istream; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:odb; 217, identifier:store; 218, argument_list; 218, 219; 219, call; 219, 220; 219, 221; 220, identifier:IStream; 221, argument_list; 221, 222; 221, 223; 221, 231; 222, identifier:str_tree_type; 223, call; 223, 224; 223, 225; 224, identifier:len; 225, argument_list; 225, 226; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:sio; 229, identifier:getvalue; 230, argument_list; 231, identifier:sio; 232, return_statement; 232, 233; 233, tuple; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:istream; 236, identifier:binsha; 237, identifier:tree_items | def write_tree_from_cache(entries, odb, sl, si=0):
tree_items = []
tree_items_append = tree_items.append
ci = sl.start
end = sl.stop
while ci < end:
entry = entries[ci]
if entry.stage != 0:
raise UnmergedEntriesError(entry)
ci += 1
rbound = entry.path.find('/', si)
if rbound == -1:
tree_items_append((entry.binsha, entry.mode, entry.path[si:]))
else:
base = entry.path[si:rbound]
xi = ci
while xi < end:
oentry = entries[xi]
orbound = oentry.path.find('/', si)
if orbound == -1 or oentry.path[si:orbound] != base:
break
xi += 1
sha, tree_entry_list = write_tree_from_cache(entries, odb, slice(ci - 1, xi), rbound + 1)
tree_items_append((sha, S_IFDIR, base))
ci = xi
sio = BytesIO()
tree_to_stream(tree_items, sio.write)
sio.seek(0)
istream = odb.store(IStream(str_tree_type, len(sio.getvalue()), sio))
return (istream.binsha, tree_items) |
Subsets and Splits