nodes
stringlengths 501
22.4k
| edges
stringlengths 138
5.07k
| code
stringlengths 108
19.3k
|
|---|---|---|
0, module; 1, function_definition; 2, function_name:get_entries; 3, parameters; 4, block; 5, identifier:self; 6, identifier:chemsys_formula_id_criteria; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, expression_statement; 13, comment:# TODO: This is a very hackish way of doing this. It should be fixed; 14, comment:# on the REST end.; 15, expression_statement; 16, expression_statement; 17, if_statement; 18, if_statement; 19, if_statement; 20, if_statement; 21, expression_statement; 22, expression_statement; 23, for_statement; 24, if_statement; 25, if_statement; 26, return_statement; 27, identifier:compatible_only; 28, True; 29, identifier:inc_structure; 30, None; 31, identifier:property_data; 32, None; 33, identifier:conventional_unit_cell; 34, False; 35, identifier:sort_by_e_above_hull; 36, False; 37, comment:"""
Get a list of ComputedEntries or ComputedStructureEntries corresponding
to a chemical system, formula, or materials_id or full criteria.
Args:
chemsys_formula_id_criteria (str/dict): A chemical system
(e.g., Li-Fe-O), or formula (e.g., Fe2O3) or materials_id
(e.g., mp-1234) or full Mongo-style dict criteria.
compatible_only (bool): Whether to return only "compatible"
entries. Compatible entries are entries that have been
processed using the MaterialsProjectCompatibility class,
which performs adjustments to allow mixing of GGA and GGA+U
calculations for more accurate phase diagrams and reaction
energies.
inc_structure (str): If None, entries returned are
ComputedEntries. If inc_structure="initial",
ComputedStructureEntries with initial structures are returned.
Otherwise, ComputedStructureEntries with final structures
are returned.
property_data (list): Specify additional properties to include in
entry.data. If None, no data. Should be a subset of
supported_properties.
conventional_unit_cell (bool): Whether to get the standard
conventional unit cell
sort_by_e_above_hull (bool): Whether to sort the list of entries by
e_above_hull (will query e_above_hull as a property_data if True).
Returns:
List of ComputedEntry or ComputedStructureEntry objects.
"""; 38, assignment; 39, assignment; 40, identifier:sort_by_e_above_hull; 41, block; 42, identifier:property_data; 43, block; 44, identifier:inc_structure; 45, block; 46, not_operator; 47, block; 48, else_clause; 49, assignment; 50, assignment; 51, identifier:d; 52, identifier:data; 53, block; 54, identifier:compatible_only; 55, block; 56, identifier:sort_by_e_above_hull; 57, block; 58, identifier:entries; 59, identifier:params; 60, list; 61, identifier:props; 62, binary_operator:["energy", "unit_cell_formula", "task_id"] + params; 63, if_statement; 64, expression_statement; 65, if_statement; 66, call; 67, expression_statement; 68, block; 69, identifier:data; 70, call; 71, identifier:entries; 72, list; 73, expression_statement; 74, expression_statement; 75, if_statement; 76, if_statement; 77, expression_statement; 78, import_from_statement; 79, expression_statement; 80, expression_statement; 81, string:"run_type"; 82, string:"is_hubbard"; 83, string:"pseudo_potential"; 84, string:"hubbards"; 85, string:"potcar_symbols"; 86, string:"oxide_type"; 87, list; 88, identifier:params; 89, boolean_operator; 90, block; 91, elif_clause; 92, augmented_assignment; 93, comparison_operator:inc_structure == "initial"; 94, block; 95, else_clause; 96, identifier:isinstance; 97, argument_list; 98, assignment; 99, expression_statement; 100, attribute; 101, argument_list; 102, assignment; 103, assignment; 104, identifier:property_data; 105, block; 106, not_operator; 107, block; 108, else_clause; 109, call; 110, dotted_name; 111, line_continuation:\; 112, dotted_name; 113, assignment; 114, assignment; 115, string:"energy"; 116, string:"unit_cell_formula"; 117, string:"task_id"; 118, identifier:property_data; 119, comparison_operator:"e_above_hull" not in property_data; 120, expression_statement; 121, not_operator; 122, block; 123, identifier:props; 124, identifier:property_data; 125, identifier:inc_structure; 126, string:"initial"; 127, expression_statement; 128, block; 129, identifier:chemsys_formula_id_criteria; 130, identifier:dict; 131, identifier:criteria; 132, call; 133, assignment; 134, identifier:self; 135, identifier:query; 136, identifier:criteria; 137, identifier:props; 138, subscript; 139, list_comprehension; 140, identifier:data; 141, dictionary; 142, expression_statement; 143, identifier:inc_structure; 144, expression_statement; 145, block; 146, attribute; 147, argument_list; 148, identifier:pymatgen; 149, identifier:entries; 150, identifier:compatibility; 151, identifier:MaterialsProjectCompatibility; 152, identifier:entries; 153, call; 154, identifier:entries; 155, call; 156, string:"e_above_hull"; 157, identifier:property_data; 158, call; 159, identifier:property_data; 160, expression_statement; 161, call; 162, expression_statement; 163, attribute; 164, argument_list; 165, identifier:criteria; 166, identifier:chemsys_formula_id_criteria; 167, identifier:d; 168, string:"potcar_symbols"; 169, binary_operator:"%s %s" % (d["pseudo_potential"]["functional"], l); 170, for_in_clause; 171, pair; 172, call; 173, assignment; 174, expression_statement; 175, if_statement; 176, expression_statement; 177, identifier:entries; 178, identifier:append; 179, identifier:e; 180, attribute; 181, argument_list; 182, identifier:sorted; 183, argument_list; 184, attribute; 185, argument_list; 186, assignment; 187, attribute; 188, argument_list; 189, call; 190, identifier:MPRester; 191, identifier:parse_criteria; 192, identifier:chemsys_formula_id_criteria; 193, string:"%s %s"; 194, tuple; 195, identifier:l; 196, subscript; 197, string:"oxide_type"; 198, subscript; 199, attribute; 200, argument_list; 201, identifier:e; 202, call; 203, assignment; 204, identifier:conventional_unit_cell; 205, block; 206, else_clause; 207, assignment; 208, call; 209, identifier:process_entries; 210, identifier:entries; 211, identifier:entries; 212, keyword_argument; 213, identifier:property_data; 214, identifier:append; 215, string:"e_above_hull"; 216, identifier:property_data; 217, list; 218, identifier:props; 219, identifier:append; 220, string:"initial_structure"; 221, attribute; 222, argument_list; 223, subscript; 224, identifier:l; 225, subscript; 226, string:"labels"; 227, identifier:d; 228, string:"oxide_type"; 229, identifier:data; 230, identifier:update; 231, dictionary_comprehension; 232, identifier:ComputedEntry; 233, argument_list; 234, identifier:prim; 235, conditional_expression:d["initial_structure"] if inc_structure == "initial" \
else d["structure"]; 236, expression_statement; 237, expression_statement; 238, block; 239, identifier:e; 240, call; 241, identifier:MaterialsProjectCompatibility; 242, argument_list; 243, identifier:key; 244, lambda; 245, string:"e_above_hull"; 246, identifier:props; 247, identifier:append; 248, string:"structure"; 249, subscript; 250, string:"functional"; 251, identifier:d; 252, string:"pseudo_potential"; 253, pair; 254, for_in_clause; 255, subscript; 256, subscript; 257, keyword_argument; 258, keyword_argument; 259, keyword_argument; 260, subscript; 261, comparison_operator:inc_structure == "initial"; 262, line_continuation:\; 263, subscript; 264, assignment; 265, assignment; 266, expression_statement; 267, expression_statement; 268, identifier:ComputedStructureEntry; 269, argument_list; 270, lambda_parameters; 271, subscript; 272, identifier:d; 273, string:"pseudo_potential"; 274, identifier:k; 275, subscript; 276, identifier:k; 277, identifier:property_data; 278, identifier:d; 279, string:"unit_cell_formula"; 280, identifier:d; 281, string:"energy"; 282, identifier:parameters; 283, dictionary_comprehension; 284, identifier:data; 285, identifier:data; 286, identifier:entry_id; 287, subscript; 288, identifier:d; 289, string:"initial_structure"; 290, identifier:inc_structure; 291, string:"initial"; 292, identifier:d; 293, string:"structure"; 294, identifier:s; 295, call; 296, identifier:energy; 297, binary_operator:d["energy"] * (len(s) / len(prim)); 298, assignment; 299, assignment; 300, identifier:s; 301, identifier:energy; 302, keyword_argument; 303, keyword_argument; 304, keyword_argument; 305, identifier:entry; 306, attribute; 307, string:"e_above_hull"; 308, identifier:d; 309, identifier:k; 310, pair; 311, for_in_clause; 312, identifier:d; 313, string:"task_id"; 314, attribute; 315, argument_list; 316, subscript; 317, parenthesized_expression; 318, identifier:s; 319, call; 320, identifier:energy; 321, subscript; 322, identifier:parameters; 323, dictionary_comprehension; 324, identifier:data; 325, identifier:data; 326, identifier:entry_id; 327, subscript; 328, identifier:entry; 329, identifier:data; 330, identifier:k; 331, subscript; 332, identifier:k; 333, identifier:params; 334, call; 335, identifier:get_conventional_standard_structure; 336, identifier:d; 337, string:"energy"; 338, binary_operator:len(s) / len(prim); 339, attribute; 340, argument_list; 341, identifier:d; 342, string:"energy"; 343, pair; 344, for_in_clause; 345, identifier:d; 346, string:"task_id"; 347, identifier:d; 348, identifier:k; 349, identifier:SpacegroupAnalyzer; 350, argument_list; 351, call; 352, call; 353, identifier:prim; 354, identifier:copy; 355, identifier:k; 356, subscript; 357, identifier:k; 358, identifier:params; 359, identifier:prim; 360, identifier:len; 361, argument_list; 362, identifier:len; 363, argument_list; 364, identifier:d; 365, identifier:k; 366, identifier:s; 367, identifier:prim | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 7, 27; 7, 28; 8, 29; 8, 30; 9, 31; 9, 32; 10, 33; 10, 34; 11, 35; 11, 36; 12, 37; 15, 38; 16, 39; 17, 40; 17, 41; 18, 42; 18, 43; 19, 44; 19, 45; 20, 46; 20, 47; 20, 48; 21, 49; 22, 50; 23, 51; 23, 52; 23, 53; 24, 54; 24, 55; 25, 56; 25, 57; 26, 58; 38, 59; 38, 60; 39, 61; 39, 62; 41, 63; 43, 64; 45, 65; 46, 66; 47, 67; 48, 68; 49, 69; 49, 70; 50, 71; 50, 72; 53, 73; 53, 74; 53, 75; 53, 76; 53, 77; 55, 78; 55, 79; 57, 80; 60, 81; 60, 82; 60, 83; 60, 84; 60, 85; 60, 86; 62, 87; 62, 88; 63, 89; 63, 90; 63, 91; 64, 92; 65, 93; 65, 94; 65, 95; 66, 96; 66, 97; 67, 98; 68, 99; 70, 100; 70, 101; 73, 102; 74, 103; 75, 104; 75, 105; 76, 106; 76, 107; 76, 108; 77, 109; 78, 110; 78, 111; 78, 112; 79, 113; 80, 114; 87, 115; 87, 116; 87, 117; 89, 118; 89, 119; 90, 120; 91, 121; 91, 122; 92, 123; 92, 124; 93, 125; 93, 126; 94, 127; 95, 128; 97, 129; 97, 130; 98, 131; 98, 132; 99, 133; 100, 134; 100, 135; 101, 136; 101, 137; 102, 138; 102, 139; 103, 140; 103, 141; 105, 142; 106, 143; 107, 144; 108, 145; 109, 146; 109, 147; 110, 148; 110, 149; 110, 150; 112, 151; 113, 152; 113, 153; 114, 154; 114, 155; 119, 156; 119, 157; 120, 158; 121, 159; 122, 160; 127, 161; 128, 162; 132, 163; 132, 164; 133, 165; 133, 166; 138, 167; 138, 168; 139, 169; 139, 170; 141, 171; 142, 172; 144, 173; 145, 174; 145, 175; 145, 176; 146, 177; 146, 178; 147, 179; 153, 180; 153, 181; 155, 182; 155, 183; 158, 184; 158, 185; 160, 186; 161, 187; 161, 188; 162, 189; 163, 190; 163, 191; 164, 192; 169, 193; 169, 194; 170, 195; 170, 196; 171, 197; 171, 198; 172, 199; 172, 200; 173, 201; 173, 202; 174, 203; 175, 204; 175, 205; 175, 206; 176, 207; 180, 208; 180, 209; 181, 210; 183, 211; 183, 212; 184, 213; 184, 214; 185, 215; 186, 216; 186, 217; 187, 218; 187, 219; 188, 220; 189, 221; 189, 222; 194, 223; 194, 224; 196, 225; 196, 226; 198, 227; 198, 228; 199, 229; 199, 230; 200, 231; 202, 232; 202, 233; 203, 234; 203, 235; 205, 236; 205, 237; 206, 238; 207, 239; 207, 240; 208, 241; 208, 242; 212, 243; 212, 244; 217, 245; 221, 246; 221, 247; 222, 248; 223, 249; 223, 250; 225, 251; 225, 252; 231, 253; 231, 254; 233, 255; 233, 256; 233, 257; 233, 258; 233, 259; 235, 260; 235, 261; 235, 262; 235, 263; 236, 264; 237, 265; 238, 266; 238, 267; 240, 268; 240, 269; 244, 270; 244, 271; 249, 272; 249, 273; 253, 274; 253, 275; 254, 276; 254, 277; 255, 278; 255, 279; 256, 280; 256, 281; 257, 282; 257, 283; 258, 284; 258, 285; 259, 286; 259, 287; 260, 288; 260, 289; 261, 290; 261, 291; 263, 292; 263, 293; 264, 294; 264, 295; 265, 296; 265, 297; 266, 298; 267, 299; 269, 300; 269, 301; 269, 302; 269, 303; 269, 304; 270, 305; 271, 306; 271, 307; 275, 308; 275, 309; 283, 310; 283, 311; 287, 312; 287, 313; 295, 314; 295, 315; 297, 316; 297, 317; 298, 318; 298, 319; 299, 320; 299, 321; 302, 322; 302, 323; 303, 324; 303, 325; 304, 326; 304, 327; 306, 328; 306, 329; 310, 330; 310, 331; 311, 332; 311, 333; 314, 334; 314, 335; 316, 336; 316, 337; 317, 338; 319, 339; 319, 340; 321, 341; 321, 342; 323, 343; 323, 344; 327, 345; 327, 346; 331, 347; 331, 348; 334, 349; 334, 350; 338, 351; 338, 352; 339, 353; 339, 354; 343, 355; 343, 356; 344, 357; 344, 358; 350, 359; 351, 360; 351, 361; 352, 362; 352, 363; 356, 364; 356, 365; 361, 366; 363, 367 | 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):
"""
Get a list of ComputedEntries or ComputedStructureEntries corresponding
to a chemical system, formula, or materials_id or full criteria.
Args:
chemsys_formula_id_criteria (str/dict): A chemical system
(e.g., Li-Fe-O), or formula (e.g., Fe2O3) or materials_id
(e.g., mp-1234) or full Mongo-style dict criteria.
compatible_only (bool): Whether to return only "compatible"
entries. Compatible entries are entries that have been
processed using the MaterialsProjectCompatibility class,
which performs adjustments to allow mixing of GGA and GGA+U
calculations for more accurate phase diagrams and reaction
energies.
inc_structure (str): If None, entries returned are
ComputedEntries. If inc_structure="initial",
ComputedStructureEntries with initial structures are returned.
Otherwise, ComputedStructureEntries with final structures
are returned.
property_data (list): Specify additional properties to include in
entry.data. If None, no data. Should be a subset of
supported_properties.
conventional_unit_cell (bool): Whether to get the standard
conventional unit cell
sort_by_e_above_hull (bool): Whether to sort the list of entries by
e_above_hull (will query e_above_hull as a property_data if True).
Returns:
List of ComputedEntry or ComputedStructureEntry objects.
"""
# TODO: This is a very hackish way of doing this. It should be fixed
# on the REST end.
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; 1, function_definition; 2, function_name:aos_as_list; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, return_statement; 8, string; 9, call; 10, string_content:Returns a list of atomic orbitals, sorted from lowest to highest energy; 11, identifier:sorted; 12, argument_list; 13, call; 14, keyword_argument; 15, attribute; 16, argument_list; 17, identifier:key; 18, lambda; 19, identifier:chain; 20, identifier:from_iterable; 21, list_comprehension; 22, lambda_parameters; 23, subscript; 24, binary_operator:self.aos[el] * int(self.composition[el]); 25, for_in_clause; 26, identifier:x; 27, identifier:x; 28, integer:2; 29, subscript; 30, call; 31, identifier:el; 32, attribute; 33, attribute; 34, identifier:el; 35, identifier:int; 36, argument_list; 37, identifier:self; 38, identifier:elements; 39, identifier:self; 40, identifier:aos; 41, subscript; 42, attribute; 43, identifier:el; 44, identifier:self; 45, identifier:composition | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 8, 10; 9, 11; 9, 12; 12, 13; 12, 14; 13, 15; 13, 16; 14, 17; 14, 18; 15, 19; 15, 20; 16, 21; 18, 22; 18, 23; 21, 24; 21, 25; 22, 26; 23, 27; 23, 28; 24, 29; 24, 30; 25, 31; 25, 32; 29, 33; 29, 34; 30, 35; 30, 36; 32, 37; 32, 38; 33, 39; 33, 40; 36, 41; 41, 42; 41, 43; 42, 44; 42, 45 | 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; 1, function_definition; 2, function_name:get_dataframe; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, dictionary_splat_pattern; 8, expression_statement; 9, import_statement; 10, expression_statement; 11, for_statement; 12, comment:# Monkey patch; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, expression_statement; 18, expression_statement; 19, expression_statement; 20, return_statement; 21, identifier:sort_key; 22, string:"wall_time"; 23, identifier:kwargs; 24, comment:"""
Return a pandas DataFrame with entries sorted according to `sort_key`.
"""; 25, aliased_import; 26, assignment; 27, identifier:osect; 28, call; 29, block; 30, assignment; 31, assignment; 32, assignment; 33, assignment; 34, assignment; 35, assignment; 36, assignment; 37, identifier:frame; 38, dotted_name; 39, identifier:pd; 40, identifier:frame; 41, call; 42, attribute; 43, argument_list; 44, expression_statement; 45, attribute; 46, attribute; 47, attribute; 48, attribute; 49, attribute; 50, attribute; 51, attribute; 52, attribute; 53, attribute; 54, attribute; 55, attribute; 56, attribute; 57, attribute; 58, attribute; 59, identifier:pandas; 60, attribute; 61, argument_list; 62, identifier:self; 63, identifier:order_sections; 64, identifier:sort_key; 65, assignment; 66, identifier:frame; 67, identifier:info; 68, identifier:self; 69, identifier:info; 70, identifier:frame; 71, identifier:cpu_time; 72, identifier:self; 73, identifier:cpu_time; 74, identifier:frame; 75, identifier:wall_time; 76, identifier:self; 77, identifier:wall_time; 78, identifier:frame; 79, identifier:mpi_nprocs; 80, identifier:self; 81, identifier:mpi_nprocs; 82, identifier:frame; 83, identifier:omp_nthreads; 84, identifier:self; 85, identifier:omp_nthreads; 86, identifier:frame; 87, identifier:mpi_rank; 88, identifier:self; 89, identifier:mpi_rank; 90, identifier:frame; 91, identifier:fname; 92, identifier:self; 93, identifier:fname; 94, identifier:pd; 95, identifier:DataFrame; 96, keyword_argument; 97, identifier:frame; 98, call; 99, identifier:columns; 100, attribute; 101, attribute; 102, argument_list; 103, identifier:AbinitTimerSection; 104, identifier:FIELDS; 105, identifier:frame; 106, identifier:append; 107, call; 108, keyword_argument; 109, attribute; 110, argument_list; 111, identifier:ignore_index; 112, True; 113, identifier:osect; 114, identifier:to_dict | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 6, 21; 6, 22; 7, 23; 8, 24; 9, 25; 10, 26; 11, 27; 11, 28; 11, 29; 13, 30; 14, 31; 15, 32; 16, 33; 17, 34; 18, 35; 19, 36; 20, 37; 25, 38; 25, 39; 26, 40; 26, 41; 28, 42; 28, 43; 29, 44; 30, 45; 30, 46; 31, 47; 31, 48; 32, 49; 32, 50; 33, 51; 33, 52; 34, 53; 34, 54; 35, 55; 35, 56; 36, 57; 36, 58; 38, 59; 41, 60; 41, 61; 42, 62; 42, 63; 43, 64; 44, 65; 45, 66; 45, 67; 46, 68; 46, 69; 47, 70; 47, 71; 48, 72; 48, 73; 49, 74; 49, 75; 50, 76; 50, 77; 51, 78; 51, 79; 52, 80; 52, 81; 53, 82; 53, 83; 54, 84; 54, 85; 55, 86; 55, 87; 56, 88; 56, 89; 57, 90; 57, 91; 58, 92; 58, 93; 60, 94; 60, 95; 61, 96; 65, 97; 65, 98; 96, 99; 96, 100; 98, 101; 98, 102; 100, 103; 100, 104; 101, 105; 101, 106; 102, 107; 102, 108; 107, 109; 107, 110; 108, 111; 108, 112; 109, 113; 109, 114 | def get_dataframe(self, sort_key="wall_time", **kwargs):
"""
Return a pandas DataFrame with entries sorted according to `sort_key`.
"""
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)
# Monkey patch
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; 1, function_definition; 2, function_name:order_sections; 3, parameters; 4, block; 5, identifier:self; 6, identifier:key; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, return_statement; 11, identifier:reverse; 12, True; 13, comment:"""Sort sections according to the value of key."""; 14, assignment; 15, call; 16, identifier:fsort; 17, lambda; 18, identifier:sorted; 19, argument_list; 20, lambda_parameters; 21, subscript; 22, attribute; 23, keyword_argument; 24, keyword_argument; 25, identifier:s; 26, attribute; 27, identifier:key; 28, identifier:self; 29, identifier:sections; 30, identifier:key; 31, identifier:fsort; 32, identifier:reverse; 33, identifier:reverse; 34, identifier:s; 35, identifier:__dict__ | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 7, 11; 7, 12; 8, 13; 9, 14; 10, 15; 14, 16; 14, 17; 15, 18; 15, 19; 17, 20; 17, 21; 19, 22; 19, 23; 19, 24; 20, 25; 21, 26; 21, 27; 22, 28; 22, 29; 23, 30; 23, 31; 24, 32; 24, 33; 26, 34; 26, 35 | def order_sections(self, key, reverse=True):
"""Sort sections according to the value of key."""
fsort = lambda s: s.__dict__[key]
return sorted(self.sections, key=fsort, reverse=reverse) |
0, module; 1, function_definition; 2, function_name:sort_dict; 3, parameters; 4, block; 5, identifier:d; 6, default_parameter; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, comment:# Sort kv_items according to key.; 11, if_statement; 12, comment:# Build ordered dict.; 13, return_statement; 14, identifier:key; 15, None; 16, identifier:reverse; 17, False; 18, comment:"""
Sorts a dict by value.
Args:
d: Input dictionary
key: Function which takes an tuple (key, object) and returns a value to
compare and sort by. By default, the function compares the values
of the dict i.e. key = lambda t : t[1]
reverse: Allows to reverse sort order.
Returns:
OrderedDict object whose keys are ordered according to their value.
"""; 19, assignment; 20, comparison_operator:key is None; 21, block; 22, else_clause; 23, call; 24, identifier:kv_items; 25, list_comprehension; 26, identifier:key; 27, None; 28, expression_statement; 29, block; 30, attribute; 31, argument_list; 32, identifier:kv; 33, for_in_clause; 34, call; 35, expression_statement; 36, identifier:collections; 37, identifier:OrderedDict; 38, identifier:kv_items; 39, identifier:kv; 40, call; 41, attribute; 42, argument_list; 43, call; 44, attribute; 45, argument_list; 46, identifier:kv_items; 47, identifier:sort; 48, keyword_argument; 49, keyword_argument; 50, attribute; 51, argument_list; 52, identifier:d; 53, identifier:items; 54, identifier:key; 55, lambda; 56, identifier:reverse; 57, identifier:reverse; 58, identifier:kv_items; 59, identifier:sort; 60, keyword_argument; 61, keyword_argument; 62, lambda_parameters; 63, subscript; 64, identifier:key; 65, identifier:key; 66, identifier:reverse; 67, identifier:reverse; 68, identifier:t; 69, identifier:t; 70, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 6, 14; 6, 15; 7, 16; 7, 17; 8, 18; 9, 19; 11, 20; 11, 21; 11, 22; 13, 23; 19, 24; 19, 25; 20, 26; 20, 27; 21, 28; 22, 29; 23, 30; 23, 31; 25, 32; 25, 33; 28, 34; 29, 35; 30, 36; 30, 37; 31, 38; 33, 39; 33, 40; 34, 41; 34, 42; 35, 43; 40, 44; 40, 45; 41, 46; 41, 47; 42, 48; 42, 49; 43, 50; 43, 51; 44, 52; 44, 53; 48, 54; 48, 55; 49, 56; 49, 57; 50, 58; 50, 59; 51, 60; 51, 61; 55, 62; 55, 63; 60, 64; 60, 65; 61, 66; 61, 67; 62, 68; 63, 69; 63, 70 | def sort_dict(d, key=None, reverse=False):
"""
Sorts a dict by value.
Args:
d: Input dictionary
key: Function which takes an tuple (key, object) and returns a value to
compare and sort by. By default, the function compares the values
of the dict i.e. key = lambda t : t[1]
reverse: Allows to reverse sort order.
Returns:
OrderedDict object whose keys are ordered according to their value.
"""
kv_items = [kv for kv in d.items()]
# Sort kv_items according to key.
if key is None:
kv_items.sort(key=lambda t: t[1], reverse=reverse)
else:
kv_items.sort(key=key, reverse=reverse)
# Build ordered dict.
return collections.OrderedDict(kv_items) |
0, module; 1, function_definition; 2, function_name:sort_by_efficiency; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, return_statement; 10, identifier:reverse; 11, True; 12, comment:"""Sort the configurations in place. items with highest efficiency come first"""; 13, call; 14, identifier:self; 15, attribute; 16, argument_list; 17, attribute; 18, identifier:sort; 19, keyword_argument; 20, keyword_argument; 21, identifier:self; 22, identifier:_confs; 23, identifier:key; 24, lambda; 25, identifier:reverse; 26, identifier:reverse; 27, lambda_parameters; 28, attribute; 29, identifier:c; 30, identifier:c; 31, identifier:efficiency | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 6, 10; 6, 11; 7, 12; 8, 13; 9, 14; 13, 15; 13, 16; 15, 17; 15, 18; 16, 19; 16, 20; 17, 21; 17, 22; 19, 23; 19, 24; 20, 25; 20, 26; 24, 27; 24, 28; 27, 29; 28, 30; 28, 31 | def sort_by_efficiency(self, reverse=True):
"""Sort the configurations in place. items with highest efficiency come first"""
self._confs.sort(key=lambda c: c.efficiency, reverse=reverse)
return self |
0, module; 1, function_definition; 2, function_name:sort_by_speedup; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, return_statement; 10, identifier:reverse; 11, True; 12, comment:"""Sort the configurations in place. items with highest speedup come first"""; 13, call; 14, identifier:self; 15, attribute; 16, argument_list; 17, attribute; 18, identifier:sort; 19, keyword_argument; 20, keyword_argument; 21, identifier:self; 22, identifier:_confs; 23, identifier:key; 24, lambda; 25, identifier:reverse; 26, identifier:reverse; 27, lambda_parameters; 28, attribute; 29, identifier:c; 30, identifier:c; 31, identifier:speedup | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 6, 10; 6, 11; 7, 12; 8, 13; 9, 14; 13, 15; 13, 16; 15, 17; 15, 18; 16, 19; 16, 20; 17, 21; 17, 22; 19, 23; 19, 24; 20, 25; 20, 26; 24, 27; 24, 28; 27, 29; 28, 30; 28, 31 | def sort_by_speedup(self, reverse=True):
"""Sort the configurations in place. items with highest speedup come first"""
self._confs.sort(key=lambda c: c.speedup, reverse=reverse)
return self |
0, module; 1, function_definition; 2, function_name:sort_by_mem_per_proc; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, comment:# Avoid sorting if mem_per_cpu is not available.; 9, if_statement; 10, return_statement; 11, identifier:reverse; 12, False; 13, comment:"""Sort the configurations in place. items with lowest memory per proc come first."""; 14, call; 15, block; 16, identifier:self; 17, identifier:any; 18, generator_expression; 19, expression_statement; 20, comparison_operator:c.mem_per_proc > 0.0; 21, for_in_clause; 22, call; 23, attribute; 24, float:0.0; 25, identifier:c; 26, identifier:self; 27, attribute; 28, argument_list; 29, identifier:c; 30, identifier:mem_per_proc; 31, attribute; 32, identifier:sort; 33, keyword_argument; 34, keyword_argument; 35, identifier:self; 36, identifier:_confs; 37, identifier:key; 38, lambda; 39, identifier:reverse; 40, identifier:reverse; 41, lambda_parameters; 42, attribute; 43, identifier:c; 44, identifier:c; 45, identifier:mem_per_proc | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 6, 12; 7, 13; 9, 14; 9, 15; 10, 16; 14, 17; 14, 18; 15, 19; 18, 20; 18, 21; 19, 22; 20, 23; 20, 24; 21, 25; 21, 26; 22, 27; 22, 28; 23, 29; 23, 30; 27, 31; 27, 32; 28, 33; 28, 34; 31, 35; 31, 36; 33, 37; 33, 38; 34, 39; 34, 40; 38, 41; 38, 42; 41, 43; 42, 44; 42, 45 | def sort_by_mem_per_proc(self, reverse=False):
"""Sort the configurations in place. items with lowest memory per proc come first."""
# Avoid sorting if mem_per_cpu is not available.
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; 1, function_definition; 2, function_name:add_cohp_dict; 3, parameters; 4, block; 5, identifier:self; 6, identifier:cohp_dict; 7, default_parameter; 8, expression_statement; 9, if_statement; 10, for_statement; 11, identifier:key_sort_func; 12, None; 13, comment:"""
Adds a dictionary of COHPs with an optional sorting function
for the keys.
Args:
cohp_dict: dict of the form {label: Cohp}
key_sort_func: function used to sort the cohp_dict keys.
"""; 14, identifier:key_sort_func; 15, block; 16, else_clause; 17, identifier:label; 18, identifier:keys; 19, block; 20, expression_statement; 21, block; 22, expression_statement; 23, assignment; 24, expression_statement; 25, call; 26, identifier:keys; 27, call; 28, assignment; 29, attribute; 30, argument_list; 31, identifier:sorted; 32, argument_list; 33, identifier:keys; 34, call; 35, identifier:self; 36, identifier:add_cohp; 37, identifier:label; 38, subscript; 39, call; 40, keyword_argument; 41, attribute; 42, argument_list; 43, identifier:cohp_dict; 44, identifier:label; 45, attribute; 46, argument_list; 47, identifier:key; 48, identifier:key_sort_func; 49, identifier:cohp_dict; 50, identifier:keys; 51, identifier:cohp_dict; 52, identifier:keys | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 7, 11; 7, 12; 8, 13; 9, 14; 9, 15; 9, 16; 10, 17; 10, 18; 10, 19; 15, 20; 16, 21; 19, 22; 20, 23; 21, 24; 22, 25; 23, 26; 23, 27; 24, 28; 25, 29; 25, 30; 27, 31; 27, 32; 28, 33; 28, 34; 29, 35; 29, 36; 30, 37; 30, 38; 32, 39; 32, 40; 34, 41; 34, 42; 38, 43; 38, 44; 39, 45; 39, 46; 40, 47; 40, 48; 41, 49; 41, 50; 45, 51; 45, 52 | def add_cohp_dict(self, cohp_dict, key_sort_func=None):
"""
Adds a dictionary of COHPs with an optional sorting function
for the keys.
Args:
cohp_dict: dict of the form {label: Cohp}
key_sort_func: function used to sort the cohp_dict keys.
"""
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; 1, function_definition; 2, function_name:get_line_in_facet; 3, parameters; 4, block; 5, identifier:self; 6, identifier:facet; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, while_statement; 12, return_statement; 13, comment:"""
Returns the sorted pts in a facet used to draw a line
"""; 14, assignment; 15, assignment; 16, assignment; 17, comparison_operator:len(lines) > 0; 18, block; 19, identifier:pt; 20, identifier:lines; 21, call; 22, identifier:pt; 23, list; 24, identifier:prev; 25, None; 26, call; 27, integer:0; 28, if_statement; 29, comment:# make sure the lines are connected one by one.; 30, comment:# find the way covering all pts and facets; 31, expression_statement; 32, expression_statement; 33, expression_statement; 34, identifier:list; 35, argument_list; 36, identifier:len; 37, argument_list; 38, comparison_operator:prev is None; 39, block; 40, else_clause; 41, call; 42, call; 43, assignment; 44, attribute; 45, identifier:lines; 46, identifier:prev; 47, None; 48, expression_statement; 49, block; 50, attribute; 51, argument_list; 52, attribute; 53, argument_list; 54, identifier:prev; 55, subscript; 56, identifier:facet; 57, identifier:outer_lines; 58, assignment; 59, for_statement; 60, identifier:pt; 61, identifier:append; 62, call; 63, identifier:pt; 64, identifier:append; 65, call; 66, identifier:l; 67, integer:1; 68, identifier:l; 69, call; 70, pattern_list; 71, call; 72, block; 73, attribute; 74, argument_list; 75, attribute; 76, argument_list; 77, attribute; 78, argument_list; 79, identifier:i; 80, identifier:l; 81, identifier:enumerate; 82, argument_list; 83, if_statement; 84, subscript; 85, identifier:tolist; 86, subscript; 87, identifier:tolist; 88, identifier:lines; 89, identifier:pop; 90, integer:0; 91, identifier:lines; 92, comparison_operator:prev in l; 93, block; 94, attribute; 95, subscript; 96, attribute; 97, subscript; 98, identifier:prev; 99, identifier:l; 100, expression_statement; 101, if_statement; 102, break_statement; 103, identifier:self; 104, identifier:wulff_pt_list; 105, identifier:l; 106, integer:0; 107, identifier:self; 108, identifier:wulff_pt_list; 109, identifier:l; 110, integer:1; 111, assignment; 112, comparison_operator:l[1] == prev; 113, block; 114, identifier:l; 115, call; 116, subscript; 117, identifier:prev; 118, expression_statement; 119, attribute; 120, argument_list; 121, identifier:l; 122, integer:1; 123, call; 124, identifier:lines; 125, identifier:pop; 126, identifier:i; 127, attribute; 128, argument_list; 129, identifier:l; 130, identifier:reverse | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 7, 13; 8, 14; 9, 15; 10, 16; 11, 17; 11, 18; 12, 19; 14, 20; 14, 21; 15, 22; 15, 23; 16, 24; 16, 25; 17, 26; 17, 27; 18, 28; 18, 29; 18, 30; 18, 31; 18, 32; 18, 33; 21, 34; 21, 35; 26, 36; 26, 37; 28, 38; 28, 39; 28, 40; 31, 41; 32, 42; 33, 43; 35, 44; 37, 45; 38, 46; 38, 47; 39, 48; 40, 49; 41, 50; 41, 51; 42, 52; 42, 53; 43, 54; 43, 55; 44, 56; 44, 57; 48, 58; 49, 59; 50, 60; 50, 61; 51, 62; 52, 63; 52, 64; 53, 65; 55, 66; 55, 67; 58, 68; 58, 69; 59, 70; 59, 71; 59, 72; 62, 73; 62, 74; 65, 75; 65, 76; 69, 77; 69, 78; 70, 79; 70, 80; 71, 81; 71, 82; 72, 83; 73, 84; 73, 85; 75, 86; 75, 87; 77, 88; 77, 89; 78, 90; 82, 91; 83, 92; 83, 93; 84, 94; 84, 95; 86, 96; 86, 97; 92, 98; 92, 99; 93, 100; 93, 101; 93, 102; 94, 103; 94, 104; 95, 105; 95, 106; 96, 107; 96, 108; 97, 109; 97, 110; 100, 111; 101, 112; 101, 113; 111, 114; 111, 115; 112, 116; 112, 117; 113, 118; 115, 119; 115, 120; 116, 121; 116, 122; 118, 123; 119, 124; 119, 125; 120, 126; 123, 127; 123, 128; 127, 129; 127, 130 | def get_line_in_facet(self, facet):
"""
Returns the sorted pts in a facet used to draw a line
"""
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
# make sure the lines are connected one by one.
# find the way covering all pts and facets
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; 1, function_definition; 2, function_name:get_classical_addresses_from_program; 3, parameters; 4, type; 5, block; 6, identifier:program; 7, generic_type; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, comment:# Required to use the `classical_reg.address` int attribute.; 12, comment:# See https://github.com/rigetti/pyquil/issues/388.; 13, for_statement; 14, comment:# flatten duplicates; 15, for_statement; 16, return_statement; 17, identifier:Dict; 18, type_parameter; 19, comment:"""
Returns a sorted list of classical addresses found in the MEASURE instructions in the program.
:param Program program: The program from which to get the classical addresses.
:return: A mapping from memory region names to lists of offsets appearing in the program.
"""; 20, assignment; 21, assignment; 22, identifier:instr; 23, identifier:program; 24, block; 25, pattern_list; 26, call; 27, block; 28, identifier:flattened_addresses; 29, type; 30, type; 31, identifier:addresses; 32, type; 33, call; 34, identifier:flattened_addresses; 35, dictionary; 36, if_statement; 37, identifier:k; 38, identifier:v; 39, attribute; 40, argument_list; 41, expression_statement; 42, expression_statement; 43, expression_statement; 44, identifier:str; 45, generic_type; 46, generic_type; 47, identifier:defaultdict; 48, argument_list; 49, boolean_operator; 50, block; 51, identifier:addresses; 52, identifier:items; 53, assignment; 54, call; 55, assignment; 56, identifier:List; 57, type_parameter; 58, identifier:Dict; 59, type_parameter; 60, identifier:list; 61, call; 62, attribute; 63, expression_statement; 64, identifier:reduced_list; 65, call; 66, attribute; 67, argument_list; 68, subscript; 69, identifier:reduced_list; 70, type; 71, type; 72, type; 73, identifier:isinstance; 74, argument_list; 75, identifier:instr; 76, identifier:classical_reg; 77, call; 78, identifier:list; 79, argument_list; 80, identifier:reduced_list; 81, identifier:sort; 82, identifier:flattened_addresses; 83, identifier:k; 84, identifier:int; 85, identifier:str; 86, generic_type; 87, identifier:instr; 88, identifier:Measurement; 89, attribute; 90, argument_list; 91, call; 92, identifier:List; 93, type_parameter; 94, subscript; 95, identifier:append; 96, attribute; 97, identifier:set; 98, argument_list; 99, type; 100, identifier:addresses; 101, attribute; 102, attribute; 103, identifier:offset; 104, identifier:v; 105, identifier:int; 106, attribute; 107, identifier:name; 108, identifier:instr; 109, identifier:classical_reg; 110, identifier:instr; 111, identifier:classical_reg | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 4, 7; 5, 8; 5, 9; 5, 10; 5, 11; 5, 12; 5, 13; 5, 14; 5, 15; 5, 16; 7, 17; 7, 18; 8, 19; 9, 20; 10, 21; 13, 22; 13, 23; 13, 24; 15, 25; 15, 26; 15, 27; 16, 28; 18, 29; 18, 30; 20, 31; 20, 32; 20, 33; 21, 34; 21, 35; 24, 36; 25, 37; 25, 38; 26, 39; 26, 40; 27, 41; 27, 42; 27, 43; 29, 44; 30, 45; 32, 46; 33, 47; 33, 48; 36, 49; 36, 50; 39, 51; 39, 52; 41, 53; 42, 54; 43, 55; 45, 56; 45, 57; 46, 58; 46, 59; 48, 60; 49, 61; 49, 62; 50, 63; 53, 64; 53, 65; 54, 66; 54, 67; 55, 68; 55, 69; 57, 70; 59, 71; 59, 72; 61, 73; 61, 74; 62, 75; 62, 76; 63, 77; 65, 78; 65, 79; 66, 80; 66, 81; 68, 82; 68, 83; 70, 84; 71, 85; 72, 86; 74, 87; 74, 88; 77, 89; 77, 90; 79, 91; 86, 92; 86, 93; 89, 94; 89, 95; 90, 96; 91, 97; 91, 98; 93, 99; 94, 100; 94, 101; 96, 102; 96, 103; 98, 104; 99, 105; 101, 106; 101, 107; 102, 108; 102, 109; 106, 110; 106, 111 | def get_classical_addresses_from_program(program) -> Dict[str, List[int]]:
"""
Returns a sorted list of classical addresses found in the MEASURE instructions in the program.
:param Program program: The program from which to get the classical addresses.
:return: A mapping from memory region names to lists of offsets appearing in the program.
"""
addresses: Dict[str, List[int]] = defaultdict(list)
flattened_addresses = {}
# Required to use the `classical_reg.address` int attribute.
# See https://github.com/rigetti/pyquil/issues/388.
for instr in program:
if isinstance(instr, Measurement) and instr.classical_reg:
addresses[instr.classical_reg.name].append(instr.classical_reg.offset)
# flatten duplicates
for k, v in addresses.items():
reduced_list = list(set(v))
reduced_list.sort()
flattened_addresses[k] = reduced_list
return flattened_addresses |
0, module; 1, function_definition; 2, function_name:percolate_declares; 3, parameters; 4, type; 5, block; 6, typed_parameter; 7, identifier:Program; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, for_statement; 12, expression_statement; 13, expression_statement; 14, return_statement; 15, identifier:program; 16, type; 17, comment:"""
Move all the DECLARE statements to the top of the program. Return a fresh obejct.
:param program: Perhaps jumbled program.
:return: Program with DECLAREs all at the top and otherwise the same sorted contents.
"""; 18, assignment; 19, assignment; 20, identifier:instr; 21, identifier:program; 22, block; 23, assignment; 24, assignment; 25, identifier:p; 26, identifier:Program; 27, identifier:declare_program; 28, call; 29, identifier:instrs_program; 30, call; 31, if_statement; 32, identifier:p; 33, binary_operator:declare_program + instrs_program; 34, attribute; 35, attribute; 36, identifier:Program; 37, argument_list; 38, identifier:Program; 39, argument_list; 40, call; 41, block; 42, else_clause; 43, identifier:declare_program; 44, identifier:instrs_program; 45, identifier:p; 46, identifier:_defined_gates; 47, identifier:program; 48, identifier:_defined_gates; 49, identifier:isinstance; 50, argument_list; 51, expression_statement; 52, block; 53, identifier:instr; 54, identifier:Declare; 55, augmented_assignment; 56, expression_statement; 57, identifier:declare_program; 58, identifier:instr; 59, augmented_assignment; 60, identifier:instrs_program; 61, identifier:instr | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 4, 7; 5, 8; 5, 9; 5, 10; 5, 11; 5, 12; 5, 13; 5, 14; 6, 15; 6, 16; 8, 17; 9, 18; 10, 19; 11, 20; 11, 21; 11, 22; 12, 23; 13, 24; 14, 25; 16, 26; 18, 27; 18, 28; 19, 29; 19, 30; 22, 31; 23, 32; 23, 33; 24, 34; 24, 35; 28, 36; 28, 37; 30, 38; 30, 39; 31, 40; 31, 41; 31, 42; 33, 43; 33, 44; 34, 45; 34, 46; 35, 47; 35, 48; 40, 49; 40, 50; 41, 51; 42, 52; 50, 53; 50, 54; 51, 55; 52, 56; 55, 57; 55, 58; 56, 59; 59, 60; 59, 61 | def percolate_declares(program: Program) -> Program:
"""
Move all the DECLARE statements to the top of the program. Return a fresh obejct.
:param program: Perhaps jumbled program.
:return: Program with DECLAREs all at the top and otherwise the same sorted contents.
"""
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; 1, function_definition; 2, function_name:text_search; 3, parameters; 4, block; 5, identifier:conn; 6, identifier:search; 7, keyword_separator; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, default_parameter; 13, default_parameter; 14, expression_statement; 15, raise_statement; 16, identifier:language; 17, string; 18, identifier:case_sensitive; 19, False; 20, identifier:diacritic_sensitive; 21, False; 22, identifier:text_score; 23, False; 24, identifier:limit; 25, integer:0; 26, identifier:table; 27, None; 28, comment:"""Return all the assets that match the text search.
The results are sorted by text score.
For more information about the behavior of text search on MongoDB see
https://docs.mongodb.com/manual/reference/operator/query/text/#behavior
Args:
search (str): Text search string to query the text index
language (str, optional): The language for the search and the rules for
stemmer and tokenizer. If the language is ``None`` text search uses
simple tokenization and no stemming.
case_sensitive (bool, optional): Enable or disable case sensitive
search.
diacritic_sensitive (bool, optional): Enable or disable case sensitive
diacritic search.
text_score (bool, optional): If ``True`` returns the text score with
each document.
limit (int, optional): Limit the number of returned documents.
Returns:
:obj:`list` of :obj:`dict`: a list of assets
Raises:
OperationError: If the backend does not support text search
"""; 29, call; 30, string_content:english; 31, identifier:OperationError; 32, argument_list; 33, concatenated_string; 34, string; 35, string; 36, string_content:This query is only supported when running; 37, string_content:BigchainDB with MongoDB as the backend. | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 3, 13; 4, 14; 4, 15; 8, 16; 8, 17; 9, 18; 9, 19; 10, 20; 10, 21; 11, 22; 11, 23; 12, 24; 12, 25; 13, 26; 13, 27; 14, 28; 15, 29; 17, 30; 29, 31; 29, 32; 32, 33; 33, 34; 33, 35; 34, 36; 35, 37 | def text_search(conn, search, *, language='english', case_sensitive=False,
diacritic_sensitive=False, text_score=False, limit=0, table=None):
"""Return all the assets that match the text search.
The results are sorted by text score.
For more information about the behavior of text search on MongoDB see
https://docs.mongodb.com/manual/reference/operator/query/text/#behavior
Args:
search (str): Text search string to query the text index
language (str, optional): The language for the search and the rules for
stemmer and tokenizer. If the language is ``None`` text search uses
simple tokenization and no stemming.
case_sensitive (bool, optional): Enable or disable case sensitive
search.
diacritic_sensitive (bool, optional): Enable or disable case sensitive
diacritic search.
text_score (bool, optional): If ``True`` returns the text score with
each document.
limit (int, optional): Limit the number of returned documents.
Returns:
:obj:`list` of :obj:`dict`: a list of assets
Raises:
OperationError: If the backend does not support text search
"""
raise OperationError('This query is only supported when running '
'BigchainDB with MongoDB as the backend.') |
0, module; 1, function_definition; 2, function_name:get_utxoset_merkle_root; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, comment:# TODO Once ready, use the already pre-computed utxo_hash field.; 9, comment:# See common/transactions.py for details.; 10, expression_statement; 11, comment:# TODO Notice the sorted call!; 12, return_statement; 13, comment:"""Returns the merkle root of the utxoset. This implies that
the utxoset is first put into a merkle tree.
For now, the merkle tree and its root will be computed each
time. This obviously is not efficient and a better approach
that limits the repetition of the same computation when
unnecesary should be sought. For instance, future optimizations
could simply re-compute the branches of the tree that were
affected by a change.
The transaction hash (id) and output index should be sufficient
to uniquely identify a utxo, and consequently only that
information from a utxo record is needed to compute the merkle
root. Hence, each node of the merkle tree should contain the
tuple (txid, output_index).
.. important:: The leaves of the tree will need to be sorted in
some kind of lexicographical order.
Returns:
str: Merkle root in hexadecimal form.
"""; 14, assignment; 15, assignment; 16, call; 17, identifier:utxoset; 18, call; 19, identifier:hashes; 20, list_comprehension; 21, identifier:merkleroot; 22, argument_list; 23, attribute; 24, argument_list; 25, call; 26, for_in_clause; 27, call; 28, attribute; 29, identifier:get_unspent_outputs; 30, attribute; 31, attribute; 32, argument_list; 33, identifier:utxo; 34, identifier:utxoset; 35, identifier:sorted; 36, argument_list; 37, identifier:backend; 38, identifier:query; 39, identifier:self; 40, identifier:connection; 41, call; 42, identifier:digest; 43, identifier:hashes; 44, identifier:sha3_256; 45, argument_list; 46, call; 47, attribute; 48, argument_list; 49, call; 50, identifier:encode; 51, attribute; 52, argument_list; 53, string; 54, identifier:format; 55, subscript; 56, subscript; 57, string_content:{}{}; 58, identifier:utxo; 59, string; 60, identifier:utxo; 61, string; 62, string_content:transaction_id; 63, string_content:output_index | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 6, 13; 7, 14; 10, 15; 12, 16; 14, 17; 14, 18; 15, 19; 15, 20; 16, 21; 16, 22; 18, 23; 18, 24; 20, 25; 20, 26; 22, 27; 23, 28; 23, 29; 24, 30; 25, 31; 25, 32; 26, 33; 26, 34; 27, 35; 27, 36; 28, 37; 28, 38; 30, 39; 30, 40; 31, 41; 31, 42; 36, 43; 41, 44; 41, 45; 45, 46; 46, 47; 46, 48; 47, 49; 47, 50; 49, 51; 49, 52; 51, 53; 51, 54; 52, 55; 52, 56; 53, 57; 55, 58; 55, 59; 56, 60; 56, 61; 59, 62; 61, 63 | def get_utxoset_merkle_root(self):
"""Returns the merkle root of the utxoset. This implies that
the utxoset is first put into a merkle tree.
For now, the merkle tree and its root will be computed each
time. This obviously is not efficient and a better approach
that limits the repetition of the same computation when
unnecesary should be sought. For instance, future optimizations
could simply re-compute the branches of the tree that were
affected by a change.
The transaction hash (id) and output index should be sufficient
to uniquely identify a utxo, and consequently only that
information from a utxo record is needed to compute the merkle
root. Hence, each node of the merkle tree should contain the
tuple (txid, output_index).
.. important:: The leaves of the tree will need to be sorted in
some kind of lexicographical order.
Returns:
str: Merkle root in hexadecimal form.
"""
utxoset = backend.query.get_unspent_outputs(self.connection)
# TODO Once ready, use the already pre-computed utxo_hash field.
# See common/transactions.py for details.
hashes = [
sha3_256(
'{}{}'.format(utxo['transaction_id'], utxo['output_index']).encode()
).digest() for utxo in utxoset
]
# TODO Notice the sorted call!
return merkleroot(sorted(hashes)) |
0, module; 1, function_definition; 2, function_name:log_time; 3, parameters; 4, type; 5, block; 6, typed_parameter; 7, generic_type; 8, expression_statement; 9, function_definition; 10, return_statement; 11, identifier:func; 12, type; 13, identifier:Callable; 14, type_parameter; 15, comment:"""Log the time it takes to run a function. It's sort of like timeit, but
prettier.
"""; 16, function_name:wrapper; 17, parameters; 18, block; 19, identifier:wrapper; 20, generic_type; 21, type; 22, type; 23, list_splat_pattern; 24, dictionary_splat_pattern; 25, expression_statement; 26, expression_statement; 27, expression_statement; 28, expression_statement; 29, return_statement; 30, identifier:Callable; 31, type_parameter; 32, ellipsis:...; 33, identifier:Any; 34, identifier:args; 35, identifier:kwargs; 36, assignment; 37, call; 38, assignment; 39, call; 40, identifier:ret; 41, type; 42, type; 43, identifier:start_time; 44, call; 45, attribute; 46, argument_list; 47, identifier:ret; 48, call; 49, attribute; 50, argument_list; 51, ellipsis:...; 52, identifier:Any; 53, attribute; 54, argument_list; 55, identifier:log; 56, identifier:info; 57, string:"%s starting..."; 58, call; 59, identifier:func; 60, argument_list; 61, identifier:log; 62, identifier:info; 63, string:"%s finished (%s)"; 64, call; 65, call; 66, identifier:time; 67, identifier:time; 68, attribute; 69, argument_list; 70, list_splat; 71, dictionary_splat; 72, attribute; 73, argument_list; 74, attribute; 75, argument_list; 76, attribute; 77, identifier:title; 78, identifier:args; 79, identifier:kwargs; 80, attribute; 81, identifier:title; 82, identifier:datetime; 83, identifier:timedelta; 84, keyword_argument; 85, identifier:func; 86, identifier:__name__; 87, identifier:func; 88, identifier:__name__; 89, identifier:seconds; 90, call; 91, identifier:int; 92, argument_list; 93, binary_operator:time.time() - start_time; 94, call; 95, identifier:start_time; 96, attribute; 97, argument_list; 98, identifier:time; 99, identifier:time | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 4, 7; 5, 8; 5, 9; 5, 10; 6, 11; 6, 12; 7, 13; 7, 14; 8, 15; 9, 16; 9, 17; 9, 18; 10, 19; 12, 20; 14, 21; 14, 22; 17, 23; 17, 24; 18, 25; 18, 26; 18, 27; 18, 28; 18, 29; 20, 30; 20, 31; 21, 32; 22, 33; 23, 34; 24, 35; 25, 36; 26, 37; 27, 38; 28, 39; 29, 40; 31, 41; 31, 42; 36, 43; 36, 44; 37, 45; 37, 46; 38, 47; 38, 48; 39, 49; 39, 50; 41, 51; 42, 52; 44, 53; 44, 54; 45, 55; 45, 56; 46, 57; 46, 58; 48, 59; 48, 60; 49, 61; 49, 62; 50, 63; 50, 64; 50, 65; 53, 66; 53, 67; 58, 68; 58, 69; 60, 70; 60, 71; 64, 72; 64, 73; 65, 74; 65, 75; 68, 76; 68, 77; 70, 78; 71, 79; 72, 80; 72, 81; 74, 82; 74, 83; 75, 84; 76, 85; 76, 86; 80, 87; 80, 88; 84, 89; 84, 90; 90, 91; 90, 92; 92, 93; 93, 94; 93, 95; 94, 96; 94, 97; 96, 98; 96, 99 | def log_time(func: Callable[..., Any]) -> Callable[..., Any]:
"""Log the time it takes to run a function. It's sort of like timeit, but
prettier.
"""
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; 1, function_definition; 2, function_name:_get_mro; 3, parameters; 4, block; 5, identifier:cls; 6, expression_statement; 7, if_statement; 8, return_statement; 9, comment:"""
Returns the bases classes for cls sorted by the MRO.
Works around an issue on Jython where inspect.getmro will not return all
base classes if multiple classes share the same name. Instead, this
function will return a tuple containing the class itself, and the contents
of cls.__bases__. See https://github.com/pypa/setuptools/issues/1024.
"""; 10, comparison_operator:platform.python_implementation() == "Jython"; 11, block; 12, call; 13, call; 14, string:"Jython"; 15, return_statement; 16, attribute; 17, argument_list; 18, attribute; 19, argument_list; 20, binary_operator:(cls,) + cls.__bases__; 21, identifier:inspect; 22, identifier:getmro; 23, identifier:cls; 24, identifier:platform; 25, identifier:python_implementation; 26, tuple; 27, attribute; 28, identifier:cls; 29, identifier:cls; 30, identifier:__bases__ | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 7, 11; 8, 12; 10, 13; 10, 14; 11, 15; 12, 16; 12, 17; 13, 18; 13, 19; 15, 20; 16, 21; 16, 22; 17, 23; 18, 24; 18, 25; 20, 26; 20, 27; 26, 28; 27, 29; 27, 30 | def _get_mro(cls):
"""
Returns the bases classes for cls sorted by the MRO.
Works around an issue on Jython where inspect.getmro will not return all
base classes if multiple classes share the same name. Instead, this
function will return a tuple containing the class itself, and the contents
of cls.__bases__. See https://github.com/pypa/setuptools/issues/1024.
"""
if platform.python_implementation() == "Jython":
return (cls,) + cls.__bases__
return inspect.getmro(cls) |
0, module; 1, function_definition; 2, function_name:sorted_walk; 3, parameters; 4, block; 5, identifier:dir; 6, expression_statement; 7, for_statement; 8, comment:"""Do os.walk in a reproducible way,
independent of indeterministic filesystem readdir order
"""; 9, pattern_list; 10, call; 11, block; 12, identifier:base; 13, identifier:dirs; 14, identifier:files; 15, attribute; 16, argument_list; 17, expression_statement; 18, expression_statement; 19, expression_statement; 20, identifier:os; 21, identifier:walk; 22, identifier:dir; 23, call; 24, call; 25, yield; 26, attribute; 27, argument_list; 28, attribute; 29, argument_list; 30, expression_list; 31, identifier:dirs; 32, identifier:sort; 33, identifier:files; 34, identifier:sort; 35, identifier:base; 36, identifier:dirs; 37, identifier:files | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 6, 8; 7, 9; 7, 10; 7, 11; 9, 12; 9, 13; 9, 14; 10, 15; 10, 16; 11, 17; 11, 18; 11, 19; 15, 20; 15, 21; 16, 22; 17, 23; 18, 24; 19, 25; 23, 26; 23, 27; 24, 28; 24, 29; 25, 30; 26, 31; 26, 32; 28, 33; 28, 34; 30, 35; 30, 36; 30, 37 | def sorted_walk(dir):
"""Do os.walk in a reproducible way,
independent of indeterministic filesystem readdir order
"""
for base, dirs, files in os.walk(dir):
dirs.sort()
files.sort()
yield base, dirs, files |
0, module; 1, function_definition; 2, function_name:_get_all_ns_packages; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, return_statement; 9, comment:"""Return sorted list of all package namespaces"""; 10, assignment; 11, call; 12, identifier:pkgs; 13, boolean_operator; 14, identifier:sorted; 15, argument_list; 16, attribute; 17, list; 18, call; 19, attribute; 20, identifier:namespace_packages; 21, identifier:flatten; 22, argument_list; 23, identifier:self; 24, identifier:distribution; 25, call; 26, identifier:map; 27, argument_list; 28, attribute; 29, identifier:pkgs; 30, identifier:self; 31, identifier:_pkg_names | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 8, 11; 10, 12; 10, 13; 11, 14; 11, 15; 13, 16; 13, 17; 15, 18; 16, 19; 16, 20; 18, 21; 18, 22; 19, 23; 19, 24; 22, 25; 25, 26; 25, 27; 27, 28; 27, 29; 28, 30; 28, 31 | def _get_all_ns_packages(self):
"""Return sorted list of all package namespaces"""
pkgs = self.distribution.namespace_packages or []
return sorted(flatten(map(self._pkg_names, pkgs))) |
0, module; 1, function_definition; 2, function_name:flatten_comments; 3, parameters; 4, block; 5, identifier:comments; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, expression_statement; 11, while_statement; 12, return_statement; 13, identifier:root_level; 14, integer:0; 15, comment:"""
Flatten a PRAW comment tree while preserving the nested level of each
comment via the `nested_level` attribute.
There are a couple of different ways that the input comment list can be
organized depending on its source:
1. Comments that are returned from the get_submission() api call.
In this case, the comments list will contain only top level
comments and replies will be attached to those comments via
the `comment.replies` property.
2. Comments that are returned from the comments() method on a
MoreComments object. In this case, the api returns all of the
comments and replies as a flat list. We need to sort out which
ones are replies to other comments by looking at the parent_id
parameter and checking if the id matches another comment.
In addition, there is a bug in praw where a MoreComments object that is
also a reply will be added below the comment as a sibling instead of
a child. So it is especially important that this method is robust and
double-checks all of the parent_id's of the comments.
Reference:
https://github.com/praw-dev/praw/issues/391
"""; 16, assignment; 17, identifier:item; 18, identifier:stack; 19, block; 20, assignment; 21, identifier:stack; 22, block; 23, identifier:retval; 24, identifier:stack; 25, subscript; 26, expression_statement; 27, pattern_list; 28, expression_list; 29, expression_statement; 30, comment:# The MoreComments item count should never be zero, discard it if; 31, comment:# it is. Need to look into this further.; 32, if_statement; 33, if_statement; 34, comment:# Add all of the attached replies to the front of the stack to be; 35, comment:# parsed separately; 36, if_statement; 37, comment:# The comment is now a potential parent for the items that are; 38, comment:# remaining on the stack.; 39, expression_statement; 40, expression_statement; 41, identifier:comments; 42, slice; 43, assignment; 44, identifier:retval; 45, identifier:parent_candidates; 46, list; 47, dictionary; 48, assignment; 49, boolean_operator; 50, block; 51, attribute; 52, comment:# Search the list of previous comments for a possible parent; 53, comment:# The match is based off of the parent_id parameter E.g.; 54, comment:# parent.id = c0tprcm; 55, comment:# child.parent_id = t1_c0tprcm; 56, block; 57, call; 58, block; 59, assignment; 60, call; 61, attribute; 62, identifier:root_level; 63, identifier:item; 64, call; 65, call; 66, comparison_operator:item.count == 0; 67, continue_statement; 68, identifier:item; 69, identifier:parent_id; 70, expression_statement; 71, if_statement; 72, identifier:hasattr; 73, argument_list; 74, for_statement; 75, expression_statement; 76, subscript; 77, identifier:item; 78, attribute; 79, argument_list; 80, identifier:item; 81, identifier:nested_level; 82, attribute; 83, argument_list; 84, identifier:isinstance; 85, argument_list; 86, attribute; 87, integer:0; 88, assignment; 89, identifier:parent; 90, block; 91, identifier:item; 92, string; 93, identifier:n; 94, attribute; 95, block; 96, assignment; 97, identifier:parent_candidates; 98, attribute; 99, identifier:retval; 100, identifier:append; 101, identifier:item; 102, identifier:stack; 103, identifier:pop; 104, integer:0; 105, identifier:item; 106, attribute; 107, identifier:item; 108, identifier:count; 109, identifier:parent; 110, call; 111, expression_statement; 112, string_content:replies; 113, identifier:item; 114, identifier:replies; 115, expression_statement; 116, subscript; 117, attribute; 118, identifier:item; 119, identifier:id; 120, attribute; 121, identifier:MoreComments; 122, attribute; 123, argument_list; 124, assignment; 125, assignment; 126, identifier:stack; 127, slice; 128, identifier:item; 129, identifier:replies; 130, identifier:praw; 131, identifier:objects; 132, identifier:parent_candidates; 133, identifier:get; 134, subscript; 135, attribute; 136, binary_operator:parent.nested_level + 1; 137, attribute; 138, binary_operator:item.nested_level + 1; 139, integer:0; 140, integer:0; 141, attribute; 142, slice; 143, identifier:item; 144, identifier:nested_level; 145, attribute; 146, integer:1; 147, identifier:n; 148, identifier:nested_level; 149, attribute; 150, integer:1; 151, identifier:item; 152, identifier:parent_id; 153, integer:3; 154, identifier:parent; 155, identifier:nested_level; 156, identifier:item; 157, identifier:nested_level | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 6, 13; 6, 14; 7, 15; 8, 16; 9, 17; 9, 18; 9, 19; 10, 20; 11, 21; 11, 22; 12, 23; 16, 24; 16, 25; 19, 26; 20, 27; 20, 28; 22, 29; 22, 30; 22, 31; 22, 32; 22, 33; 22, 34; 22, 35; 22, 36; 22, 37; 22, 38; 22, 39; 22, 40; 25, 41; 25, 42; 26, 43; 27, 44; 27, 45; 28, 46; 28, 47; 29, 48; 32, 49; 32, 50; 33, 51; 33, 52; 33, 53; 33, 54; 33, 55; 33, 56; 36, 57; 36, 58; 39, 59; 40, 60; 43, 61; 43, 62; 48, 63; 48, 64; 49, 65; 49, 66; 50, 67; 51, 68; 51, 69; 56, 70; 56, 71; 57, 72; 57, 73; 58, 74; 58, 75; 59, 76; 59, 77; 60, 78; 60, 79; 61, 80; 61, 81; 64, 82; 64, 83; 65, 84; 65, 85; 66, 86; 66, 87; 70, 88; 71, 89; 71, 90; 73, 91; 73, 92; 74, 93; 74, 94; 74, 95; 75, 96; 76, 97; 76, 98; 78, 99; 78, 100; 79, 101; 82, 102; 82, 103; 83, 104; 85, 105; 85, 106; 86, 107; 86, 108; 88, 109; 88, 110; 90, 111; 92, 112; 94, 113; 94, 114; 95, 115; 96, 116; 96, 117; 98, 118; 98, 119; 106, 120; 106, 121; 110, 122; 110, 123; 111, 124; 115, 125; 116, 126; 116, 127; 117, 128; 117, 129; 120, 130; 120, 131; 122, 132; 122, 133; 123, 134; 124, 135; 124, 136; 125, 137; 125, 138; 127, 139; 127, 140; 134, 141; 134, 142; 135, 143; 135, 144; 136, 145; 136, 146; 137, 147; 137, 148; 138, 149; 138, 150; 141, 151; 141, 152; 142, 153; 145, 154; 145, 155; 149, 156; 149, 157 | def flatten_comments(comments, root_level=0):
"""
Flatten a PRAW comment tree while preserving the nested level of each
comment via the `nested_level` attribute.
There are a couple of different ways that the input comment list can be
organized depending on its source:
1. Comments that are returned from the get_submission() api call.
In this case, the comments list will contain only top level
comments and replies will be attached to those comments via
the `comment.replies` property.
2. Comments that are returned from the comments() method on a
MoreComments object. In this case, the api returns all of the
comments and replies as a flat list. We need to sort out which
ones are replies to other comments by looking at the parent_id
parameter and checking if the id matches another comment.
In addition, there is a bug in praw where a MoreComments object that is
also a reply will be added below the comment as a sibling instead of
a child. So it is especially important that this method is robust and
double-checks all of the parent_id's of the comments.
Reference:
https://github.com/praw-dev/praw/issues/391
"""
stack = comments[:]
for item in stack:
item.nested_level = root_level
retval, parent_candidates = [], {}
while stack:
item = stack.pop(0)
# The MoreComments item count should never be zero, discard it if
# it is. Need to look into this further.
if isinstance(item, praw.objects.MoreComments) and item.count == 0:
continue
if item.parent_id:
# Search the list of previous comments for a possible parent
# The match is based off of the parent_id parameter E.g.
# parent.id = c0tprcm
# child.parent_id = t1_c0tprcm
parent = parent_candidates.get(item.parent_id[3:])
if parent:
item.nested_level = parent.nested_level + 1
# Add all of the attached replies to the front of the stack to be
# parsed separately
if hasattr(item, 'replies'):
for n in item.replies:
n.nested_level = item.nested_level + 1
stack[0:0] = item.replies
# The comment is now a potential parent for the items that are
# remaining on the stack.
parent_candidates[item.id] = item
retval.append(item)
return retval |
0, module; 1, function_definition; 2, function_name:get_domain_listing; 3, parameters; 4, block; 5, identifier:self; 6, identifier:domain; 7, default_parameter; 8, default_parameter; 9, list_splat_pattern; 10, dictionary_splat_pattern; 11, expression_statement; 12, comment:# Verify arguments; 13, if_statement; 14, if_statement; 15, if_statement; 16, expression_statement; 17, if_statement; 18, if_statement; 19, return_statement; 20, identifier:sort; 21, string; 22, identifier:period; 23, None; 24, identifier:args; 25, identifier:kwargs; 26, comment:"""Return a get_content generator for submissions by domain.
Corresponds to the submissions provided by
``https://www.reddit.com/domain/{domain}``.
:param domain: The domain to generate a submission listing for.
:param sort: When provided must be one of 'hot', 'new', 'rising',
'controversial, 'gilded', or 'top'. Defaults to 'hot'.
:param period: When sort is either 'controversial', or 'top' the period
can be either None (for account default), 'all', 'year', 'month',
'week', 'day', or 'hour'.
The additional parameters are passed directly into
:meth:`.get_content`. Note: the `url` parameter cannot be altered.
"""; 27, comparison_operator:sort not in ('controversial', 'hot', 'new', 'rising', 'top',
'gilded'); 28, block; 29, comparison_operator:period not in (None, 'all', 'day', 'hour', 'month', 'week', 'year'); 30, block; 31, boolean_operator; 32, block; 33, assignment; 34, comparison_operator:sort != 'hot'; 35, block; 36, identifier:period; 37, comment:# Set or overwrite params 't' parameter; 38, block; 39, call; 40, string_content:hot; 41, identifier:sort; 42, tuple; 43, raise_statement; 44, identifier:period; 45, tuple; 46, raise_statement; 47, comparison_operator:sort not in ('controversial', 'top'); 48, identifier:period; 49, raise_statement; 50, identifier:url; 51, call; 52, identifier:sort; 53, string; 54, expression_statement; 55, expression_statement; 56, attribute; 57, argument_list; 58, string; 59, string; 60, string; 61, string; 62, string; 63, string; 64, call; 65, None; 66, string; 67, string; 68, string; 69, string; 70, string; 71, string; 72, call; 73, identifier:sort; 74, tuple; 75, call; 76, attribute; 77, argument_list; 78, string_content:hot; 79, augmented_assignment; 80, assignment; 81, identifier:self; 82, identifier:get_content; 83, identifier:url; 84, list_splat; 85, dictionary_splat; 86, string_content:controversial; 87, string_content:hot; 88, string_content:new; 89, string_content:rising; 90, string_content:top; 91, string_content:gilded; 92, identifier:TypeError; 93, argument_list; 94, string_content:all; 95, string_content:day; 96, string_content:hour; 97, string_content:month; 98, string_content:week; 99, string_content:year; 100, identifier:TypeError; 101, argument_list; 102, string; 103, string; 104, identifier:TypeError; 105, argument_list; 106, subscript; 107, identifier:format; 108, keyword_argument; 109, identifier:url; 110, identifier:sort; 111, subscript; 112, identifier:period; 113, identifier:args; 114, identifier:kwargs; 115, string; 116, string; 117, string_content:controversial; 118, string_content:top; 119, string; 120, attribute; 121, string; 122, identifier:domain; 123, identifier:domain; 124, call; 125, string; 126, string_content:Invalid sort parameter.; 127, string_content:Invalid period parameter.; 128, string_content:Period cannot be set for that sort argument.; 129, identifier:self; 130, identifier:config; 131, string_content:domain; 132, attribute; 133, argument_list; 134, string_content:t; 135, identifier:kwargs; 136, identifier:setdefault; 137, string; 138, dictionary; 139, string_content:params | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 7, 20; 7, 21; 8, 22; 8, 23; 9, 24; 10, 25; 11, 26; 13, 27; 13, 28; 14, 29; 14, 30; 15, 31; 15, 32; 16, 33; 17, 34; 17, 35; 18, 36; 18, 37; 18, 38; 19, 39; 21, 40; 27, 41; 27, 42; 28, 43; 29, 44; 29, 45; 30, 46; 31, 47; 31, 48; 32, 49; 33, 50; 33, 51; 34, 52; 34, 53; 35, 54; 38, 55; 39, 56; 39, 57; 42, 58; 42, 59; 42, 60; 42, 61; 42, 62; 42, 63; 43, 64; 45, 65; 45, 66; 45, 67; 45, 68; 45, 69; 45, 70; 45, 71; 46, 72; 47, 73; 47, 74; 49, 75; 51, 76; 51, 77; 53, 78; 54, 79; 55, 80; 56, 81; 56, 82; 57, 83; 57, 84; 57, 85; 58, 86; 59, 87; 60, 88; 61, 89; 62, 90; 63, 91; 64, 92; 64, 93; 66, 94; 67, 95; 68, 96; 69, 97; 70, 98; 71, 99; 72, 100; 72, 101; 74, 102; 74, 103; 75, 104; 75, 105; 76, 106; 76, 107; 77, 108; 79, 109; 79, 110; 80, 111; 80, 112; 84, 113; 85, 114; 93, 115; 101, 116; 102, 117; 103, 118; 105, 119; 106, 120; 106, 121; 108, 122; 108, 123; 111, 124; 111, 125; 115, 126; 116, 127; 119, 128; 120, 129; 120, 130; 121, 131; 124, 132; 124, 133; 125, 134; 132, 135; 132, 136; 133, 137; 133, 138; 137, 139 | def get_domain_listing(self, domain, sort='hot', period=None, *args,
**kwargs):
"""Return a get_content generator for submissions by domain.
Corresponds to the submissions provided by
``https://www.reddit.com/domain/{domain}``.
:param domain: The domain to generate a submission listing for.
:param sort: When provided must be one of 'hot', 'new', 'rising',
'controversial, 'gilded', or 'top'. Defaults to 'hot'.
:param period: When sort is either 'controversial', or 'top' the period
can be either None (for account default), 'all', 'year', 'month',
'week', 'day', or 'hour'.
The additional parameters are passed directly into
:meth:`.get_content`. Note: the `url` parameter cannot be altered.
"""
# Verify arguments
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: # Set or overwrite params 't' parameter
kwargs.setdefault('params', {})['t'] = period
return self.get_content(url, *args, **kwargs) |
0, module; 1, function_definition; 2, function_name:get_submission; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, expression_statement; 12, if_statement; 13, if_statement; 14, return_statement; 15, identifier:url; 16, None; 17, identifier:submission_id; 18, None; 19, identifier:comment_limit; 20, integer:0; 21, identifier:comment_sort; 22, None; 23, identifier:params; 24, None; 25, comment:"""Return a Submission object for the given url or submission_id.
:param comment_limit: The desired number of comments to fetch. If <= 0
fetch the default number for the session's user. If None, fetch the
maximum possible.
:param comment_sort: The sort order for retrieved comments. When None
use the default for the session's user.
:param params: Dictionary containing extra GET data to put in the url.
"""; 26, comparison_operator:bool(url) == bool(submission_id); 27, block; 28, identifier:submission_id; 29, block; 30, call; 31, call; 32, call; 33, raise_statement; 34, expression_statement; 35, attribute; 36, argument_list; 37, identifier:bool; 38, argument_list; 39, identifier:bool; 40, argument_list; 41, call; 42, assignment; 43, attribute; 44, identifier:from_url; 45, identifier:self; 46, identifier:url; 47, keyword_argument; 48, keyword_argument; 49, keyword_argument; 50, identifier:url; 51, identifier:submission_id; 52, identifier:TypeError; 53, argument_list; 54, identifier:url; 55, call; 56, identifier:objects; 57, identifier:Submission; 58, identifier:comment_limit; 59, identifier:comment_limit; 60, identifier:comment_sort; 61, identifier:comment_sort; 62, identifier:params; 63, identifier:params; 64, string; 65, identifier:urljoin; 66, argument_list; 67, string_content:One (and only one) of id or url is required!; 68, subscript; 69, identifier:submission_id; 70, attribute; 71, string; 72, identifier:self; 73, identifier:config; 74, string_content:comments | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 4, 13; 4, 14; 6, 15; 6, 16; 7, 17; 7, 18; 8, 19; 8, 20; 9, 21; 9, 22; 10, 23; 10, 24; 11, 25; 12, 26; 12, 27; 13, 28; 13, 29; 14, 30; 26, 31; 26, 32; 27, 33; 29, 34; 30, 35; 30, 36; 31, 37; 31, 38; 32, 39; 32, 40; 33, 41; 34, 42; 35, 43; 35, 44; 36, 45; 36, 46; 36, 47; 36, 48; 36, 49; 38, 50; 40, 51; 41, 52; 41, 53; 42, 54; 42, 55; 43, 56; 43, 57; 47, 58; 47, 59; 48, 60; 48, 61; 49, 62; 49, 63; 53, 64; 55, 65; 55, 66; 64, 67; 66, 68; 66, 69; 68, 70; 68, 71; 70, 72; 70, 73; 71, 74 | def get_submission(self, url=None, submission_id=None, comment_limit=0,
comment_sort=None, params=None):
"""Return a Submission object for the given url or submission_id.
:param comment_limit: The desired number of comments to fetch. If <= 0
fetch the default number for the session's user. If None, fetch the
maximum possible.
:param comment_sort: The sort order for retrieved comments. When None
use the default for the session's user.
:param params: Dictionary containing extra GET data to put in the url.
"""
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; 1, function_definition; 2, function_name:search; 3, parameters; 4, block; 5, identifier:self; 6, identifier:query; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, list_splat_pattern; 12, dictionary_splat_pattern; 13, expression_statement; 14, expression_statement; 15, if_statement; 16, if_statement; 17, if_statement; 18, if_statement; 19, if_statement; 20, expression_statement; 21, expression_statement; 22, while_statement; 23, identifier:subreddit; 24, None; 25, identifier:sort; 26, None; 27, identifier:syntax; 28, None; 29, identifier:period; 30, None; 31, identifier:args; 32, identifier:kwargs; 33, comment:"""Return a generator for submissions that match the search query.
:param query: The query string to search for. If query is a URL only
submissions which link to that URL will be returned.
:param subreddit: Limit search results to the subreddit if provided.
:param sort: The sort order of the results.
:param syntax: The syntax of the search query.
:param period: The time period of the results.
The additional parameters are passed directly into
:meth:`.get_content`. Note: the `url` parameter cannot be altered.
See https://www.reddit.com/wiki/search for more information on how to
build a search query.
"""; 34, assignment; 35, comparison_operator:'params' in kwargs; 36, block; 37, identifier:sort; 38, block; 39, identifier:syntax; 40, block; 41, identifier:period; 42, block; 43, identifier:subreddit; 44, block; 45, else_clause; 46, assignment; 47, assignment; 48, comparison_operator:depth > 0; 49, block; 50, identifier:params; 51, dictionary; 52, string; 53, identifier:kwargs; 54, expression_statement; 55, expression_statement; 56, expression_statement; 57, expression_statement; 58, expression_statement; 59, expression_statement; 60, expression_statement; 61, block; 62, identifier:url; 63, call; 64, identifier:depth; 65, integer:2; 66, identifier:depth; 67, integer:0; 68, expression_statement; 69, try_statement; 70, pair; 71, string_content:params; 72, call; 73, call; 74, assignment; 75, assignment; 76, assignment; 77, assignment; 78, assignment; 79, expression_statement; 80, attribute; 81, argument_list; 82, augmented_assignment; 83, block; 84, except_clause; 85, string; 86, identifier:query; 87, attribute; 88, argument_list; 89, attribute; 90, argument_list; 91, subscript; 92, identifier:sort; 93, subscript; 94, identifier:syntax; 95, subscript; 96, identifier:period; 97, subscript; 98, string; 99, identifier:subreddit; 100, call; 101, assignment; 102, subscript; 103, identifier:format; 104, keyword_argument; 105, identifier:depth; 106, integer:1; 107, for_statement; 108, break_statement; 109, as_pattern; 110, block; 111, string_content:q; 112, identifier:params; 113, identifier:update; 114, subscript; 115, identifier:kwargs; 116, identifier:pop; 117, string; 118, identifier:params; 119, string; 120, identifier:params; 121, string; 122, identifier:params; 123, string; 124, identifier:params; 125, string; 126, string_content:on; 127, attribute; 128, argument_list; 129, identifier:subreddit; 130, string; 131, attribute; 132, string; 133, identifier:subreddit; 134, identifier:subreddit; 135, identifier:item; 136, call; 137, block; 138, attribute; 139, as_pattern_target; 140, expression_statement; 141, expression_statement; 142, expression_statement; 143, comment:# Handle redirects from URL searches; 144, if_statement; 145, identifier:kwargs; 146, string; 147, string_content:params; 148, string_content:sort; 149, string_content:syntax; 150, string_content:t; 151, string_content:restrict_sr; 152, identifier:six; 153, identifier:text_type; 154, identifier:subreddit; 155, string_content:all; 156, identifier:self; 157, identifier:config; 158, string_content:search; 159, attribute; 160, argument_list; 161, expression_statement; 162, identifier:errors; 163, identifier:RedirectException; 164, identifier:exc; 165, assignment; 166, assignment; 167, assignment; 168, comparison_operator:'already_submitted' in params; 169, block; 170, string_content:params; 171, identifier:self; 172, identifier:get_content; 173, identifier:url; 174, keyword_argument; 175, list_splat; 176, dictionary_splat; 177, yield; 178, identifier:parsed; 179, call; 180, identifier:params; 181, call; 182, identifier:url; 183, call; 184, string; 185, identifier:params; 186, expression_statement; 187, break_statement; 188, identifier:params; 189, identifier:params; 190, identifier:args; 191, identifier:kwargs; 192, identifier:item; 193, identifier:urlparse; 194, argument_list; 195, identifier:dict; 196, generator_expression; 197, identifier:urlunparse; 198, argument_list; 199, string_content:already_submitted; 200, yield; 201, attribute; 202, tuple; 203, for_in_clause; 204, binary_operator:parsed[:3] + ("", "", ""); 205, call; 206, identifier:exc; 207, identifier:response_url; 208, identifier:k; 209, call; 210, pattern_list; 211, call; 212, subscript; 213, tuple; 214, attribute; 215, argument_list; 216, attribute; 217, argument_list; 218, identifier:k; 219, identifier:v; 220, attribute; 221, argument_list; 222, identifier:parsed; 223, slice; 224, string:""; 225, string:""; 226, string:""; 227, identifier:self; 228, identifier:get_submission; 229, identifier:url; 230, string:","; 231, identifier:join; 232, identifier:v; 233, call; 234, identifier:items; 235, integer:3; 236, identifier:parse_qs; 237, argument_list; 238, attribute; 239, identifier:parsed; 240, identifier:query | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 7, 23; 7, 24; 8, 25; 8, 26; 9, 27; 9, 28; 10, 29; 10, 30; 11, 31; 12, 32; 13, 33; 14, 34; 15, 35; 15, 36; 16, 37; 16, 38; 17, 39; 17, 40; 18, 41; 18, 42; 19, 43; 19, 44; 19, 45; 20, 46; 21, 47; 22, 48; 22, 49; 34, 50; 34, 51; 35, 52; 35, 53; 36, 54; 36, 55; 38, 56; 40, 57; 42, 58; 44, 59; 44, 60; 45, 61; 46, 62; 46, 63; 47, 64; 47, 65; 48, 66; 48, 67; 49, 68; 49, 69; 51, 70; 52, 71; 54, 72; 55, 73; 56, 74; 57, 75; 58, 76; 59, 77; 60, 78; 61, 79; 63, 80; 63, 81; 68, 82; 69, 83; 69, 84; 70, 85; 70, 86; 72, 87; 72, 88; 73, 89; 73, 90; 74, 91; 74, 92; 75, 93; 75, 94; 76, 95; 76, 96; 77, 97; 77, 98; 78, 99; 78, 100; 79, 101; 80, 102; 80, 103; 81, 104; 82, 105; 82, 106; 83, 107; 83, 108; 84, 109; 84, 110; 85, 111; 87, 112; 87, 113; 88, 114; 89, 115; 89, 116; 90, 117; 91, 118; 91, 119; 93, 120; 93, 121; 95, 122; 95, 123; 97, 124; 97, 125; 98, 126; 100, 127; 100, 128; 101, 129; 101, 130; 102, 131; 102, 132; 104, 133; 104, 134; 107, 135; 107, 136; 107, 137; 109, 138; 109, 139; 110, 140; 110, 141; 110, 142; 110, 143; 110, 144; 114, 145; 114, 146; 117, 147; 119, 148; 121, 149; 123, 150; 125, 151; 127, 152; 127, 153; 128, 154; 130, 155; 131, 156; 131, 157; 132, 158; 136, 159; 136, 160; 137, 161; 138, 162; 138, 163; 139, 164; 140, 165; 141, 166; 142, 167; 144, 168; 144, 169; 146, 170; 159, 171; 159, 172; 160, 173; 160, 174; 160, 175; 160, 176; 161, 177; 165, 178; 165, 179; 166, 180; 166, 181; 167, 182; 167, 183; 168, 184; 168, 185; 169, 186; 169, 187; 174, 188; 174, 189; 175, 190; 176, 191; 177, 192; 179, 193; 179, 194; 181, 195; 181, 196; 183, 197; 183, 198; 184, 199; 186, 200; 194, 201; 196, 202; 196, 203; 198, 204; 200, 205; 201, 206; 201, 207; 202, 208; 202, 209; 203, 210; 203, 211; 204, 212; 204, 213; 205, 214; 205, 215; 209, 216; 209, 217; 210, 218; 210, 219; 211, 220; 211, 221; 212, 222; 212, 223; 213, 224; 213, 225; 213, 226; 214, 227; 214, 228; 215, 229; 216, 230; 216, 231; 217, 232; 220, 233; 220, 234; 223, 235; 233, 236; 233, 237; 237, 238; 238, 239; 238, 240 | def search(self, query, subreddit=None, sort=None, syntax=None,
period=None, *args, **kwargs):
"""Return a generator for submissions that match the search query.
:param query: The query string to search for. If query is a URL only
submissions which link to that URL will be returned.
:param subreddit: Limit search results to the subreddit if provided.
:param sort: The sort order of the results.
:param syntax: The syntax of the search query.
:param period: The time period of the results.
The additional parameters are passed directly into
:meth:`.get_content`. Note: the `url` parameter cannot be altered.
See https://www.reddit.com/wiki/search for more information on how to
build a search query.
"""
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] + ("", "", ""))
# Handle redirects from URL searches
if 'already_submitted' in params:
yield self.get_submission(url)
break |
0, module; 1, function_definition; 2, function_name:_get_sorter; 3, parameters; 4, block; 5, default_parameter; 6, dictionary_splat_pattern; 7, expression_statement; 8, decorated_definition; 9, return_statement; 10, identifier:subpath; 11, string; 12, identifier:defaults; 13, comment:"""Return function to generate specific subreddit Submission listings."""; 14, decorator; 15, function_definition; 16, identifier:_sorted; 17, call; 18, function_name:_sorted; 19, parameters; 20, block; 21, identifier:restrict_access; 22, argument_list; 23, identifier:self; 24, list_splat_pattern; 25, dictionary_splat_pattern; 26, expression_statement; 27, if_statement; 28, for_statement; 29, expression_statement; 30, comment:# pylint: disable=W0212; 31, return_statement; 32, keyword_argument; 33, identifier:args; 34, identifier:kwargs; 35, comment:"""Return a get_content generator for some RedditContentObject type.
The additional parameters are passed directly into
:meth:`.get_content`. Note: the `url` parameter cannot be altered.
"""; 36, not_operator; 37, block; 38, pattern_list; 39, call; 40, block; 41, assignment; 42, call; 43, identifier:scope; 44, string; 45, call; 46, expression_statement; 47, identifier:key; 48, identifier:value; 49, attribute; 50, argument_list; 51, expression_statement; 52, identifier:url; 53, call; 54, attribute; 55, argument_list; 56, string_content:read; 57, attribute; 58, argument_list; 59, assignment; 60, identifier:six; 61, identifier:iteritems; 62, identifier:defaults; 63, call; 64, identifier:urljoin; 65, argument_list; 66, attribute; 67, identifier:get_content; 68, identifier:url; 69, list_splat; 70, dictionary_splat; 71, identifier:kwargs; 72, identifier:get; 73, string; 74, subscript; 75, dictionary; 76, attribute; 77, argument_list; 78, attribute; 79, identifier:subpath; 80, identifier:self; 81, identifier:reddit_session; 82, identifier:args; 83, identifier:kwargs; 84, string_content:params; 85, identifier:kwargs; 86, string; 87, subscript; 88, identifier:setdefault; 89, identifier:key; 90, identifier:value; 91, identifier:self; 92, identifier:_url; 93, string_content:params; 94, identifier:kwargs; 95, string; 96, string_content:params | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 5, 10; 5, 11; 6, 12; 7, 13; 8, 14; 8, 15; 9, 16; 14, 17; 15, 18; 15, 19; 15, 20; 17, 21; 17, 22; 19, 23; 19, 24; 19, 25; 20, 26; 20, 27; 20, 28; 20, 29; 20, 30; 20, 31; 22, 32; 24, 33; 25, 34; 26, 35; 27, 36; 27, 37; 28, 38; 28, 39; 28, 40; 29, 41; 31, 42; 32, 43; 32, 44; 36, 45; 37, 46; 38, 47; 38, 48; 39, 49; 39, 50; 40, 51; 41, 52; 41, 53; 42, 54; 42, 55; 44, 56; 45, 57; 45, 58; 46, 59; 49, 60; 49, 61; 50, 62; 51, 63; 53, 64; 53, 65; 54, 66; 54, 67; 55, 68; 55, 69; 55, 70; 57, 71; 57, 72; 58, 73; 59, 74; 59, 75; 63, 76; 63, 77; 65, 78; 65, 79; 66, 80; 66, 81; 69, 82; 70, 83; 73, 84; 74, 85; 74, 86; 76, 87; 76, 88; 77, 89; 77, 90; 78, 91; 78, 92; 86, 93; 87, 94; 87, 95; 95, 96 | def _get_sorter(subpath='', **defaults):
"""Return function to generate specific subreddit Submission listings."""
@restrict_access(scope='read')
def _sorted(self, *args, **kwargs):
"""Return a get_content generator for some RedditContentObject type.
The additional parameters are passed directly into
:meth:`.get_content`. Note: the `url` parameter cannot be altered.
"""
if not kwargs.get('params'):
kwargs['params'] = {}
for key, value in six.iteritems(defaults):
kwargs['params'].setdefault(key, value)
url = urljoin(self._url, subpath) # pylint: disable=W0212
return self.reddit_session.get_content(url, *args, **kwargs)
return _sorted |
0, module; 1, function_definition; 2, function_name:_draw_banner; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, if_statement; 18, expression_statement; 19, comment:"""
Draw the banner with sorting options at the top of the page
"""; 20, assignment; 21, assignment; 22, call; 23, call; 24, assignment; 25, assignment; 26, assignment; 27, assignment; 28, assignment; 29, call; 30, comparison_operator:self.content.order is not None; 31, block; 32, augmented_assignment; 33, pattern_list; 34, call; 35, identifier:window; 36, call; 37, attribute; 38, argument_list; 39, attribute; 40, argument_list; 41, identifier:banner; 42, conditional_expression:docs.BANNER_SEARCH if self.content.query else self.BANNER; 43, identifier:items; 44, call; 45, identifier:distance; 46, binary_operator:(n_cols - sum(len(t) for t in items) - 1) / (len(items) - 1); 47, identifier:spacing; 48, binary_operator:max(1, int(distance)) * ' '; 49, identifier:text; 50, call; 51, attribute; 52, argument_list; 53, attribute; 54, None; 55, expression_statement; 56, expression_statement; 57, expression_statement; 58, expression_statement; 59, attribute; 60, integer:1; 61, identifier:n_rows; 62, identifier:n_cols; 63, attribute; 64, argument_list; 65, attribute; 66, argument_list; 67, identifier:window; 68, identifier:erase; 69, identifier:window; 70, identifier:bkgd; 71, call; 72, call; 73, attribute; 74, attribute; 75, attribute; 76, attribute; 77, argument_list; 78, parenthesized_expression; 79, parenthesized_expression; 80, call; 81, string; 82, attribute; 83, argument_list; 84, attribute; 85, identifier:add_line; 86, identifier:window; 87, identifier:text; 88, integer:0; 89, integer:0; 90, attribute; 91, identifier:order; 92, assignment; 93, assignment; 94, assignment; 95, call; 96, identifier:self; 97, identifier:_row; 98, attribute; 99, identifier:getmaxyx; 100, attribute; 101, identifier:derwin; 102, integer:1; 103, identifier:n_cols; 104, attribute; 105, integer:0; 106, identifier:str; 107, argument_list; 108, attribute; 109, argument_list; 110, identifier:docs; 111, identifier:BANNER_SEARCH; 112, attribute; 113, identifier:query; 114, identifier:self; 115, identifier:BANNER; 116, call; 117, identifier:split; 118, string; 119, binary_operator:n_cols - sum(len(t) for t in items) - 1; 120, binary_operator:len(items) - 1; 121, identifier:max; 122, argument_list; 123, string_content:; 124, identifier:spacing; 125, identifier:join; 126, identifier:items; 127, identifier:self; 128, identifier:term; 129, identifier:self; 130, identifier:content; 131, identifier:order; 132, subscript; 133, identifier:col; 134, binary_operator:text.find(order) - 3; 135, identifier:attr; 136, call; 137, attribute; 138, argument_list; 139, attribute; 140, identifier:stdscr; 141, attribute; 142, identifier:stdscr; 143, identifier:self; 144, identifier:_row; 145, string; 146, attribute; 147, identifier:attr; 148, string; 149, identifier:self; 150, identifier:content; 151, attribute; 152, argument_list; 153, string_content:; 154, binary_operator:n_cols - sum(len(t) for t in items); 155, integer:1; 156, call; 157, integer:1; 158, integer:1; 159, call; 160, call; 161, integer:0; 162, call; 163, integer:3; 164, attribute; 165, argument_list; 166, identifier:window; 167, identifier:chgat; 168, integer:0; 169, identifier:col; 170, integer:3; 171, identifier:attr; 172, identifier:self; 173, identifier:term; 174, identifier:self; 175, identifier:term; 176, string_content:; 177, identifier:self; 178, identifier:term; 179, string_content:OrderBar; 180, identifier:banner; 181, identifier:strip; 182, identifier:n_cols; 183, call; 184, identifier:len; 185, argument_list; 186, identifier:int; 187, argument_list; 188, attribute; 189, argument_list; 190, attribute; 191, argument_list; 192, attribute; 193, identifier:attr; 194, string; 195, identifier:sum; 196, generator_expression; 197, identifier:items; 198, identifier:distance; 199, attribute; 200, identifier:split; 201, string; 202, identifier:text; 203, identifier:find; 204, identifier:order; 205, identifier:self; 206, identifier:term; 207, string_content:OrderBarHighlight; 208, call; 209, for_in_clause; 210, attribute; 211, identifier:order; 212, string_content:-; 213, identifier:len; 214, argument_list; 215, identifier:t; 216, identifier:items; 217, identifier:self; 218, identifier:content; 219, identifier:t | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 6, 19; 7, 20; 8, 21; 9, 22; 10, 23; 11, 24; 12, 25; 13, 26; 14, 27; 15, 28; 16, 29; 17, 30; 17, 31; 18, 32; 20, 33; 20, 34; 21, 35; 21, 36; 22, 37; 22, 38; 23, 39; 23, 40; 24, 41; 24, 42; 25, 43; 25, 44; 26, 45; 26, 46; 27, 47; 27, 48; 28, 49; 28, 50; 29, 51; 29, 52; 30, 53; 30, 54; 31, 55; 31, 56; 31, 57; 31, 58; 32, 59; 32, 60; 33, 61; 33, 62; 34, 63; 34, 64; 36, 65; 36, 66; 37, 67; 37, 68; 39, 69; 39, 70; 40, 71; 40, 72; 42, 73; 42, 74; 42, 75; 44, 76; 44, 77; 46, 78; 46, 79; 48, 80; 48, 81; 50, 82; 50, 83; 51, 84; 51, 85; 52, 86; 52, 87; 52, 88; 52, 89; 53, 90; 53, 91; 55, 92; 56, 93; 57, 94; 58, 95; 59, 96; 59, 97; 63, 98; 63, 99; 65, 100; 65, 101; 66, 102; 66, 103; 66, 104; 66, 105; 71, 106; 71, 107; 72, 108; 72, 109; 73, 110; 73, 111; 74, 112; 74, 113; 75, 114; 75, 115; 76, 116; 76, 117; 77, 118; 78, 119; 79, 120; 80, 121; 80, 122; 81, 123; 82, 124; 82, 125; 83, 126; 84, 127; 84, 128; 90, 129; 90, 130; 92, 131; 92, 132; 93, 133; 93, 134; 94, 135; 94, 136; 95, 137; 95, 138; 98, 139; 98, 140; 100, 141; 100, 142; 104, 143; 104, 144; 107, 145; 108, 146; 108, 147; 109, 148; 112, 149; 112, 150; 116, 151; 116, 152; 118, 153; 119, 154; 119, 155; 120, 156; 120, 157; 122, 158; 122, 159; 132, 160; 132, 161; 134, 162; 134, 163; 136, 164; 136, 165; 137, 166; 137, 167; 138, 168; 138, 169; 138, 170; 138, 171; 139, 172; 139, 173; 141, 174; 141, 175; 145, 176; 146, 177; 146, 178; 148, 179; 151, 180; 151, 181; 154, 182; 154, 183; 156, 184; 156, 185; 159, 186; 159, 187; 160, 188; 160, 189; 162, 190; 162, 191; 164, 192; 164, 193; 165, 194; 183, 195; 183, 196; 185, 197; 187, 198; 188, 199; 188, 200; 189, 201; 190, 202; 190, 203; 191, 204; 192, 205; 192, 206; 194, 207; 196, 208; 196, 209; 199, 210; 199, 211; 201, 212; 208, 213; 208, 214; 209, 215; 209, 216; 210, 217; 210, 218; 214, 219 | def _draw_banner(self):
"""
Draw the banner with sorting options at the top of the page
"""
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; 1, function_definition; 2, function_name:from_url; 3, parameters; 4, block; 5, identifier:reddit_session; 6, identifier:url; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, expression_statement; 12, if_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, expression_statement; 18, if_statement; 19, if_statement; 20, expression_statement; 21, if_statement; 22, expression_statement; 23, expression_statement; 24, comment:# pylint: disable=W0212; 25, expression_statement; 26, comment:# pylint: disable=W0212; 27, return_statement; 28, identifier:comment_limit; 29, integer:0; 30, identifier:comment_sort; 31, None; 32, identifier:comments_only; 33, False; 34, identifier:params; 35, None; 36, comment:"""Request the url and return a Submission object.
:param reddit_session: The session to make the request with.
:param url: The url to build the Submission object from.
:param comment_limit: The desired number of comments to fetch. If <= 0
fetch the default number for the session's user. If None, fetch the
maximum possible.
:param comment_sort: The sort order for retrieved comments. When None
use the default for the session's user.
:param comments_only: Return only the list of comments.
:param params: dictionary containing extra GET data to put in the url.
"""; 37, comparison_operator:params is None; 38, block; 39, assignment; 40, assignment; 41, assignment; 42, call; 43, assignment; 44, comparison_operator:comment_limit is None; 45, comment:# Fetch MAX; 46, block; 47, elif_clause; 48, identifier:comment_sort; 49, block; 50, assignment; 51, identifier:comments_only; 52, block; 53, assignment; 54, assignment; 55, assignment; 56, identifier:submission; 57, identifier:params; 58, None; 59, expression_statement; 60, identifier:parsed; 61, call; 62, identifier:query_pairs; 63, call; 64, identifier:get_params; 65, call; 66, attribute; 67, argument_list; 68, identifier:url; 69, call; 70, identifier:comment_limit; 71, None; 72, expression_statement; 73, comment:# Just use a big number; 74, comparison_operator:comment_limit > 0; 75, comment:# Use value; 76, block; 77, expression_statement; 78, identifier:response; 79, call; 80, return_statement; 81, identifier:submission; 82, call; 83, attribute; 84, identifier:comment_sort; 85, attribute; 86, identifier:params; 87, assignment; 88, identifier:urlparse; 89, argument_list; 90, identifier:parse_qs; 91, argument_list; 92, identifier:dict; 93, generator_expression; 94, identifier:params; 95, identifier:update; 96, identifier:get_params; 97, identifier:urlunparse; 98, argument_list; 99, assignment; 100, identifier:comment_limit; 101, integer:0; 102, expression_statement; 103, assignment; 104, attribute; 105, argument_list; 106, subscript; 107, attribute; 108, argument_list; 109, identifier:submission; 110, identifier:_comment_sort; 111, identifier:submission; 112, identifier:_params; 113, identifier:params; 114, dictionary; 115, identifier:url; 116, attribute; 117, tuple; 118, for_in_clause; 119, binary_operator:parsed[:3] + ("", "", ""); 120, subscript; 121, integer:2048; 122, assignment; 123, subscript; 124, identifier:comment_sort; 125, identifier:reddit_session; 126, identifier:request_json; 127, identifier:url; 128, keyword_argument; 129, subscript; 130, string; 131, identifier:Submission; 132, identifier:from_json; 133, identifier:response; 134, identifier:parsed; 135, identifier:query; 136, identifier:k; 137, call; 138, pattern_list; 139, call; 140, subscript; 141, tuple; 142, identifier:params; 143, string; 144, subscript; 145, identifier:comment_limit; 146, identifier:params; 147, string; 148, identifier:params; 149, identifier:params; 150, subscript; 151, string; 152, string_content:children; 153, attribute; 154, argument_list; 155, identifier:k; 156, identifier:v; 157, attribute; 158, argument_list; 159, identifier:parsed; 160, slice; 161, string:""; 162, string:""; 163, string:""; 164, string_content:limit; 165, identifier:params; 166, string; 167, string_content:sort; 168, identifier:response; 169, integer:1; 170, string_content:data; 171, string:","; 172, identifier:join; 173, identifier:v; 174, identifier:query_pairs; 175, identifier:items; 176, integer:3; 177, string_content:limit | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 4, 27; 7, 28; 7, 29; 8, 30; 8, 31; 9, 32; 9, 33; 10, 34; 10, 35; 11, 36; 12, 37; 12, 38; 13, 39; 14, 40; 15, 41; 16, 42; 17, 43; 18, 44; 18, 45; 18, 46; 18, 47; 19, 48; 19, 49; 20, 50; 21, 51; 21, 52; 22, 53; 23, 54; 25, 55; 27, 56; 37, 57; 37, 58; 38, 59; 39, 60; 39, 61; 40, 62; 40, 63; 41, 64; 41, 65; 42, 66; 42, 67; 43, 68; 43, 69; 44, 70; 44, 71; 46, 72; 46, 73; 47, 74; 47, 75; 47, 76; 49, 77; 50, 78; 50, 79; 52, 80; 53, 81; 53, 82; 54, 83; 54, 84; 55, 85; 55, 86; 59, 87; 61, 88; 61, 89; 63, 90; 63, 91; 65, 92; 65, 93; 66, 94; 66, 95; 67, 96; 69, 97; 69, 98; 72, 99; 74, 100; 74, 101; 76, 102; 77, 103; 79, 104; 79, 105; 80, 106; 82, 107; 82, 108; 83, 109; 83, 110; 85, 111; 85, 112; 87, 113; 87, 114; 89, 115; 91, 116; 93, 117; 93, 118; 98, 119; 99, 120; 99, 121; 102, 122; 103, 123; 103, 124; 104, 125; 104, 126; 105, 127; 105, 128; 106, 129; 106, 130; 107, 131; 107, 132; 108, 133; 116, 134; 116, 135; 117, 136; 117, 137; 118, 138; 118, 139; 119, 140; 119, 141; 120, 142; 120, 143; 122, 144; 122, 145; 123, 146; 123, 147; 128, 148; 128, 149; 129, 150; 129, 151; 130, 152; 137, 153; 137, 154; 138, 155; 138, 156; 139, 157; 139, 158; 140, 159; 140, 160; 141, 161; 141, 162; 141, 163; 143, 164; 144, 165; 144, 166; 147, 167; 150, 168; 150, 169; 151, 170; 153, 171; 153, 172; 154, 173; 157, 174; 157, 175; 160, 176; 166, 177 | def from_url(reddit_session, url, comment_limit=0, comment_sort=None,
comments_only=False, params=None):
"""Request the url and return a Submission object.
:param reddit_session: The session to make the request with.
:param url: The url to build the Submission object from.
:param comment_limit: The desired number of comments to fetch. If <= 0
fetch the default number for the session's user. If None, fetch the
maximum possible.
:param comment_sort: The sort order for retrieved comments. When None
use the default for the session's user.
:param comments_only: Return only the list of comments.
:param params: dictionary containing extra GET data to put in the url.
"""
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: # Fetch MAX
params['limit'] = 2048 # Just use a big number
elif comment_limit > 0: # Use value
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 # pylint: disable=W0212
submission._params = params # pylint: disable=W0212
return submission |
0, module; 1, function_definition; 2, function_name:set_suggested_sort; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, return_statement; 11, identifier:sort; 12, string; 13, comment:"""Set 'Suggested Sort' for the comments of the submission.
Comments can be sorted in one of (confidence, top, new, hot,
controversial, old, random, qa, blank).
:returns: The json response from the server.
"""; 14, assignment; 15, assignment; 16, call; 17, string_content:blank; 18, identifier:url; 19, subscript; 20, identifier:data; 21, dictionary; 22, attribute; 23, argument_list; 24, attribute; 25, string; 26, pair; 27, pair; 28, attribute; 29, identifier:request_json; 30, identifier:url; 31, keyword_argument; 32, attribute; 33, identifier:config; 34, string_content:suggested_sort; 35, string; 36, attribute; 37, string; 38, identifier:sort; 39, identifier:self; 40, identifier:reddit_session; 41, identifier:data; 42, identifier:data; 43, identifier:self; 44, identifier:reddit_session; 45, string_content:id; 46, identifier:self; 47, identifier:fullname; 48, string_content:sort | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 6, 12; 7, 13; 8, 14; 9, 15; 10, 16; 12, 17; 14, 18; 14, 19; 15, 20; 15, 21; 16, 22; 16, 23; 19, 24; 19, 25; 21, 26; 21, 27; 22, 28; 22, 29; 23, 30; 23, 31; 24, 32; 24, 33; 25, 34; 26, 35; 26, 36; 27, 37; 27, 38; 28, 39; 28, 40; 31, 41; 31, 42; 32, 43; 32, 44; 35, 45; 36, 46; 36, 47; 37, 48 | def set_suggested_sort(self, sort='blank'):
"""Set 'Suggested Sort' for the comments of the submission.
Comments can be sorted in one of (confidence, top, new, hot,
controversial, old, random, qa, blank).
:returns: The json response from the server.
"""
url = self.reddit_session.config['suggested_sort']
data = {'id': self.fullname, 'sort': sort}
return self.reddit_session.request_json(url, data=data) |
0, module; 1, function_definition; 2, function_name:is_jump_back; 3, parameters; 4, block; 5, identifier:self; 6, identifier:offset; 7, identifier:extended_arg; 8, expression_statement; 9, if_statement; 10, return_statement; 11, comment:"""
Return True if the code at offset is some sort of jump back.
That is, it is ether "JUMP_FORWARD" or an absolute jump that
goes forward.
"""; 12, comparison_operator:self.code[offset] != self.opc.JUMP_ABSOLUTE; 13, block; 14, comparison_operator:offset > self.get_target(offset, extended_arg); 15, subscript; 16, attribute; 17, return_statement; 18, identifier:offset; 19, call; 20, attribute; 21, identifier:offset; 22, attribute; 23, identifier:JUMP_ABSOLUTE; 24, False; 25, attribute; 26, argument_list; 27, identifier:self; 28, identifier:code; 29, identifier:self; 30, identifier:opc; 31, identifier:self; 32, identifier:get_target; 33, identifier:offset; 34, identifier:extended_arg | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 8, 11; 9, 12; 9, 13; 10, 14; 12, 15; 12, 16; 13, 17; 14, 18; 14, 19; 15, 20; 15, 21; 16, 22; 16, 23; 17, 24; 19, 25; 19, 26; 20, 27; 20, 28; 22, 29; 22, 30; 25, 31; 25, 32; 26, 33; 26, 34 | def is_jump_back(self, offset, extended_arg):
"""
Return True if the code at offset is some sort of jump back.
That is, it is ether "JUMP_FORWARD" or an absolute jump that
goes forward.
"""
if self.code[offset] != self.opc.JUMP_ABSOLUTE:
return False
return offset > self.get_target(offset, extended_arg) |
0, module; 1, function_definition; 2, function_name:is_jump_forward; 3, parameters; 4, block; 5, identifier:self; 6, identifier:offset; 7, expression_statement; 8, expression_statement; 9, if_statement; 10, if_statement; 11, return_statement; 12, comment:"""
Return True if the code at offset is some sort of jump forward.
That is, it is ether "JUMP_FORWARD" or an absolute jump that
goes forward.
"""; 13, assignment; 14, comparison_operator:opname == 'JUMP_FORWARD'; 15, block; 16, comparison_operator:opname != 'JUMP_ABSOLUTE'; 17, block; 18, comparison_operator:offset < self.get_target(offset); 19, identifier:opname; 20, attribute; 21, identifier:opname; 22, string; 23, return_statement; 24, identifier:opname; 25, string; 26, return_statement; 27, identifier:offset; 28, call; 29, call; 30, identifier:opname; 31, string_content:JUMP_FORWARD; 32, True; 33, string_content:JUMP_ABSOLUTE; 34, False; 35, attribute; 36, argument_list; 37, attribute; 38, argument_list; 39, identifier:self; 40, identifier:get_target; 41, identifier:offset; 42, identifier:self; 43, identifier:get_inst; 44, identifier:offset | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 7, 12; 8, 13; 9, 14; 9, 15; 10, 16; 10, 17; 11, 18; 13, 19; 13, 20; 14, 21; 14, 22; 15, 23; 16, 24; 16, 25; 17, 26; 18, 27; 18, 28; 20, 29; 20, 30; 22, 31; 23, 32; 25, 33; 26, 34; 28, 35; 28, 36; 29, 37; 29, 38; 35, 39; 35, 40; 36, 41; 37, 42; 37, 43; 38, 44 | def is_jump_forward(self, offset):
"""
Return True if the code at offset is some sort of jump forward.
That is, it is ether "JUMP_FORWARD" or an absolute jump that
goes forward.
"""
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; 1, function_definition; 2, function_name:show_grid; 3, parameters; 4, block; 5, identifier:data_frame; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, default_parameter; 11, default_parameter; 12, expression_statement; 13, if_statement; 14, if_statement; 15, if_statement; 16, if_statement; 17, if_statement; 18, if_statement; 19, comment:# if a Series is passed in, convert it to a DataFrame; 20, if_statement; 21, expression_statement; 22, comment:# create a visualization for the dataframe; 23, return_statement; 24, identifier:show_toolbar; 25, None; 26, identifier:precision; 27, None; 28, identifier:grid_options; 29, None; 30, identifier:column_options; 31, None; 32, identifier:column_definitions; 33, None; 34, identifier:row_edit_callback; 35, None; 36, comment:"""
Renders a DataFrame or Series as an interactive qgrid, represented by
an instance of the ``QgridWidget`` class. The ``QgridWidget`` instance
is constructed using the options passed in to this function. The
``data_frame`` argument to this function is used as the ``df`` kwarg in
call to the QgridWidget constructor, and the rest of the parameters
are passed through as is.
If the ``data_frame`` argument is a Series, it will be converted to a
DataFrame before being passed in to the QgridWidget constructor as the
``df`` kwarg.
:rtype: QgridWidget
Parameters
----------
data_frame : DataFrame
The DataFrame that will be displayed by this instance of
QgridWidget.
grid_options : dict
Options to use when creating the SlickGrid control (i.e. the
interactive grid). See the Notes section below for more information
on the available options, as well as the default options that this
widget uses.
precision : integer
The number of digits of precision to display for floating-point
values. If unset, we use the value of
`pandas.get_option('display.precision')`.
show_toolbar : bool
Whether to show a toolbar with options for adding/removing rows.
Adding/removing rows is an experimental feature which only works
with DataFrames that have an integer index.
column_options : dict
Column options that are to be applied to every column. See the
Notes section below for more information on the available options,
as well as the default options that this widget uses.
column_definitions : dict
Column options that are to be applied to individual
columns. The keys of the dict should be the column names, and each
value should be the column options for a particular column,
represented as a dict. The available options for each column are the
same options that are available to be set for all columns via the
``column_options`` parameter. See the Notes section below for more
information on those options.
row_edit_callback : callable
A callable that is called to determine whether a particular row
should be editable or not. Its signature should be
``callable(row)``, where ``row`` is a dictionary which contains a
particular row's values, keyed by column name. The callback should
return True if the provided row should be editable, and False
otherwise.
Notes
-----
The following dictionary is used for ``grid_options`` if none are
provided explicitly::
{
# SlickGrid options
'fullWidthRows': True,
'syncColumnCellResize': True,
'forceFitColumns': True,
'defaultColumnWidth': 150,
'rowHeight': 28,
'enableColumnReorder': False,
'enableTextSelectionOnCells': True,
'editable': True,
'autoEdit': False,
'explicitInitialization': True,
# Qgrid options
'maxVisibleRows': 15,
'minVisibleRows': 8,
'sortable': True,
'filterable': True,
'highlightSelectedCell': False,
'highlightSelectedRow': True
}
The first group of options are SlickGrid "grid options" which are
described in the `SlickGrid documentation
<https://github.com/mleibman/SlickGrid/wiki/Grid-Options>`_.
The second group of option are options that were added specifically
for Qgrid and therefore are not documented in the SlickGrid documentation.
The following bullet points describe these options.
* **maxVisibleRows** The maximum number of rows that Qgrid will show.
* **minVisibleRows** The minimum number of rows that Qgrid will show
* **sortable** Whether the Qgrid instance will allow the user to sort
columns by clicking the column headers. When this is set to ``False``,
nothing will happen when users click the column headers.
* **filterable** Whether the Qgrid instance will allow the user to filter
the grid. When this is set to ``False`` the filter icons won't be shown
for any columns.
* **highlightSelectedCell** If you set this to True, the selected cell
will be given a light blue border.
* **highlightSelectedRow** If you set this to False, the light blue
background that's shown by default for selected rows will be hidden.
The following dictionary is used for ``column_options`` if none are
provided explicitly::
{
# SlickGrid column options
'defaultSortAsc': True,
'maxWidth': None,
'minWidth': 30,
'resizable': True,
'sortable': True,
'toolTip': "",
'width': None
# Qgrid column options
'editable': True,
}
The first group of options are SlickGrid "column options" which are
described in the `SlickGrid documentation
<https://github.com/mleibman/SlickGrid/wiki/Column-Options>`_.
The ``editable`` option was added specifically for Qgrid and therefore is
not documented in the SlickGrid documentation. This option specifies
whether a column should be editable or not.
See Also
--------
set_defaults : Permanently set global defaults for the parameters
of ``show_grid``, with the exception of the ``data_frame``
and ``column_definitions`` parameters, since those
depend on the particular set of data being shown by an
instance, and therefore aren't parameters we would want
to set for all QgridWidet instances.
set_grid_option : Permanently set global defaults for individual
grid options. Does so by changing the defaults
that the ``show_grid`` method uses for the
``grid_options`` parameter.
QgridWidget : The widget class that is instantiated and returned by this
method.
"""; 37, comparison_operator:show_toolbar is None; 38, block; 39, comparison_operator:precision is None; 40, block; 41, not_operator; 42, block; 43, comparison_operator:column_options is None; 44, block; 45, else_clause; 46, comparison_operator:grid_options is None; 47, block; 48, else_clause; 49, not_operator; 50, block; 51, call; 52, block; 53, elif_clause; 54, assignment; 55, call; 56, identifier:show_toolbar; 57, None; 58, expression_statement; 59, identifier:precision; 60, None; 61, expression_statement; 62, call; 63, raise_statement; 64, identifier:column_options; 65, None; 66, expression_statement; 67, block; 68, identifier:grid_options; 69, None; 70, expression_statement; 71, block; 72, call; 73, raise_statement; 74, identifier:isinstance; 75, argument_list; 76, expression_statement; 77, not_operator; 78, block; 79, identifier:column_definitions; 80, parenthesized_expression; 81, identifier:QgridWidget; 82, argument_list; 83, assignment; 84, assignment; 85, identifier:isinstance; 86, argument_list; 87, call; 88, assignment; 89, expression_statement; 90, expression_statement; 91, expression_statement; 92, assignment; 93, expression_statement; 94, expression_statement; 95, expression_statement; 96, identifier:isinstance; 97, argument_list; 98, call; 99, identifier:data_frame; 100, attribute; 101, assignment; 102, call; 103, raise_statement; 104, boolean_operator; 105, keyword_argument; 106, keyword_argument; 107, keyword_argument; 108, keyword_argument; 109, keyword_argument; 110, keyword_argument; 111, keyword_argument; 112, identifier:show_toolbar; 113, attribute; 114, identifier:precision; 115, attribute; 116, identifier:precision; 117, identifier:Integral; 118, identifier:TypeError; 119, argument_list; 120, identifier:column_options; 121, attribute; 122, assignment; 123, call; 124, assignment; 125, identifier:grid_options; 126, attribute; 127, assignment; 128, call; 129, assignment; 130, identifier:grid_options; 131, identifier:dict; 132, identifier:TypeError; 133, argument_list; 134, identifier:pd; 135, identifier:Series; 136, identifier:data_frame; 137, call; 138, identifier:isinstance; 139, argument_list; 140, call; 141, identifier:column_definitions; 142, dictionary; 143, identifier:df; 144, identifier:data_frame; 145, identifier:precision; 146, identifier:precision; 147, identifier:grid_options; 148, identifier:grid_options; 149, identifier:column_options; 150, identifier:column_options; 151, identifier:column_definitions; 152, identifier:column_definitions; 153, identifier:row_edit_callback; 154, identifier:row_edit_callback; 155, identifier:show_toolbar; 156, identifier:show_toolbar; 157, identifier:defaults; 158, identifier:show_toolbar; 159, identifier:defaults; 160, identifier:precision; 161, binary_operator:"precision must be int, not %s" % type(precision); 162, identifier:defaults; 163, identifier:column_options; 164, identifier:options; 165, call; 166, attribute; 167, argument_list; 168, identifier:column_options; 169, identifier:options; 170, identifier:defaults; 171, identifier:grid_options; 172, identifier:options; 173, call; 174, attribute; 175, argument_list; 176, identifier:grid_options; 177, identifier:options; 178, binary_operator:"grid_options must be dict, not %s" % type(grid_options); 179, attribute; 180, argument_list; 181, identifier:data_frame; 182, attribute; 183, identifier:TypeError; 184, argument_list; 185, string:"precision must be int, not %s"; 186, call; 187, attribute; 188, argument_list; 189, identifier:options; 190, identifier:update; 191, identifier:column_options; 192, attribute; 193, argument_list; 194, identifier:options; 195, identifier:update; 196, identifier:grid_options; 197, string:"grid_options must be dict, not %s"; 198, call; 199, identifier:pd; 200, identifier:DataFrame; 201, identifier:data_frame; 202, identifier:pd; 203, identifier:DataFrame; 204, binary_operator:"data_frame must be DataFrame or Series, not %s" % type(data_frame); 205, identifier:type; 206, argument_list; 207, attribute; 208, identifier:copy; 209, attribute; 210, identifier:copy; 211, identifier:type; 212, argument_list; 213, string:"data_frame must be DataFrame or Series, not %s"; 214, call; 215, identifier:precision; 216, identifier:defaults; 217, identifier:column_options; 218, identifier:defaults; 219, identifier:grid_options; 220, identifier:grid_options; 221, identifier:type; 222, argument_list; 223, identifier:data_frame | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 6, 24; 6, 25; 7, 26; 7, 27; 8, 28; 8, 29; 9, 30; 9, 31; 10, 32; 10, 33; 11, 34; 11, 35; 12, 36; 13, 37; 13, 38; 14, 39; 14, 40; 15, 41; 15, 42; 16, 43; 16, 44; 16, 45; 17, 46; 17, 47; 17, 48; 18, 49; 18, 50; 20, 51; 20, 52; 20, 53; 21, 54; 23, 55; 37, 56; 37, 57; 38, 58; 39, 59; 39, 60; 40, 61; 41, 62; 42, 63; 43, 64; 43, 65; 44, 66; 45, 67; 46, 68; 46, 69; 47, 70; 48, 71; 49, 72; 50, 73; 51, 74; 51, 75; 52, 76; 53, 77; 53, 78; 54, 79; 54, 80; 55, 81; 55, 82; 58, 83; 61, 84; 62, 85; 62, 86; 63, 87; 66, 88; 67, 89; 67, 90; 67, 91; 70, 92; 71, 93; 71, 94; 71, 95; 72, 96; 72, 97; 73, 98; 75, 99; 75, 100; 76, 101; 77, 102; 78, 103; 80, 104; 82, 105; 82, 106; 82, 107; 82, 108; 82, 109; 82, 110; 82, 111; 83, 112; 83, 113; 84, 114; 84, 115; 86, 116; 86, 117; 87, 118; 87, 119; 88, 120; 88, 121; 89, 122; 90, 123; 91, 124; 92, 125; 92, 126; 93, 127; 94, 128; 95, 129; 97, 130; 97, 131; 98, 132; 98, 133; 100, 134; 100, 135; 101, 136; 101, 137; 102, 138; 102, 139; 103, 140; 104, 141; 104, 142; 105, 143; 105, 144; 106, 145; 106, 146; 107, 147; 107, 148; 108, 149; 108, 150; 109, 151; 109, 152; 110, 153; 110, 154; 111, 155; 111, 156; 113, 157; 113, 158; 115, 159; 115, 160; 119, 161; 121, 162; 121, 163; 122, 164; 122, 165; 123, 166; 123, 167; 124, 168; 124, 169; 126, 170; 126, 171; 127, 172; 127, 173; 128, 174; 128, 175; 129, 176; 129, 177; 133, 178; 137, 179; 137, 180; 139, 181; 139, 182; 140, 183; 140, 184; 161, 185; 161, 186; 165, 187; 165, 188; 166, 189; 166, 190; 167, 191; 173, 192; 173, 193; 174, 194; 174, 195; 175, 196; 178, 197; 178, 198; 179, 199; 179, 200; 180, 201; 182, 202; 182, 203; 184, 204; 186, 205; 186, 206; 187, 207; 187, 208; 192, 209; 192, 210; 198, 211; 198, 212; 204, 213; 204, 214; 206, 215; 207, 216; 207, 217; 209, 218; 209, 219; 212, 220; 214, 221; 214, 222; 222, 223 | def show_grid(data_frame,
show_toolbar=None,
precision=None,
grid_options=None,
column_options=None,
column_definitions=None,
row_edit_callback=None):
"""
Renders a DataFrame or Series as an interactive qgrid, represented by
an instance of the ``QgridWidget`` class. The ``QgridWidget`` instance
is constructed using the options passed in to this function. The
``data_frame`` argument to this function is used as the ``df`` kwarg in
call to the QgridWidget constructor, and the rest of the parameters
are passed through as is.
If the ``data_frame`` argument is a Series, it will be converted to a
DataFrame before being passed in to the QgridWidget constructor as the
``df`` kwarg.
:rtype: QgridWidget
Parameters
----------
data_frame : DataFrame
The DataFrame that will be displayed by this instance of
QgridWidget.
grid_options : dict
Options to use when creating the SlickGrid control (i.e. the
interactive grid). See the Notes section below for more information
on the available options, as well as the default options that this
widget uses.
precision : integer
The number of digits of precision to display for floating-point
values. If unset, we use the value of
`pandas.get_option('display.precision')`.
show_toolbar : bool
Whether to show a toolbar with options for adding/removing rows.
Adding/removing rows is an experimental feature which only works
with DataFrames that have an integer index.
column_options : dict
Column options that are to be applied to every column. See the
Notes section below for more information on the available options,
as well as the default options that this widget uses.
column_definitions : dict
Column options that are to be applied to individual
columns. The keys of the dict should be the column names, and each
value should be the column options for a particular column,
represented as a dict. The available options for each column are the
same options that are available to be set for all columns via the
``column_options`` parameter. See the Notes section below for more
information on those options.
row_edit_callback : callable
A callable that is called to determine whether a particular row
should be editable or not. Its signature should be
``callable(row)``, where ``row`` is a dictionary which contains a
particular row's values, keyed by column name. The callback should
return True if the provided row should be editable, and False
otherwise.
Notes
-----
The following dictionary is used for ``grid_options`` if none are
provided explicitly::
{
# SlickGrid options
'fullWidthRows': True,
'syncColumnCellResize': True,
'forceFitColumns': True,
'defaultColumnWidth': 150,
'rowHeight': 28,
'enableColumnReorder': False,
'enableTextSelectionOnCells': True,
'editable': True,
'autoEdit': False,
'explicitInitialization': True,
# Qgrid options
'maxVisibleRows': 15,
'minVisibleRows': 8,
'sortable': True,
'filterable': True,
'highlightSelectedCell': False,
'highlightSelectedRow': True
}
The first group of options are SlickGrid "grid options" which are
described in the `SlickGrid documentation
<https://github.com/mleibman/SlickGrid/wiki/Grid-Options>`_.
The second group of option are options that were added specifically
for Qgrid and therefore are not documented in the SlickGrid documentation.
The following bullet points describe these options.
* **maxVisibleRows** The maximum number of rows that Qgrid will show.
* **minVisibleRows** The minimum number of rows that Qgrid will show
* **sortable** Whether the Qgrid instance will allow the user to sort
columns by clicking the column headers. When this is set to ``False``,
nothing will happen when users click the column headers.
* **filterable** Whether the Qgrid instance will allow the user to filter
the grid. When this is set to ``False`` the filter icons won't be shown
for any columns.
* **highlightSelectedCell** If you set this to True, the selected cell
will be given a light blue border.
* **highlightSelectedRow** If you set this to False, the light blue
background that's shown by default for selected rows will be hidden.
The following dictionary is used for ``column_options`` if none are
provided explicitly::
{
# SlickGrid column options
'defaultSortAsc': True,
'maxWidth': None,
'minWidth': 30,
'resizable': True,
'sortable': True,
'toolTip': "",
'width': None
# Qgrid column options
'editable': True,
}
The first group of options are SlickGrid "column options" which are
described in the `SlickGrid documentation
<https://github.com/mleibman/SlickGrid/wiki/Column-Options>`_.
The ``editable`` option was added specifically for Qgrid and therefore is
not documented in the SlickGrid documentation. This option specifies
whether a column should be editable or not.
See Also
--------
set_defaults : Permanently set global defaults for the parameters
of ``show_grid``, with the exception of the ``data_frame``
and ``column_definitions`` parameters, since those
depend on the particular set of data being shown by an
instance, and therefore aren't parameters we would want
to set for all QgridWidet instances.
set_grid_option : Permanently set global defaults for individual
grid options. Does so by changing the defaults
that the ``show_grid`` method uses for the
``grid_options`` parameter.
QgridWidget : The widget class that is instantiated and returned by this
method.
"""
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 a Series is passed in, convert it to a DataFrame
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 {})
# create a visualization for the dataframe
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; 1, function_definition; 2, function_name:_eigsorted; 3, parameters; 4, block; 5, identifier:cov; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, if_statement; 11, return_statement; 12, identifier:asc; 13, True; 14, comment:"""
Computes eigenvalues and eigenvectors of a covariance matrix and returns
them sorted by eigenvalue.
Parameters
----------
cov : ndarray
covariance matrix
asc : bool, default=True
determines whether we are sorted smallest to largest (asc=True),
or largest to smallest (asc=False)
Returns
-------
eigval : 1D ndarray
eigenvalues of covariance ordered largest to smallest
eigvec : 2D ndarray
eigenvectors of covariance matrix ordered to match `eigval` ordering.
I.e eigvec[:, 0] is the rotation vector for eigval[0]
"""; 15, assignment; 16, assignment; 17, not_operator; 18, comment:# sort largest to smallest; 19, block; 20, expression_list; 21, pattern_list; 22, call; 23, identifier:order; 24, call; 25, identifier:asc; 26, expression_statement; 27, subscript; 28, subscript; 29, identifier:eigval; 30, identifier:eigvec; 31, attribute; 32, argument_list; 33, attribute; 34, argument_list; 35, assignment; 36, identifier:eigval; 37, identifier:order; 38, identifier:eigvec; 39, slice; 40, identifier:order; 41, attribute; 42, identifier:eigh; 43, identifier:cov; 44, identifier:eigval; 45, identifier:argsort; 46, identifier:order; 47, subscript; 48, identifier:np; 49, identifier:linalg; 50, identifier:order; 51, slice; 52, unary_operator; 53, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 6, 13; 7, 14; 8, 15; 9, 16; 10, 17; 10, 18; 10, 19; 11, 20; 15, 21; 15, 22; 16, 23; 16, 24; 17, 25; 19, 26; 20, 27; 20, 28; 21, 29; 21, 30; 22, 31; 22, 32; 24, 33; 24, 34; 26, 35; 27, 36; 27, 37; 28, 38; 28, 39; 28, 40; 31, 41; 31, 42; 32, 43; 33, 44; 33, 45; 35, 46; 35, 47; 41, 48; 41, 49; 47, 50; 47, 51; 51, 52; 52, 53 | def _eigsorted(cov, asc=True):
"""
Computes eigenvalues and eigenvectors of a covariance matrix and returns
them sorted by eigenvalue.
Parameters
----------
cov : ndarray
covariance matrix
asc : bool, default=True
determines whether we are sorted smallest to largest (asc=True),
or largest to smallest (asc=False)
Returns
-------
eigval : 1D ndarray
eigenvalues of covariance ordered largest to smallest
eigvec : 2D ndarray
eigenvectors of covariance matrix ordered to match `eigval` ordering.
I.e eigvec[:, 0] is the rotation vector for eigval[0]
"""
eigval, eigvec = np.linalg.eigh(cov)
order = eigval.argsort()
if not asc:
# sort largest to smallest
order = order[::-1]
return eigval[order], eigvec[:, order] |
0, module; 1, function_definition; 2, function_name:sort_args; 3, parameters; 4, block; 5, identifier:args; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, comment:"""Put flags at the end"""; 12, assignment; 13, assignment; 14, identifier:i; 15, identifier:flags; 16, block; 17, binary_operator:args + flags; 18, identifier:args; 19, call; 20, identifier:flags; 21, list_comprehension; 22, expression_statement; 23, identifier:args; 24, identifier:flags; 25, attribute; 26, argument_list; 27, identifier:i; 28, for_in_clause; 29, if_clause; 30, call; 31, identifier:args; 32, identifier:copy; 33, identifier:i; 34, identifier:args; 35, call; 36, attribute; 37, argument_list; 38, attribute; 39, argument_list; 40, identifier:args; 41, identifier:remove; 42, identifier:i; 43, identifier:FLAGS_RE; 44, identifier:match; 45, subscript; 46, identifier:i; 47, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 7, 12; 8, 13; 9, 14; 9, 15; 9, 16; 10, 17; 12, 18; 12, 19; 13, 20; 13, 21; 16, 22; 17, 23; 17, 24; 19, 25; 19, 26; 21, 27; 21, 28; 21, 29; 22, 30; 25, 31; 25, 32; 28, 33; 28, 34; 29, 35; 30, 36; 30, 37; 35, 38; 35, 39; 36, 40; 36, 41; 37, 42; 38, 43; 38, 44; 39, 45; 45, 46; 45, 47 | def sort_args(args):
"""Put flags at the end"""
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; 1, function_definition; 2, function_name:plot_fracs; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, import_from_statement; 11, expression_statement; 12, expression_statement; 13, if_statement; 14, if_statement; 15, expression_statement; 16, expression_statement; 17, expression_statement; 18, expression_statement; 19, expression_statement; 20, expression_statement; 21, expression_statement; 22, try_statement; 23, return_statement; 24, identifier:Q; 25, None; 26, identifier:ax; 27, None; 28, identifier:fignum; 29, None; 30, comment:"""
Plot fractions of Eigenvalues sorted in descending order.
"""; 31, relative_import; 32, dotted_name; 33, call; 34, assignment; 35, comparison_operator:ax is None; 36, block; 37, comparison_operator:Q is None; 38, block; 39, assignment; 40, assignment; 41, call; 42, call; 43, call; 44, call; 45, call; 46, block; 47, except_clause; 48, identifier:bar; 49, import_prefix; 50, dotted_name; 51, identifier:Tango; 52, attribute; 53, argument_list; 54, identifier:col; 55, call; 56, identifier:ax; 57, None; 58, expression_statement; 59, expression_statement; 60, identifier:Q; 61, None; 62, expression_statement; 63, identifier:ticks; 64, call; 65, identifier:bar; 66, call; 67, attribute; 68, argument_list; 69, attribute; 70, argument_list; 71, attribute; 72, argument_list; 73, attribute; 74, argument_list; 75, attribute; 76, argument_list; 77, expression_statement; 78, block; 79, identifier:plotting; 80, identifier:Tango; 81, identifier:reset; 82, attribute; 83, argument_list; 84, assignment; 85, assignment; 86, assignment; 87, attribute; 88, argument_list; 89, attribute; 90, argument_list; 91, identifier:ax; 92, identifier:set_xticks; 93, identifier:ticks; 94, call; 95, identifier:ax; 96, identifier:set_ylabel; 97, string:"Eigenvalue fraction"; 98, identifier:ax; 99, identifier:set_xlabel; 100, string:"PC"; 101, identifier:ax; 102, identifier:set_ylim; 103, integer:0; 104, subscript; 105, identifier:ax; 106, identifier:set_xlim; 107, binary_operator:ticks.min() - .5; 108, binary_operator:ticks.max() + .5; 109, call; 110, pass_statement; 111, identifier:Tango; 112, identifier:nextMedium; 113, identifier:fig; 114, call; 115, identifier:ax; 116, call; 117, identifier:Q; 118, attribute; 119, identifier:numpy; 120, identifier:arange; 121, identifier:Q; 122, identifier:ax; 123, identifier:bar; 124, binary_operator:ticks - .4; 125, subscript; 126, keyword_argument; 127, identifier:map; 128, argument_list; 129, call; 130, integer:1; 131, call; 132, float:.5; 133, call; 134, float:.5; 135, attribute; 136, argument_list; 137, attribute; 138, argument_list; 139, attribute; 140, argument_list; 141, identifier:self; 142, identifier:Q; 143, identifier:ticks; 144, float:.4; 145, attribute; 146, slice; 147, identifier:color; 148, identifier:col; 149, lambda; 150, binary_operator:ticks + 1; 151, attribute; 152, argument_list; 153, attribute; 154, argument_list; 155, attribute; 156, argument_list; 157, identifier:pylab; 158, identifier:tight_layout; 159, identifier:pylab; 160, identifier:figure; 161, identifier:fignum; 162, identifier:fig; 163, identifier:add_subplot; 164, integer:111; 165, identifier:self; 166, identifier:fracs; 167, identifier:Q; 168, lambda_parameters; 169, call; 170, identifier:ticks; 171, integer:1; 172, identifier:ax; 173, identifier:get_ylim; 174, identifier:ticks; 175, identifier:min; 176, identifier:ticks; 177, identifier:max; 178, identifier:x; 179, attribute; 180, argument_list; 181, string:r"${}$"; 182, identifier:format; 183, identifier:x | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 6, 24; 6, 25; 7, 26; 7, 27; 8, 28; 8, 29; 9, 30; 10, 31; 10, 32; 11, 33; 12, 34; 13, 35; 13, 36; 14, 37; 14, 38; 15, 39; 16, 40; 17, 41; 18, 42; 19, 43; 20, 44; 21, 45; 22, 46; 22, 47; 23, 48; 31, 49; 31, 50; 32, 51; 33, 52; 33, 53; 34, 54; 34, 55; 35, 56; 35, 57; 36, 58; 36, 59; 37, 60; 37, 61; 38, 62; 39, 63; 39, 64; 40, 65; 40, 66; 41, 67; 41, 68; 42, 69; 42, 70; 43, 71; 43, 72; 44, 73; 44, 74; 45, 75; 45, 76; 46, 77; 47, 78; 50, 79; 52, 80; 52, 81; 55, 82; 55, 83; 58, 84; 59, 85; 62, 86; 64, 87; 64, 88; 66, 89; 66, 90; 67, 91; 67, 92; 68, 93; 68, 94; 69, 95; 69, 96; 70, 97; 71, 98; 71, 99; 72, 100; 73, 101; 73, 102; 74, 103; 74, 104; 75, 105; 75, 106; 76, 107; 76, 108; 77, 109; 78, 110; 82, 111; 82, 112; 84, 113; 84, 114; 85, 115; 85, 116; 86, 117; 86, 118; 87, 119; 87, 120; 88, 121; 89, 122; 89, 123; 90, 124; 90, 125; 90, 126; 94, 127; 94, 128; 104, 129; 104, 130; 107, 131; 107, 132; 108, 133; 108, 134; 109, 135; 109, 136; 114, 137; 114, 138; 116, 139; 116, 140; 118, 141; 118, 142; 124, 143; 124, 144; 125, 145; 125, 146; 126, 147; 126, 148; 128, 149; 128, 150; 129, 151; 129, 152; 131, 153; 131, 154; 133, 155; 133, 156; 135, 157; 135, 158; 137, 159; 137, 160; 138, 161; 139, 162; 139, 163; 140, 164; 145, 165; 145, 166; 146, 167; 149, 168; 149, 169; 150, 170; 150, 171; 151, 172; 151, 173; 153, 174; 153, 175; 155, 176; 155, 177; 168, 178; 169, 179; 169, 180; 179, 181; 179, 182; 180, 183 | def plot_fracs(self, Q=None, ax=None, fignum=None):
"""
Plot fractions of Eigenvalues sorted in descending order.
"""
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; 1, function_definition; 2, function_name:_distance_squared; 3, parameters; 4, type; 5, block; 6, identifier:self; 7, typed_parameter; 8, generic_type; 9, expression_statement; 10, return_statement; 11, identifier:p2; 12, type; 13, identifier:Union; 14, type_parameter; 15, comment:""" Function used to not take the square root as the distances will stay proportionally the same. This is to speed up the sorting process. """; 16, binary_operator:(self[0] - p2[0]) ** 2 + (self[1] - p2[1]) ** 2; 17, string:"Point2"; 18, type; 19, type; 20, binary_operator:(self[0] - p2[0]) ** 2; 21, binary_operator:(self[1] - p2[1]) ** 2; 22, identifier:int; 23, identifier:float; 24, parenthesized_expression; 25, integer:2; 26, parenthesized_expression; 27, integer:2; 28, binary_operator:self[0] - p2[0]; 29, binary_operator:self[1] - p2[1]; 30, subscript; 31, subscript; 32, subscript; 33, subscript; 34, identifier:self; 35, integer:0; 36, identifier:p2; 37, integer:0; 38, identifier:self; 39, integer:1; 40, identifier:p2; 41, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 3, 7; 4, 8; 5, 9; 5, 10; 7, 11; 7, 12; 8, 13; 8, 14; 9, 15; 10, 16; 12, 17; 14, 18; 14, 19; 16, 20; 16, 21; 18, 22; 19, 23; 20, 24; 20, 25; 21, 26; 21, 27; 24, 28; 26, 29; 28, 30; 28, 31; 29, 32; 29, 33; 30, 34; 30, 35; 31, 36; 31, 37; 32, 38; 32, 39; 33, 40; 33, 41 | def _distance_squared(self, p2: "Point2") -> Union[int, float]:
""" Function used to not take the square root as the distances will stay proportionally the same. This is to speed up the sorting process. """
return (self[0] - p2[0]) ** 2 + (self[1] - p2[1]) ** 2 |
0, module; 1, function_definition; 2, function_name:get_next_of_type; 3, parameters; 4, block; 5, identifier:self; 6, identifier:processor_type; 7, expression_statement; 8, with_statement; 9, comment:"""Get the next available processor of a particular type and increment
its occupancy counter.
Args:
processor_type (ProcessorType): The processor type associated with
a zmq identity.
Returns:
(Processor): Information about the transaction processor
"""; 10, with_clause; 11, block; 12, with_item; 13, if_statement; 14, try_statement; 15, expression_statement; 16, return_statement; 17, attribute; 18, comparison_operator:processor_type not in self; 19, block; 20, block; 21, except_clause; 22, call; 23, identifier:processor; 24, identifier:self; 25, identifier:_condition; 26, identifier:processor_type; 27, identifier:self; 28, expression_statement; 29, expression_statement; 30, identifier:NoProcessorVacancyError; 31, block; 32, attribute; 33, argument_list; 34, call; 35, assignment; 36, expression_statement; 37, identifier:processor; 38, identifier:inc_occupancy; 39, attribute; 40, argument_list; 41, identifier:processor; 42, call; 43, assignment; 44, identifier:self; 45, identifier:wait_for_registration; 46, identifier:processor_type; 47, attribute; 48, argument_list; 49, identifier:processor; 50, call; 51, subscript; 52, identifier:next_processor; 53, attribute; 54, argument_list; 55, identifier:self; 56, identifier:processor_type; 57, identifier:self; 58, identifier:wait_for_vacancy; 59, identifier:processor_type | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 7, 9; 8, 10; 8, 11; 10, 12; 11, 13; 11, 14; 11, 15; 11, 16; 12, 17; 13, 18; 13, 19; 14, 20; 14, 21; 15, 22; 16, 23; 17, 24; 17, 25; 18, 26; 18, 27; 19, 28; 20, 29; 21, 30; 21, 31; 22, 32; 22, 33; 28, 34; 29, 35; 31, 36; 32, 37; 32, 38; 34, 39; 34, 40; 35, 41; 35, 42; 36, 43; 39, 44; 39, 45; 40, 46; 42, 47; 42, 48; 43, 49; 43, 50; 47, 51; 47, 52; 50, 53; 50, 54; 51, 55; 51, 56; 53, 57; 53, 58; 54, 59 | def get_next_of_type(self, processor_type):
"""Get the next available processor of a particular type and increment
its occupancy counter.
Args:
processor_type (ProcessorType): The processor type associated with
a zmq identity.
Returns:
(Processor): Information about the transaction processor
"""
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; 1, function_definition; 2, function_name:wait_for_registration; 3, parameters; 4, block; 5, identifier:self; 6, identifier:processor_type; 7, expression_statement; 8, with_statement; 9, comment:"""Waits for a particular processor type to register or until
is_cancelled is True. is_cancelled cannot be part of this class
since we aren't cancelling all waiting for a processor_type,
but just this particular wait.
Args:
processor_type (ProcessorType): The family, and version of
the transaction processor.
Returns:
None
"""; 10, with_clause; 11, block; 12, with_item; 13, expression_statement; 14, if_statement; 15, attribute; 16, call; 17, call; 18, block; 19, identifier:self; 20, identifier:_condition; 21, attribute; 22, argument_list; 23, attribute; 24, argument_list; 25, raise_statement; 26, attribute; 27, identifier:wait_for; 28, lambda; 29, attribute; 30, identifier:is_set; 31, call; 32, identifier:self; 33, identifier:_condition; 34, parenthesized_expression; 35, identifier:self; 36, identifier:_cancelled_event; 37, identifier:WaitCancelledException; 38, argument_list; 39, boolean_operator; 40, comparison_operator:processor_type in self; 41, call; 42, identifier:processor_type; 43, identifier:self; 44, attribute; 45, argument_list; 46, attribute; 47, identifier:is_set; 48, identifier:self; 49, identifier:_cancelled_event | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 7, 9; 8, 10; 8, 11; 10, 12; 11, 13; 11, 14; 12, 15; 13, 16; 14, 17; 14, 18; 15, 19; 15, 20; 16, 21; 16, 22; 17, 23; 17, 24; 18, 25; 21, 26; 21, 27; 22, 28; 23, 29; 23, 30; 25, 31; 26, 32; 26, 33; 28, 34; 29, 35; 29, 36; 31, 37; 31, 38; 34, 39; 39, 40; 39, 41; 40, 42; 40, 43; 41, 44; 41, 45; 44, 46; 44, 47; 46, 48; 46, 49 | def wait_for_registration(self, processor_type):
"""Waits for a particular processor type to register or until
is_cancelled is True. is_cancelled cannot be part of this class
since we aren't cancelling all waiting for a processor_type,
but just this particular wait.
Args:
processor_type (ProcessorType): The family, and version of
the transaction processor.
Returns:
None
"""
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; 1, function_definition; 2, function_name:wait_for_vacancy; 3, parameters; 4, block; 5, identifier:self; 6, identifier:processor_type; 7, expression_statement; 8, with_statement; 9, comment:"""Waits for a particular processor type to have the capacity to
handle additional transactions or until is_cancelled is True.
Args:
processor_type (ProcessorType): The family, and version of
the transaction processor.
Returns:
Processor
"""; 10, with_clause; 11, block; 12, with_item; 13, expression_statement; 14, if_statement; 15, expression_statement; 16, return_statement; 17, attribute; 18, call; 19, call; 20, block; 21, assignment; 22, identifier:processor; 23, identifier:self; 24, identifier:_condition; 25, attribute; 26, argument_list; 27, attribute; 28, argument_list; 29, raise_statement; 30, identifier:processor; 31, call; 32, attribute; 33, identifier:wait_for; 34, lambda; 35, attribute; 36, identifier:is_set; 37, call; 38, attribute; 39, argument_list; 40, identifier:self; 41, identifier:_condition; 42, parenthesized_expression; 43, identifier:self; 44, identifier:_cancelled_event; 45, identifier:WaitCancelledException; 46, argument_list; 47, subscript; 48, identifier:next_processor; 49, boolean_operator; 50, identifier:self; 51, identifier:processor_type; 52, call; 53, call; 54, attribute; 55, argument_list; 56, attribute; 57, argument_list; 58, identifier:self; 59, identifier:_processor_available; 60, identifier:processor_type; 61, attribute; 62, identifier:is_set; 63, identifier:self; 64, identifier:_cancelled_event | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 7, 9; 8, 10; 8, 11; 10, 12; 11, 13; 11, 14; 11, 15; 11, 16; 12, 17; 13, 18; 14, 19; 14, 20; 15, 21; 16, 22; 17, 23; 17, 24; 18, 25; 18, 26; 19, 27; 19, 28; 20, 29; 21, 30; 21, 31; 25, 32; 25, 33; 26, 34; 27, 35; 27, 36; 29, 37; 31, 38; 31, 39; 32, 40; 32, 41; 34, 42; 35, 43; 35, 44; 37, 45; 37, 46; 38, 47; 38, 48; 42, 49; 47, 50; 47, 51; 49, 52; 49, 53; 52, 54; 52, 55; 53, 56; 53, 57; 54, 58; 54, 59; 55, 60; 56, 61; 56, 62; 61, 63; 61, 64 | def wait_for_vacancy(self, processor_type):
"""Waits for a particular processor type to have the capacity to
handle additional transactions or until is_cancelled is True.
Args:
processor_type (ProcessorType): The family, and version of
the transaction processor.
Returns:
Processor
"""
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; 1, function_definition; 2, function_name:_get_sorting_message; 3, parameters; 4, block; 5, identifier:request; 6, identifier:key; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, if_statement; 11, if_statement; 12, return_statement; 13, comment:"""Parses the reverse query into a list of ClientSortControls protobuf
messages.
"""; 14, assignment; 15, assignment; 16, comparison_operator:reverse is None; 17, block; 18, comparison_operator:reverse.lower() == ""; 19, block; 20, elif_clause; 21, identifier:control_list; 22, identifier:control_list; 23, list; 24, identifier:reverse; 25, call; 26, identifier:reverse; 27, None; 28, return_statement; 29, call; 30, string:""; 31, expression_statement; 32, comparison_operator:reverse.lower() != 'false'; 33, block; 34, attribute; 35, argument_list; 36, identifier:control_list; 37, attribute; 38, argument_list; 39, call; 40, call; 41, string; 42, expression_statement; 43, attribute; 44, identifier:get; 45, string; 46, None; 47, identifier:reverse; 48, identifier:lower; 49, attribute; 50, argument_list; 51, attribute; 52, argument_list; 53, string_content:false; 54, call; 55, attribute; 56, identifier:query; 57, string_content:reverse; 58, identifier:control_list; 59, identifier:append; 60, call; 61, identifier:reverse; 62, identifier:lower; 63, attribute; 64, argument_list; 65, identifier:request; 66, identifier:url; 67, attribute; 68, argument_list; 69, identifier:control_list; 70, identifier:append; 71, call; 72, identifier:client_list_control_pb2; 73, identifier:ClientSortControls; 74, keyword_argument; 75, keyword_argument; 76, attribute; 77, argument_list; 78, identifier:reverse; 79, True; 80, identifier:keys; 81, call; 82, identifier:client_list_control_pb2; 83, identifier:ClientSortControls; 84, keyword_argument; 85, keyword_argument; 86, attribute; 87, argument_list; 88, identifier:reverse; 89, True; 90, identifier:keys; 91, call; 92, identifier:key; 93, identifier:split; 94, string:","; 95, attribute; 96, argument_list; 97, identifier:reverse; 98, identifier:split; 99, string:"," | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 7, 13; 8, 14; 9, 15; 10, 16; 10, 17; 11, 18; 11, 19; 11, 20; 12, 21; 14, 22; 14, 23; 15, 24; 15, 25; 16, 26; 16, 27; 17, 28; 18, 29; 18, 30; 19, 31; 20, 32; 20, 33; 25, 34; 25, 35; 28, 36; 29, 37; 29, 38; 31, 39; 32, 40; 32, 41; 33, 42; 34, 43; 34, 44; 35, 45; 35, 46; 37, 47; 37, 48; 39, 49; 39, 50; 40, 51; 40, 52; 41, 53; 42, 54; 43, 55; 43, 56; 45, 57; 49, 58; 49, 59; 50, 60; 51, 61; 51, 62; 54, 63; 54, 64; 55, 65; 55, 66; 60, 67; 60, 68; 63, 69; 63, 70; 64, 71; 67, 72; 67, 73; 68, 74; 68, 75; 71, 76; 71, 77; 74, 78; 74, 79; 75, 80; 75, 81; 76, 82; 76, 83; 77, 84; 77, 85; 81, 86; 81, 87; 84, 88; 84, 89; 85, 90; 85, 91; 86, 92; 86, 93; 87, 94; 91, 95; 91, 96; 95, 97; 95, 98; 96, 99 | def _get_sorting_message(request, key):
"""Parses the reverse query into a list of ClientSortControls protobuf
messages.
"""
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; 1, function_definition; 2, function_name:sort_resources; 3, parameters; 4, block; 5, identifier:cls; 6, identifier:request; 7, identifier:resources; 8, identifier:fail_enum; 9, default_parameter; 10, expression_statement; 11, if_statement; 12, expression_statement; 13, function_definition; 14, return_statement; 15, identifier:header_proto; 16, None; 17, comment:"""Sorts a list of resources based on a list of sort controls
Args:
request (object): The parsed protobuf request object
resources (list of objects): The resources to be sorted
fail_enum (int, enum): The enum status to raise with invalid keys
header_proto(class): Class to decode a resources header
Returns:
list: The sorted list of resources
"""; 18, not_operator; 19, block; 20, assignment; 21, function_name:sorter; 22, parameters; 23, block; 24, call; 25, attribute; 26, return_statement; 27, identifier:value_handlers; 28, call; 29, identifier:resource_a; 30, identifier:resource_b; 31, for_statement; 32, return_statement; 33, identifier:sorted; 34, argument_list; 35, identifier:request; 36, identifier:sorting; 37, identifier:resources; 38, attribute; 39, argument_list; 40, identifier:handler; 41, identifier:value_handlers; 42, block; 43, integer:0; 44, identifier:resources; 45, keyword_argument; 46, identifier:cls; 47, identifier:_get_handler_set; 48, identifier:request; 49, identifier:fail_enum; 50, identifier:header_proto; 51, expression_statement; 52, if_statement; 53, if_statement; 54, identifier:key; 55, call; 56, assignment; 57, comparison_operator:val_a < val_b; 58, block; 59, comparison_operator:val_a > val_b; 60, block; 61, identifier:cmp_to_key; 62, argument_list; 63, pattern_list; 64, call; 65, identifier:val_a; 66, identifier:val_b; 67, return_statement; 68, identifier:val_a; 69, identifier:val_b; 70, return_statement; 71, identifier:sorter; 72, identifier:val_a; 73, identifier:val_b; 74, attribute; 75, argument_list; 76, call; 77, call; 78, identifier:handler; 79, identifier:get_sort_values; 80, identifier:resource_a; 81, identifier:resource_b; 82, attribute; 83, argument_list; 84, attribute; 85, argument_list; 86, identifier:handler; 87, identifier:xform_result; 88, unary_operator; 89, identifier:handler; 90, identifier:xform_result; 91, integer:1; 92, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 9, 15; 9, 16; 10, 17; 11, 18; 11, 19; 12, 20; 13, 21; 13, 22; 13, 23; 14, 24; 18, 25; 19, 26; 20, 27; 20, 28; 22, 29; 22, 30; 23, 31; 23, 32; 24, 33; 24, 34; 25, 35; 25, 36; 26, 37; 28, 38; 28, 39; 31, 40; 31, 41; 31, 42; 32, 43; 34, 44; 34, 45; 38, 46; 38, 47; 39, 48; 39, 49; 39, 50; 42, 51; 42, 52; 42, 53; 45, 54; 45, 55; 51, 56; 52, 57; 52, 58; 53, 59; 53, 60; 55, 61; 55, 62; 56, 63; 56, 64; 57, 65; 57, 66; 58, 67; 59, 68; 59, 69; 60, 70; 62, 71; 63, 72; 63, 73; 64, 74; 64, 75; 67, 76; 70, 77; 74, 78; 74, 79; 75, 80; 75, 81; 76, 82; 76, 83; 77, 84; 77, 85; 82, 86; 82, 87; 83, 88; 84, 89; 84, 90; 85, 91; 88, 92 | def sort_resources(cls, request, resources, fail_enum, header_proto=None):
"""Sorts a list of resources based on a list of sort controls
Args:
request (object): The parsed protobuf request object
resources (list of objects): The resources to be sorted
fail_enum (int, enum): The enum status to raise with invalid keys
header_proto(class): Class to decode a resources header
Returns:
list: The sorted list of resources
"""
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; 1, function_definition; 2, function_name:_get_handler_set; 3, parameters; 4, block; 5, identifier:cls; 6, identifier:request; 7, identifier:fail_enum; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, for_statement; 13, return_statement; 14, identifier:header_proto; 15, None; 16, comment:"""Goes through the list of ClientSortControls and returns a list of
unique _ValueHandlers. Maintains order, but drops ClientSortControls
that have already appeared to help prevent spamming.
"""; 17, assignment; 18, assignment; 19, identifier:controls; 20, attribute; 21, block; 22, identifier:handlers; 23, identifier:added; 24, call; 25, identifier:handlers; 26, list; 27, identifier:request; 28, identifier:sorting; 29, expression_statement; 30, if_statement; 31, identifier:set; 32, argument_list; 33, assignment; 34, comparison_operator:control_bytes not in added; 35, block; 36, identifier:control_bytes; 37, call; 38, identifier:control_bytes; 39, identifier:added; 40, expression_statement; 41, expression_statement; 42, attribute; 43, argument_list; 44, call; 45, call; 46, identifier:controls; 47, identifier:SerializeToString; 48, attribute; 49, argument_list; 50, attribute; 51, argument_list; 52, identifier:added; 53, identifier:add; 54, identifier:control_bytes; 55, identifier:handlers; 56, identifier:append; 57, call; 58, attribute; 59, argument_list; 60, identifier:cls; 61, identifier:_ValueHandler; 62, identifier:controls; 63, identifier:fail_enum; 64, identifier:header_proto | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 8, 14; 8, 15; 9, 16; 10, 17; 11, 18; 12, 19; 12, 20; 12, 21; 13, 22; 17, 23; 17, 24; 18, 25; 18, 26; 20, 27; 20, 28; 21, 29; 21, 30; 24, 31; 24, 32; 29, 33; 30, 34; 30, 35; 33, 36; 33, 37; 34, 38; 34, 39; 35, 40; 35, 41; 37, 42; 37, 43; 40, 44; 41, 45; 42, 46; 42, 47; 44, 48; 44, 49; 45, 50; 45, 51; 48, 52; 48, 53; 49, 54; 50, 55; 50, 56; 51, 57; 57, 58; 57, 59; 58, 60; 58, 61; 59, 62; 59, 63; 59, 64 | def _get_handler_set(cls, request, fail_enum, header_proto=None):
"""Goes through the list of ClientSortControls and returns a list of
unique _ValueHandlers. Maintains order, but drops ClientSortControls
that have already appeared to help prevent spamming.
"""
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; 1, function_definition; 2, function_name:find_write_predecessors; 3, parameters; 4, block; 5, identifier:self; 6, identifier:address; 7, expression_statement; 8, comment:# A write operation must be preceded by:; 9, comment:# - The "enclosing writer", which is the writer at the address or; 10, comment:# the nearest writer higher (closer to the root) in the tree.; 11, comment:# - The "enclosing readers", which are the readers at the address; 12, comment:# or higher in the tree.; 13, comment:# - The "children writers", which include all writers which are; 14, comment:# lower in the tree than the address.; 15, comment:# - The "children readers", which include all readers which are; 16, comment:# lower in the tree than the address.; 17, comment:#; 18, comment:# The enclosing writer must be added as it may have modified a node; 19, comment:# which must not happen after the current write.; 20, comment:#; 21, comment:# Writers which are higher in the tree than the enclosing writer may; 22, comment:# have modified a node at or under the given address. However, we do; 23, comment:# not need to include them here as they will have been considered a; 24, comment:# predecessor to the enclosing writer.; 25, comment:#; 26, comment:# Enclosing readers must be included. Technically, we only need to add; 27, comment:# enclosing readers which occurred after the enclosing writer, since; 28, comment:# the readers preceding the writer will have been considered a; 29, comment:# predecessor of the enclosing writer. However, with the current; 30, comment:# data structure we can not determine the difference between readers; 31, comment:# so we specify them all; this is mostly harmless as it will not change; 32, comment:# the eventual sort order generated by the scheduler.; 33, comment:#; 34, comment:# Children readers must be added, since their reads must happen prior; 35, comment:# to the write.; 36, expression_statement; 37, expression_statement; 38, expression_statement; 39, expression_statement; 40, comment:# First, walk down from the root to the address, collecting all readers; 41, comment:# and updating the enclosing_writer if needed.; 42, try_statement; 43, comment:# Next, descend down the tree starting at the address node and; 44, comment:# find all descendant readers and writers.; 45, for_statement; 46, return_statement; 47, comment:"""Returns all predecessor transaction ids for a write of the provided
address.
Arguments:
address (str): the radix address
Returns: a set of transaction ids
"""; 48, assignment; 49, assignment; 50, assignment; 51, assignment; 52, block; 53, comment:# If the address isn't on the tree, then there aren't any; 54, comment:# predecessors below the node to worry about (because there; 55, comment:# isn't anything at all), so return the predecessors that have; 56, comment:# already been collected.; 57, except_clause; 58, finally_clause; 59, pattern_list; 60, identifier:node_stream; 61, block; 62, identifier:predecessors; 63, identifier:predecessors; 64, call; 65, identifier:enclosing_writer; 66, None; 67, identifier:node_stream; 68, call; 69, identifier:address_len; 70, call; 71, for_statement; 72, as_pattern; 73, block; 74, block; 75, identifier:_; 76, identifier:node; 77, if_statement; 78, identifier:set; 79, argument_list; 80, attribute; 81, argument_list; 82, identifier:len; 83, argument_list; 84, pattern_list; 85, identifier:node_stream; 86, block; 87, identifier:AddressNotInTree; 88, as_pattern_target; 89, if_statement; 90, return_statement; 91, if_statement; 92, comparison_operator:node is not None; 93, block; 94, attribute; 95, identifier:walk; 96, identifier:address; 97, identifier:address; 98, identifier:node_address; 99, identifier:node; 100, if_statement; 101, identifier:err; 102, comparison_operator:err.match is not None; 103, block; 104, identifier:predecessors; 105, comparison_operator:enclosing_writer is not None; 106, block; 107, identifier:node; 108, None; 109, if_statement; 110, expression_statement; 111, identifier:self; 112, identifier:_tree; 113, comparison_operator:node is not None; 114, block; 115, attribute; 116, None; 117, return_statement; 118, identifier:enclosing_writer; 119, None; 120, expression_statement; 121, comparison_operator:node.writer is not None; 122, block; 123, call; 124, identifier:node; 125, None; 126, expression_statement; 127, if_statement; 128, if_statement; 129, identifier:err; 130, identifier:match; 131, call; 132, call; 133, attribute; 134, None; 135, expression_statement; 136, attribute; 137, argument_list; 138, call; 139, comparison_operator:node.writer is not None; 140, block; 141, comparison_operator:len(node_address) >= address_len; 142, block; 143, attribute; 144, argument_list; 145, attribute; 146, argument_list; 147, identifier:node; 148, identifier:writer; 149, call; 150, identifier:predecessors; 151, identifier:update; 152, attribute; 153, attribute; 154, argument_list; 155, attribute; 156, None; 157, expression_statement; 158, call; 159, identifier:address_len; 160, break_statement; 161, identifier:self; 162, identifier:find_write_predecessors; 163, attribute; 164, identifier:predecessors; 165, identifier:add; 166, identifier:enclosing_writer; 167, attribute; 168, argument_list; 169, identifier:node; 170, identifier:readers; 171, identifier:predecessors; 172, identifier:update; 173, attribute; 174, identifier:node; 175, identifier:writer; 176, assignment; 177, identifier:len; 178, argument_list; 179, identifier:err; 180, identifier:match; 181, identifier:predecessors; 182, identifier:add; 183, attribute; 184, identifier:node; 185, identifier:readers; 186, identifier:enclosing_writer; 187, attribute; 188, identifier:node_address; 189, identifier:node; 190, identifier:writer; 191, identifier:node; 192, identifier:writer | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 4, 27; 4, 28; 4, 29; 4, 30; 4, 31; 4, 32; 4, 33; 4, 34; 4, 35; 4, 36; 4, 37; 4, 38; 4, 39; 4, 40; 4, 41; 4, 42; 4, 43; 4, 44; 4, 45; 4, 46; 7, 47; 36, 48; 37, 49; 38, 50; 39, 51; 42, 52; 42, 53; 42, 54; 42, 55; 42, 56; 42, 57; 42, 58; 45, 59; 45, 60; 45, 61; 46, 62; 48, 63; 48, 64; 49, 65; 49, 66; 50, 67; 50, 68; 51, 69; 51, 70; 52, 71; 57, 72; 57, 73; 58, 74; 59, 75; 59, 76; 61, 77; 64, 78; 64, 79; 68, 80; 68, 81; 70, 82; 70, 83; 71, 84; 71, 85; 71, 86; 72, 87; 72, 88; 73, 89; 73, 90; 74, 91; 77, 92; 77, 93; 80, 94; 80, 95; 81, 96; 83, 97; 84, 98; 84, 99; 86, 100; 88, 101; 89, 102; 89, 103; 90, 104; 91, 105; 91, 106; 92, 107; 92, 108; 93, 109; 93, 110; 94, 111; 94, 112; 100, 113; 100, 114; 102, 115; 102, 116; 103, 117; 105, 118; 105, 119; 106, 120; 109, 121; 109, 122; 110, 123; 113, 124; 113, 125; 114, 126; 114, 127; 114, 128; 115, 129; 115, 130; 117, 131; 120, 132; 121, 133; 121, 134; 122, 135; 123, 136; 123, 137; 126, 138; 127, 139; 127, 140; 128, 141; 128, 142; 131, 143; 131, 144; 132, 145; 132, 146; 133, 147; 133, 148; 135, 149; 136, 150; 136, 151; 137, 152; 138, 153; 138, 154; 139, 155; 139, 156; 140, 157; 141, 158; 141, 159; 142, 160; 143, 161; 143, 162; 144, 163; 145, 164; 145, 165; 146, 166; 149, 167; 149, 168; 152, 169; 152, 170; 153, 171; 153, 172; 154, 173; 155, 174; 155, 175; 157, 176; 158, 177; 158, 178; 163, 179; 163, 180; 167, 181; 167, 182; 168, 183; 173, 184; 173, 185; 176, 186; 176, 187; 178, 188; 183, 189; 183, 190; 187, 191; 187, 192 | def find_write_predecessors(self, address):
"""Returns all predecessor transaction ids for a write of the provided
address.
Arguments:
address (str): the radix address
Returns: a set of transaction ids
"""
# A write operation must be preceded by:
# - The "enclosing writer", which is the writer at the address or
# the nearest writer higher (closer to the root) in the tree.
# - The "enclosing readers", which are the readers at the address
# or higher in the tree.
# - The "children writers", which include all writers which are
# lower in the tree than the address.
# - The "children readers", which include all readers which are
# lower in the tree than the address.
#
# The enclosing writer must be added as it may have modified a node
# which must not happen after the current write.
#
# Writers which are higher in the tree than the enclosing writer may
# have modified a node at or under the given address. However, we do
# not need to include them here as they will have been considered a
# predecessor to the enclosing writer.
#
# Enclosing readers must be included. Technically, we only need to add
# enclosing readers which occurred after the enclosing writer, since
# the readers preceding the writer will have been considered a
# predecessor of the enclosing writer. However, with the current
# data structure we can not determine the difference between readers
# so we specify them all; this is mostly harmless as it will not change
# the eventual sort order generated by the scheduler.
#
# Children readers must be added, since their reads must happen prior
# to the write.
predecessors = set()
enclosing_writer = None
node_stream = self._tree.walk(address)
address_len = len(address)
# First, walk down from the root to the address, collecting all readers
# and updating the enclosing_writer if needed.
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
# If the address isn't on the tree, then there aren't any
# predecessors below the node to worry about (because there
# isn't anything at all), so return the predecessors that have
# already been collected.
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)
# Next, descend down the tree starting at the address node and
# find all descendant readers and writers.
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; 1, function_definition; 2, function_name:_get_efron_values_single; 3, parameters; 4, block; 5, identifier:self; 6, identifier:X; 7, identifier:T; 8, identifier:E; 9, identifier:weights; 10, identifier:beta; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, comment:# Init risk and tie sums to zero; 17, expression_statement; 18, expression_statement; 19, expression_statement; 20, expression_statement; 21, comment:# Init number of ties and weights; 22, expression_statement; 23, expression_statement; 24, expression_statement; 25, comment:# Iterate backwards to utilize recursive relationship; 26, for_statement; 27, return_statement; 28, comment:"""
Calculates the first and second order vector differentials, with respect to beta.
Note that X, T, E are assumed to be sorted on T!
A good explanation for Efron. Consider three of five subjects who fail at the time.
As it is not known a priori that who is the first to fail, so one-third of
(φ1 + φ2 + φ3) is adjusted from sum_j^{5} φj after one fails. Similarly two-third
of (φ1 + φ2 + φ3) is adjusted after first two individuals fail, etc.
From https://cran.r-project.org/web/packages/survival/survival.pdf:
"Setting all weights to 2 for instance will give the same coefficient estimate but halve the variance. When
the Efron approximation for ties (default) is employed replication of the data will not give exactly the same coefficients as the
weights option, and in this case the weighted fit is arguably the correct one."
Parameters
----------
X: array
(n,d) numpy array of observations.
T: array
(n) numpy array representing observed durations.
E: array
(n) numpy array representing death events.
weights: array
(n) an array representing weights per observation.
beta: array
(1, d) numpy array of coefficients.
Returns
-------
hessian:
(d, d) numpy array,
gradient:
(1, d) numpy array
log_likelihood: float
"""; 29, assignment; 30, assignment; 31, assignment; 32, assignment; 33, assignment; 34, assignment; 35, assignment; 36, assignment; 37, assignment; 38, assignment; 39, assignment; 40, identifier:i; 41, call; 42, comment:# Doing it like this to preserve shape; 43, block; 44, expression_list; 45, pattern_list; 46, attribute; 47, identifier:hessian; 48, call; 49, identifier:gradient; 50, call; 51, identifier:log_lik; 52, integer:0; 53, identifier:x_death_sum; 54, call; 55, pattern_list; 56, expression_list; 57, pattern_list; 58, expression_list; 59, pattern_list; 60, expression_list; 61, identifier:weight_count; 62, float:0.0; 63, identifier:tied_death_counts; 64, integer:0; 65, identifier:scores; 66, binary_operator:weights * np.exp(np.dot(X, beta)); 67, identifier:range; 68, argument_list; 69, expression_statement; 70, expression_statement; 71, expression_statement; 72, expression_statement; 73, expression_statement; 74, comment:# Calculate phi values; 75, expression_statement; 76, expression_statement; 77, expression_statement; 78, comment:# Calculate sums of Risk set; 79, expression_statement; 80, expression_statement; 81, expression_statement; 82, comment:# Calculate sums of Ties, if this is an event; 83, if_statement; 84, if_statement; 85, comment:# There was atleast one event and no more ties remain. Time to sum.; 86, comment:#; 87, comment:# This code is near identical to the _batch algorithm below. In fact, see _batch for comments.; 88, comment:#; 89, expression_statement; 90, if_statement; 91, expression_statement; 92, expression_statement; 93, expression_statement; 94, expression_statement; 95, expression_statement; 96, comment:# reset tie values; 97, expression_statement; 98, expression_statement; 99, expression_statement; 100, expression_statement; 101, expression_statement; 102, expression_statement; 103, identifier:hessian; 104, identifier:gradient; 105, identifier:log_lik; 106, identifier:n; 107, identifier:d; 108, identifier:X; 109, identifier:shape; 110, attribute; 111, argument_list; 112, attribute; 113, argument_list; 114, attribute; 115, argument_list; 116, identifier:risk_phi; 117, identifier:tie_phi; 118, integer:0; 119, integer:0; 120, identifier:risk_phi_x; 121, identifier:tie_phi_x; 122, call; 123, call; 124, identifier:risk_phi_x_x; 125, identifier:tie_phi_x_x; 126, call; 127, call; 128, identifier:weights; 129, call; 130, binary_operator:n - 1; 131, unary_operator; 132, unary_operator; 133, assignment; 134, assignment; 135, assignment; 136, assignment; 137, assignment; 138, assignment; 139, assignment; 140, assignment; 141, assignment; 142, assignment; 143, assignment; 144, identifier:ei; 145, block; 146, boolean_operator; 147, comment:# There are more ties/members of the risk set; 148, block; 149, elif_clause; 150, assignment; 151, comparison_operator:tied_death_counts > 1; 152, block; 153, else_clause; 154, assignment; 155, assignment; 156, assignment; 157, assignment; 158, assignment; 159, assignment; 160, assignment; 161, assignment; 162, assignment; 163, assignment; 164, assignment; 165, identifier:np; 166, identifier:zeros; 167, tuple; 168, identifier:np; 169, identifier:zeros; 170, tuple; 171, identifier:np; 172, identifier:zeros; 173, tuple; 174, attribute; 175, argument_list; 176, attribute; 177, argument_list; 178, attribute; 179, argument_list; 180, attribute; 181, argument_list; 182, attribute; 183, argument_list; 184, identifier:n; 185, integer:1; 186, integer:1; 187, integer:1; 188, identifier:ti; 189, subscript; 190, identifier:ei; 191, subscript; 192, identifier:xi; 193, subscript; 194, identifier:score; 195, subscript; 196, identifier:w; 197, subscript; 198, identifier:phi_i; 199, identifier:score; 200, identifier:phi_x_i; 201, binary_operator:phi_i * xi; 202, identifier:phi_x_x_i; 203, call; 204, identifier:risk_phi; 205, binary_operator:risk_phi + phi_i; 206, identifier:risk_phi_x; 207, binary_operator:risk_phi_x + phi_x_i; 208, identifier:risk_phi_x_x; 209, binary_operator:risk_phi_x_x + phi_x_x_i; 210, expression_statement; 211, expression_statement; 212, expression_statement; 213, expression_statement; 214, comment:# Keep track of count; 215, expression_statement; 216, expression_statement; 217, comparison_operator:i > 0; 218, comparison_operator:T[i - 1] == ti; 219, continue_statement; 220, comparison_operator:tied_death_counts == 0; 221, comment:# Only censored with current time, move on; 222, block; 223, identifier:weighted_average; 224, binary_operator:weight_count / tied_death_counts; 225, identifier:tied_death_counts; 226, integer:1; 227, expression_statement; 228, expression_statement; 229, expression_statement; 230, expression_statement; 231, block; 232, identifier:summand; 233, binary_operator:numer * denom[:, None]; 234, identifier:a2; 235, call; 236, identifier:gradient; 237, binary_operator:gradient + x_death_sum - weighted_average * summand.sum(0); 238, identifier:log_lik; 239, binary_operator:log_lik + np.dot(x_death_sum, beta) + weighted_average * np.log(denom).sum(); 240, identifier:hessian; 241, binary_operator:hessian + weighted_average * (a2 - a1); 242, identifier:tied_death_counts; 243, integer:0; 244, identifier:weight_count; 245, float:0.0; 246, identifier:x_death_sum; 247, call; 248, identifier:tie_phi; 249, integer:0; 250, identifier:tie_phi_x; 251, call; 252, identifier:tie_phi_x_x; 253, call; 254, identifier:d; 255, identifier:d; 256, identifier:d; 257, identifier:d; 258, identifier:np; 259, identifier:zeros; 260, tuple; 261, identifier:np; 262, identifier:zeros; 263, tuple; 264, identifier:np; 265, identifier:zeros; 266, tuple; 267, identifier:np; 268, identifier:zeros; 269, tuple; 270, identifier:np; 271, identifier:exp; 272, call; 273, identifier:T; 274, identifier:i; 275, identifier:E; 276, identifier:i; 277, identifier:X; 278, identifier:i; 279, identifier:scores; 280, identifier:i; 281, identifier:weights; 282, identifier:i; 283, identifier:phi_i; 284, identifier:xi; 285, attribute; 286, argument_list; 287, identifier:risk_phi; 288, identifier:phi_i; 289, identifier:risk_phi_x; 290, identifier:phi_x_i; 291, identifier:risk_phi_x_x; 292, identifier:phi_x_x_i; 293, assignment; 294, assignment; 295, assignment; 296, assignment; 297, augmented_assignment; 298, augmented_assignment; 299, identifier:i; 300, integer:0; 301, subscript; 302, identifier:ti; 303, identifier:tied_death_counts; 304, integer:0; 305, continue_statement; 306, identifier:weight_count; 307, identifier:tied_death_counts; 308, assignment; 309, assignment; 310, assignment; 311, assignment; 312, expression_statement; 313, expression_statement; 314, expression_statement; 315, identifier:numer; 316, subscript; 317, attribute; 318, argument_list; 319, binary_operator:gradient + x_death_sum; 320, binary_operator:weighted_average * summand.sum(0); 321, binary_operator:log_lik + np.dot(x_death_sum, beta); 322, binary_operator:weighted_average * np.log(denom).sum(); 323, identifier:hessian; 324, binary_operator:weighted_average * (a2 - a1); 325, attribute; 326, argument_list; 327, attribute; 328, argument_list; 329, attribute; 330, argument_list; 331, identifier:d; 332, identifier:d; 333, identifier:d; 334, identifier:d; 335, identifier:d; 336, identifier:d; 337, attribute; 338, argument_list; 339, identifier:np; 340, identifier:outer; 341, identifier:xi; 342, identifier:phi_x_i; 343, identifier:x_death_sum; 344, binary_operator:x_death_sum + w * xi; 345, identifier:tie_phi; 346, binary_operator:tie_phi + phi_i; 347, identifier:tie_phi_x; 348, binary_operator:tie_phi_x + phi_x_i; 349, identifier:tie_phi_x_x; 350, binary_operator:tie_phi_x_x + phi_x_x_i; 351, identifier:tied_death_counts; 352, integer:1; 353, identifier:weight_count; 354, identifier:w; 355, identifier:T; 356, binary_operator:i - 1; 357, identifier:increasing_proportion; 358, binary_operator:np.arange(tied_death_counts) / tied_death_counts; 359, identifier:denom; 360, binary_operator:1.0 / (risk_phi - increasing_proportion * tie_phi); 361, identifier:numer; 362, binary_operator:risk_phi_x - np.outer(increasing_proportion, tie_phi_x); 363, identifier:a1; 364, binary_operator:np.einsum("ab,i->ab", risk_phi_x_x, denom) - np.einsum(
"ab,i->ab", tie_phi_x_x, increasing_proportion * denom
); 365, assignment; 366, assignment; 367, assignment; 368, identifier:denom; 369, slice; 370, None; 371, attribute; 372, identifier:dot; 373, identifier:summand; 374, identifier:gradient; 375, identifier:x_death_sum; 376, identifier:weighted_average; 377, call; 378, identifier:log_lik; 379, call; 380, identifier:weighted_average; 381, call; 382, identifier:weighted_average; 383, parenthesized_expression; 384, identifier:np; 385, identifier:zeros; 386, tuple; 387, identifier:np; 388, identifier:zeros; 389, tuple; 390, identifier:np; 391, identifier:zeros; 392, tuple; 393, identifier:np; 394, identifier:dot; 395, identifier:X; 396, identifier:beta; 397, identifier:x_death_sum; 398, binary_operator:w * xi; 399, identifier:tie_phi; 400, identifier:phi_i; 401, identifier:tie_phi_x; 402, identifier:phi_x_i; 403, identifier:tie_phi_x_x; 404, identifier:phi_x_x_i; 405, identifier:i; 406, integer:1; 407, call; 408, identifier:tied_death_counts; 409, float:1.0; 410, parenthesized_expression; 411, identifier:risk_phi_x; 412, call; 413, call; 414, call; 415, identifier:denom; 416, binary_operator:1.0 / np.array([risk_phi]); 417, identifier:numer; 418, identifier:risk_phi_x; 419, identifier:a1; 420, binary_operator:risk_phi_x_x * denom; 421, identifier:summand; 422, identifier:T; 423, attribute; 424, argument_list; 425, attribute; 426, argument_list; 427, attribute; 428, argument_list; 429, binary_operator:a2 - a1; 430, identifier:d; 431, identifier:d; 432, identifier:d; 433, identifier:d; 434, identifier:w; 435, identifier:xi; 436, attribute; 437, argument_list; 438, binary_operator:risk_phi - increasing_proportion * tie_phi; 439, attribute; 440, argument_list; 441, attribute; 442, argument_list; 443, attribute; 444, argument_list; 445, float:1.0; 446, call; 447, identifier:risk_phi_x_x; 448, identifier:denom; 449, identifier:summand; 450, identifier:sum; 451, integer:0; 452, identifier:np; 453, identifier:dot; 454, identifier:x_death_sum; 455, identifier:beta; 456, call; 457, identifier:sum; 458, identifier:a2; 459, identifier:a1; 460, identifier:np; 461, identifier:arange; 462, identifier:tied_death_counts; 463, identifier:risk_phi; 464, binary_operator:increasing_proportion * tie_phi; 465, identifier:np; 466, identifier:outer; 467, identifier:increasing_proportion; 468, identifier:tie_phi_x; 469, identifier:np; 470, identifier:einsum; 471, string:"ab,i->ab"; 472, identifier:risk_phi_x_x; 473, identifier:denom; 474, identifier:np; 475, identifier:einsum; 476, string:"ab,i->ab"; 477, identifier:tie_phi_x_x; 478, binary_operator:increasing_proportion * denom; 479, attribute; 480, argument_list; 481, attribute; 482, argument_list; 483, identifier:increasing_proportion; 484, identifier:tie_phi; 485, identifier:increasing_proportion; 486, identifier:denom; 487, identifier:np; 488, identifier:array; 489, list; 490, identifier:np; 491, identifier:log; 492, identifier:denom; 493, identifier:risk_phi | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 4, 27; 11, 28; 12, 29; 13, 30; 14, 31; 15, 32; 17, 33; 18, 34; 19, 35; 20, 36; 22, 37; 23, 38; 24, 39; 26, 40; 26, 41; 26, 42; 26, 43; 27, 44; 29, 45; 29, 46; 30, 47; 30, 48; 31, 49; 31, 50; 32, 51; 32, 52; 33, 53; 33, 54; 34, 55; 34, 56; 35, 57; 35, 58; 36, 59; 36, 60; 37, 61; 37, 62; 38, 63; 38, 64; 39, 65; 39, 66; 41, 67; 41, 68; 43, 69; 43, 70; 43, 71; 43, 72; 43, 73; 43, 74; 43, 75; 43, 76; 43, 77; 43, 78; 43, 79; 43, 80; 43, 81; 43, 82; 43, 83; 43, 84; 43, 85; 43, 86; 43, 87; 43, 88; 43, 89; 43, 90; 43, 91; 43, 92; 43, 93; 43, 94; 43, 95; 43, 96; 43, 97; 43, 98; 43, 99; 43, 100; 43, 101; 43, 102; 44, 103; 44, 104; 44, 105; 45, 106; 45, 107; 46, 108; 46, 109; 48, 110; 48, 111; 50, 112; 50, 113; 54, 114; 54, 115; 55, 116; 55, 117; 56, 118; 56, 119; 57, 120; 57, 121; 58, 122; 58, 123; 59, 124; 59, 125; 60, 126; 60, 127; 66, 128; 66, 129; 68, 130; 68, 131; 68, 132; 69, 133; 70, 134; 71, 135; 72, 136; 73, 137; 75, 138; 76, 139; 77, 140; 79, 141; 80, 142; 81, 143; 83, 144; 83, 145; 84, 146; 84, 147; 84, 148; 84, 149; 89, 150; 90, 151; 90, 152; 90, 153; 91, 154; 92, 155; 93, 156; 94, 157; 95, 158; 97, 159; 98, 160; 99, 161; 100, 162; 101, 163; 102, 164; 110, 165; 110, 166; 111, 167; 112, 168; 112, 169; 113, 170; 114, 171; 114, 172; 115, 173; 122, 174; 122, 175; 123, 176; 123, 177; 126, 178; 126, 179; 127, 180; 127, 181; 129, 182; 129, 183; 130, 184; 130, 185; 131, 186; 132, 187; 133, 188; 133, 189; 134, 190; 134, 191; 135, 192; 135, 193; 136, 194; 136, 195; 137, 196; 137, 197; 138, 198; 138, 199; 139, 200; 139, 201; 140, 202; 140, 203; 141, 204; 141, 205; 142, 206; 142, 207; 143, 208; 143, 209; 145, 210; 145, 211; 145, 212; 145, 213; 145, 214; 145, 215; 145, 216; 146, 217; 146, 218; 148, 219; 149, 220; 149, 221; 149, 222; 150, 223; 150, 224; 151, 225; 151, 226; 152, 227; 152, 228; 152, 229; 152, 230; 153, 231; 154, 232; 154, 233; 155, 234; 155, 235; 156, 236; 156, 237; 157, 238; 157, 239; 158, 240; 158, 241; 159, 242; 159, 243; 160, 244; 160, 245; 161, 246; 161, 247; 162, 248; 162, 249; 163, 250; 163, 251; 164, 252; 164, 253; 167, 254; 167, 255; 170, 256; 173, 257; 174, 258; 174, 259; 175, 260; 176, 261; 176, 262; 177, 263; 178, 264; 178, 265; 179, 266; 180, 267; 180, 268; 181, 269; 182, 270; 182, 271; 183, 272; 189, 273; 189, 274; 191, 275; 191, 276; 193, 277; 193, 278; 195, 279; 195, 280; 197, 281; 197, 282; 201, 283; 201, 284; 203, 285; 203, 286; 205, 287; 205, 288; 207, 289; 207, 290; 209, 291; 209, 292; 210, 293; 211, 294; 212, 295; 213, 296; 215, 297; 216, 298; 217, 299; 217, 300; 218, 301; 218, 302; 220, 303; 220, 304; 222, 305; 224, 306; 224, 307; 227, 308; 228, 309; 229, 310; 230, 311; 231, 312; 231, 313; 231, 314; 233, 315; 233, 316; 235, 317; 235, 318; 237, 319; 237, 320; 239, 321; 239, 322; 241, 323; 241, 324; 247, 325; 247, 326; 251, 327; 251, 328; 253, 329; 253, 330; 260, 331; 263, 332; 266, 333; 266, 334; 269, 335; 269, 336; 272, 337; 272, 338; 285, 339; 285, 340; 286, 341; 286, 342; 293, 343; 293, 344; 294, 345; 294, 346; 295, 347; 295, 348; 296, 349; 296, 350; 297, 351; 297, 352; 298, 353; 298, 354; 301, 355; 301, 356; 308, 357; 308, 358; 309, 359; 309, 360; 310, 361; 310, 362; 311, 363; 311, 364; 312, 365; 313, 366; 314, 367; 316, 368; 316, 369; 316, 370; 317, 371; 317, 372; 318, 373; 319, 374; 319, 375; 320, 376; 320, 377; 321, 378; 321, 379; 322, 380; 322, 381; 324, 382; 324, 383; 325, 384; 325, 385; 326, 386; 327, 387; 327, 388; 328, 389; 329, 390; 329, 391; 330, 392; 337, 393; 337, 394; 338, 395; 338, 396; 344, 397; 344, 398; 346, 399; 346, 400; 348, 401; 348, 402; 350, 403; 350, 404; 356, 405; 356, 406; 358, 407; 358, 408; 360, 409; 360, 410; 362, 411; 362, 412; 364, 413; 364, 414; 365, 415; 365, 416; 366, 417; 366, 418; 367, 419; 367, 420; 371, 421; 371, 422; 377, 423; 377, 424; 379, 425; 379, 426; 381, 427; 381, 428; 383, 429; 386, 430; 389, 431; 392, 432; 392, 433; 398, 434; 398, 435; 407, 436; 407, 437; 410, 438; 412, 439; 412, 440; 413, 441; 413, 442; 414, 443; 414, 444; 416, 445; 416, 446; 420, 447; 420, 448; 423, 449; 423, 450; 424, 451; 425, 452; 425, 453; 426, 454; 426, 455; 427, 456; 427, 457; 429, 458; 429, 459; 436, 460; 436, 461; 437, 462; 438, 463; 438, 464; 439, 465; 439, 466; 440, 467; 440, 468; 441, 469; 441, 470; 442, 471; 442, 472; 442, 473; 443, 474; 443, 475; 444, 476; 444, 477; 444, 478; 446, 479; 446, 480; 456, 481; 456, 482; 464, 483; 464, 484; 478, 485; 478, 486; 479, 487; 479, 488; 480, 489; 481, 490; 481, 491; 482, 492; 489, 493 | def _get_efron_values_single(self, X, T, E, weights, beta):
"""
Calculates the first and second order vector differentials, with respect to beta.
Note that X, T, E are assumed to be sorted on T!
A good explanation for Efron. Consider three of five subjects who fail at the time.
As it is not known a priori that who is the first to fail, so one-third of
(φ1 + φ2 + φ3) is adjusted from sum_j^{5} φj after one fails. Similarly two-third
of (φ1 + φ2 + φ3) is adjusted after first two individuals fail, etc.
From https://cran.r-project.org/web/packages/survival/survival.pdf:
"Setting all weights to 2 for instance will give the same coefficient estimate but halve the variance. When
the Efron approximation for ties (default) is employed replication of the data will not give exactly the same coefficients as the
weights option, and in this case the weighted fit is arguably the correct one."
Parameters
----------
X: array
(n,d) numpy array of observations.
T: array
(n) numpy array representing observed durations.
E: array
(n) numpy array representing death events.
weights: array
(n) an array representing weights per observation.
beta: array
(1, d) numpy array of coefficients.
Returns
-------
hessian:
(d, d) numpy array,
gradient:
(1, d) numpy array
log_likelihood: float
"""
n, d = X.shape
hessian = np.zeros((d, d))
gradient = np.zeros((d,))
log_lik = 0
# Init risk and tie sums to zero
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))
# Init number of ties and weights
weight_count = 0.0
tied_death_counts = 0
scores = weights * np.exp(np.dot(X, beta))
# Iterate backwards to utilize recursive relationship
for i in range(n - 1, -1, -1):
# Doing it like this to preserve shape
ti = T[i]
ei = E[i]
xi = X[i]
score = scores[i]
w = weights[i]
# Calculate phi values
phi_i = score
phi_x_i = phi_i * xi
phi_x_x_i = np.outer(xi, phi_x_i)
# Calculate sums of Risk set
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
# Calculate sums of Ties, if this is an event
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
# Keep track of count
tied_death_counts += 1
weight_count += w
if i > 0 and T[i - 1] == ti:
# There are more ties/members of the risk set
continue
elif tied_death_counts == 0:
# Only censored with current time, move on
continue
# There was atleast one event and no more ties remain. Time to sum.
#
# This code is near identical to the _batch algorithm below. In fact, see _batch for comments.
#
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)
# reset tie values
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; 1, function_definition; 2, function_name:_get_efron_values_batch; 3, parameters; 4, comment:# pylint: disable=too-many-locals; 5, block; 6, identifier:self; 7, identifier:X; 8, identifier:T; 9, identifier:E; 10, identifier:weights; 11, identifier:beta; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, comment:# weights = weights[:, None]; 18, comment:# Init risk and tie sums to zero; 19, expression_statement; 20, expression_statement; 21, expression_statement; 22, comment:# counts are sorted by -T; 23, expression_statement; 24, expression_statement; 25, expression_statement; 26, for_statement; 27, return_statement; 28, comment:"""
Assumes sorted on ascending on T
Calculates the first and second order vector differentials, with respect to beta.
A good explanation for how Efron handles ties. Consider three of five subjects who fail at the time.
As it is not known a priori that who is the first to fail, so one-third of
(φ1 + φ2 + φ3) is adjusted from sum_j^{5} φj after one fails. Similarly two-third
of (φ1 + φ2 + φ3) is adjusted after first two individuals fail, etc.
Returns
-------
hessian: (d, d) numpy array,
gradient: (1, d) numpy array
log_likelihood: float
"""; 29, assignment; 30, assignment; 31, assignment; 32, assignment; 33, assignment; 34, assignment; 35, assignment; 36, assignment; 37, assignment; 38, assignment; 39, identifier:count_of_removals; 40, identifier:counts; 41, block; 42, expression_list; 43, pattern_list; 44, attribute; 45, identifier:hessian; 46, call; 47, identifier:gradient; 48, call; 49, identifier:log_lik; 50, integer:0; 51, pattern_list; 52, expression_list; 53, pattern_list; 54, expression_list; 55, pattern_list; 56, expression_list; 57, pattern_list; 58, call; 59, identifier:scores; 60, binary_operator:weights * np.exp(np.dot(X, beta)); 61, identifier:pos; 62, identifier:n; 63, expression_statement; 64, expression_statement; 65, expression_statement; 66, expression_statement; 67, expression_statement; 68, expression_statement; 69, comment:# Calculate sums of Risk set; 70, expression_statement; 71, expression_statement; 72, expression_statement; 73, comment:# Calculate the sums of Tie set; 74, expression_statement; 75, expression_statement; 76, if_statement; 77, expression_statement; 78, expression_statement; 79, expression_statement; 80, expression_statement; 81, expression_statement; 82, if_statement; 83, expression_statement; 84, comment:# This is a batch outer product.; 85, comment:# given a matrix t, for each row, m, compute it's outer product: m.dot(m.T), and stack these new matrices together.; 86, comment:# which would be: np.einsum("Bi, Bj->Bij", t, t); 87, expression_statement; 88, expression_statement; 89, expression_statement; 90, expression_statement; 91, expression_statement; 92, identifier:hessian; 93, identifier:gradient; 94, identifier:log_lik; 95, identifier:n; 96, identifier:d; 97, identifier:X; 98, identifier:shape; 99, attribute; 100, argument_list; 101, attribute; 102, argument_list; 103, identifier:risk_phi; 104, identifier:tie_phi; 105, integer:0; 106, integer:0; 107, identifier:risk_phi_x; 108, identifier:tie_phi_x; 109, call; 110, call; 111, identifier:risk_phi_x_x; 112, identifier:tie_phi_x_x; 113, call; 114, call; 115, identifier:_; 116, identifier:counts; 117, attribute; 118, argument_list; 119, identifier:weights; 120, call; 121, assignment; 122, assignment; 123, assignment; 124, assignment; 125, assignment; 126, assignment; 127, assignment; 128, assignment; 129, assignment; 130, assignment; 131, assignment; 132, comparison_operator:tied_death_counts == 0; 133, comment:# no deaths, can continue; 134, block; 135, assignment; 136, assignment; 137, assignment; 138, assignment; 139, assignment; 140, comparison_operator:tied_death_counts > 1; 141, comment:# a lot of this is now in Einstein notation for performance, but see original "expanded" code here; 142, comment:# https://github.com/CamDavidsonPilon/lifelines/blob/e7056e7817272eb5dff5983556954f56c33301b1/lifelines/fitters/coxph_fitter.py#L755-L789; 143, comment:# it's faster if we can skip computing these when we don't need to.; 144, block; 145, else_clause; 146, assignment; 147, assignment; 148, assignment; 149, assignment; 150, assignment; 151, augmented_assignment; 152, identifier:np; 153, identifier:zeros; 154, tuple; 155, identifier:np; 156, identifier:zeros; 157, tuple; 158, attribute; 159, argument_list; 160, attribute; 161, argument_list; 162, attribute; 163, argument_list; 164, attribute; 165, argument_list; 166, identifier:np; 167, identifier:unique; 168, unary_operator; 169, keyword_argument; 170, attribute; 171, argument_list; 172, identifier:slice_; 173, call; 174, identifier:X_at_t; 175, subscript; 176, identifier:weights_at_t; 177, subscript; 178, identifier:phi_i; 179, subscript; 180, identifier:phi_x_i; 181, binary_operator:phi_i * X_at_t; 182, identifier:phi_x_x_i; 183, call; 184, identifier:risk_phi; 185, binary_operator:risk_phi + array_sum_to_scalar(phi_i); 186, identifier:risk_phi_x; 187, binary_operator:risk_phi_x + matrix_axis_0_sum_to_array(phi_x_i); 188, identifier:risk_phi_x_x; 189, binary_operator:risk_phi_x_x + phi_x_x_i; 190, identifier:deaths; 191, subscript; 192, identifier:tied_death_counts; 193, call; 194, identifier:tied_death_counts; 195, integer:0; 196, expression_statement; 197, continue_statement; 198, identifier:xi_deaths; 199, subscript; 200, identifier:weights_deaths; 201, subscript; 202, identifier:x_death_sum; 203, call; 204, identifier:weight_count; 205, call; 206, identifier:weighted_average; 207, binary_operator:weight_count / tied_death_counts; 208, identifier:tied_death_counts; 209, integer:1; 210, expression_statement; 211, expression_statement; 212, expression_statement; 213, expression_statement; 214, expression_statement; 215, expression_statement; 216, comment:# computes outer products and sums them together.; 217, comment:# Naive approach is to; 218, comment:# 1) broadcast tie_phi_x_x and increasing_proportion into a (tied_death_counts, d, d) matrix; 219, comment:# 2) broadcast risk_phi_x_x and denom into a (tied_death_counts, d, d) matrix; 220, comment:# 3) subtract them, and then sum to (d, d); 221, comment:# Alternatively, we can sum earlier without having to explicitly create (_, d, d) matrices. This is used here.; 222, comment:#; 223, expression_statement; 224, comment:# no tensors here, but do some casting to make it easier in the converging step next.; 225, block; 226, identifier:summand; 227, binary_operator:numer * denom[:, None]; 228, identifier:a2; 229, call; 230, identifier:gradient; 231, binary_operator:gradient + x_death_sum - weighted_average * summand.sum(0); 232, identifier:log_lik; 233, binary_operator:log_lik + np.dot(x_death_sum, beta) + weighted_average * np.log(denom).sum(); 234, identifier:hessian; 235, binary_operator:hessian + weighted_average * (a2 - a1); 236, identifier:pos; 237, identifier:count_of_removals; 238, identifier:d; 239, identifier:d; 240, identifier:d; 241, identifier:np; 242, identifier:zeros; 243, tuple; 244, identifier:np; 245, identifier:zeros; 246, tuple; 247, identifier:np; 248, identifier:zeros; 249, tuple; 250, identifier:np; 251, identifier:zeros; 252, tuple; 253, identifier:T; 254, identifier:return_counts; 255, True; 256, identifier:np; 257, identifier:exp; 258, call; 259, identifier:slice; 260, argument_list; 261, identifier:X; 262, identifier:slice_; 263, identifier:weights; 264, identifier:slice_; 265, identifier:scores; 266, identifier:slice_; 267, None; 268, identifier:phi_i; 269, identifier:X_at_t; 270, attribute; 271, argument_list; 272, identifier:risk_phi; 273, call; 274, identifier:risk_phi_x; 275, call; 276, identifier:risk_phi_x_x; 277, identifier:phi_x_x_i; 278, identifier:E; 279, identifier:slice_; 280, identifier:array_sum_to_scalar; 281, argument_list; 282, augmented_assignment; 283, identifier:X_at_t; 284, identifier:deaths; 285, identifier:weights_at_t; 286, identifier:deaths; 287, identifier:matrix_axis_0_sum_to_array; 288, argument_list; 289, identifier:array_sum_to_scalar; 290, argument_list; 291, identifier:weight_count; 292, identifier:tied_death_counts; 293, assignment; 294, assignment; 295, assignment; 296, assignment; 297, assignment; 298, assignment; 299, assignment; 300, expression_statement; 301, expression_statement; 302, expression_statement; 303, identifier:numer; 304, subscript; 305, attribute; 306, argument_list; 307, binary_operator:gradient + x_death_sum; 308, binary_operator:weighted_average * summand.sum(0); 309, binary_operator:log_lik + np.dot(x_death_sum, beta); 310, binary_operator:weighted_average * np.log(denom).sum(); 311, identifier:hessian; 312, binary_operator:weighted_average * (a2 - a1); 313, identifier:d; 314, identifier:d; 315, identifier:d; 316, identifier:d; 317, identifier:d; 318, identifier:d; 319, attribute; 320, argument_list; 321, binary_operator:pos - count_of_removals; 322, identifier:pos; 323, identifier:np; 324, identifier:dot; 325, attribute; 326, identifier:phi_x_i; 327, identifier:array_sum_to_scalar; 328, argument_list; 329, identifier:matrix_axis_0_sum_to_array; 330, argument_list; 331, call; 332, identifier:pos; 333, identifier:count_of_removals; 334, binary_operator:weights_deaths[:, None] * xi_deaths; 335, identifier:weights_deaths; 336, identifier:tie_phi; 337, call; 338, identifier:tie_phi_x; 339, call; 340, identifier:tie_phi_x_x; 341, call; 342, identifier:increasing_proportion; 343, binary_operator:np.arange(tied_death_counts) / tied_death_counts; 344, identifier:denom; 345, binary_operator:1.0 / (risk_phi - increasing_proportion * tie_phi); 346, identifier:numer; 347, binary_operator:risk_phi_x - np.outer(increasing_proportion, tie_phi_x); 348, identifier:a1; 349, binary_operator:np.einsum("ab,i->ab", risk_phi_x_x, denom) - np.einsum(
"ab,i->ab", tie_phi_x_x, increasing_proportion * denom
); 350, assignment; 351, assignment; 352, assignment; 353, identifier:denom; 354, slice; 355, None; 356, attribute; 357, identifier:dot; 358, identifier:summand; 359, identifier:gradient; 360, identifier:x_death_sum; 361, identifier:weighted_average; 362, call; 363, identifier:log_lik; 364, call; 365, identifier:weighted_average; 366, call; 367, identifier:weighted_average; 368, parenthesized_expression; 369, identifier:np; 370, identifier:dot; 371, identifier:X; 372, identifier:beta; 373, identifier:pos; 374, identifier:count_of_removals; 375, identifier:X_at_t; 376, identifier:T; 377, identifier:phi_i; 378, identifier:phi_x_i; 379, attribute; 380, argument_list; 381, subscript; 382, identifier:xi_deaths; 383, identifier:array_sum_to_scalar; 384, argument_list; 385, identifier:matrix_axis_0_sum_to_array; 386, argument_list; 387, attribute; 388, argument_list; 389, call; 390, identifier:tied_death_counts; 391, float:1.0; 392, parenthesized_expression; 393, identifier:risk_phi_x; 394, call; 395, call; 396, call; 397, identifier:denom; 398, binary_operator:1.0 / np.array([risk_phi]); 399, identifier:numer; 400, identifier:risk_phi_x; 401, identifier:a1; 402, binary_operator:risk_phi_x_x * denom; 403, identifier:summand; 404, identifier:T; 405, attribute; 406, argument_list; 407, attribute; 408, argument_list; 409, attribute; 410, argument_list; 411, binary_operator:a2 - a1; 412, identifier:deaths; 413, identifier:astype; 414, identifier:int; 415, identifier:weights_deaths; 416, slice; 417, None; 418, subscript; 419, subscript; 420, identifier:np; 421, identifier:dot; 422, attribute; 423, binary_operator:phi_i[deaths] * xi_deaths; 424, attribute; 425, argument_list; 426, binary_operator:risk_phi - increasing_proportion * tie_phi; 427, attribute; 428, argument_list; 429, attribute; 430, argument_list; 431, attribute; 432, argument_list; 433, float:1.0; 434, call; 435, identifier:risk_phi_x_x; 436, identifier:denom; 437, identifier:summand; 438, identifier:sum; 439, integer:0; 440, identifier:np; 441, identifier:dot; 442, identifier:x_death_sum; 443, identifier:beta; 444, call; 445, identifier:sum; 446, identifier:a2; 447, identifier:a1; 448, identifier:phi_i; 449, identifier:deaths; 450, identifier:phi_x_i; 451, identifier:deaths; 452, identifier:xi_deaths; 453, identifier:T; 454, subscript; 455, identifier:xi_deaths; 456, identifier:np; 457, identifier:arange; 458, identifier:tied_death_counts; 459, identifier:risk_phi; 460, binary_operator:increasing_proportion * tie_phi; 461, identifier:np; 462, identifier:outer; 463, identifier:increasing_proportion; 464, identifier:tie_phi_x; 465, identifier:np; 466, identifier:einsum; 467, string:"ab,i->ab"; 468, identifier:risk_phi_x_x; 469, identifier:denom; 470, identifier:np; 471, identifier:einsum; 472, string:"ab,i->ab"; 473, identifier:tie_phi_x_x; 474, binary_operator:increasing_proportion * denom; 475, attribute; 476, argument_list; 477, attribute; 478, argument_list; 479, identifier:phi_i; 480, identifier:deaths; 481, identifier:increasing_proportion; 482, identifier:tie_phi; 483, identifier:increasing_proportion; 484, identifier:denom; 485, identifier:np; 486, identifier:array; 487, list; 488, identifier:np; 489, identifier:log; 490, identifier:denom; 491, identifier:risk_phi | 0, 1; 1, 2; 1, 3; 1, 4; 1, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 5, 12; 5, 13; 5, 14; 5, 15; 5, 16; 5, 17; 5, 18; 5, 19; 5, 20; 5, 21; 5, 22; 5, 23; 5, 24; 5, 25; 5, 26; 5, 27; 12, 28; 13, 29; 14, 30; 15, 31; 16, 32; 19, 33; 20, 34; 21, 35; 23, 36; 24, 37; 25, 38; 26, 39; 26, 40; 26, 41; 27, 42; 29, 43; 29, 44; 30, 45; 30, 46; 31, 47; 31, 48; 32, 49; 32, 50; 33, 51; 33, 52; 34, 53; 34, 54; 35, 55; 35, 56; 36, 57; 36, 58; 37, 59; 37, 60; 38, 61; 38, 62; 41, 63; 41, 64; 41, 65; 41, 66; 41, 67; 41, 68; 41, 69; 41, 70; 41, 71; 41, 72; 41, 73; 41, 74; 41, 75; 41, 76; 41, 77; 41, 78; 41, 79; 41, 80; 41, 81; 41, 82; 41, 83; 41, 84; 41, 85; 41, 86; 41, 87; 41, 88; 41, 89; 41, 90; 41, 91; 42, 92; 42, 93; 42, 94; 43, 95; 43, 96; 44, 97; 44, 98; 46, 99; 46, 100; 48, 101; 48, 102; 51, 103; 51, 104; 52, 105; 52, 106; 53, 107; 53, 108; 54, 109; 54, 110; 55, 111; 55, 112; 56, 113; 56, 114; 57, 115; 57, 116; 58, 117; 58, 118; 60, 119; 60, 120; 63, 121; 64, 122; 65, 123; 66, 124; 67, 125; 68, 126; 70, 127; 71, 128; 72, 129; 74, 130; 75, 131; 76, 132; 76, 133; 76, 134; 77, 135; 78, 136; 79, 137; 80, 138; 81, 139; 82, 140; 82, 141; 82, 142; 82, 143; 82, 144; 82, 145; 83, 146; 87, 147; 88, 148; 89, 149; 90, 150; 91, 151; 99, 152; 99, 153; 100, 154; 101, 155; 101, 156; 102, 157; 109, 158; 109, 159; 110, 160; 110, 161; 113, 162; 113, 163; 114, 164; 114, 165; 117, 166; 117, 167; 118, 168; 118, 169; 120, 170; 120, 171; 121, 172; 121, 173; 122, 174; 122, 175; 123, 176; 123, 177; 124, 178; 124, 179; 125, 180; 125, 181; 126, 182; 126, 183; 127, 184; 127, 185; 128, 186; 128, 187; 129, 188; 129, 189; 130, 190; 130, 191; 131, 192; 131, 193; 132, 194; 132, 195; 134, 196; 134, 197; 135, 198; 135, 199; 136, 200; 136, 201; 137, 202; 137, 203; 138, 204; 138, 205; 139, 206; 139, 207; 140, 208; 140, 209; 144, 210; 144, 211; 144, 212; 144, 213; 144, 214; 144, 215; 144, 216; 144, 217; 144, 218; 144, 219; 144, 220; 144, 221; 144, 222; 144, 223; 145, 224; 145, 225; 146, 226; 146, 227; 147, 228; 147, 229; 148, 230; 148, 231; 149, 232; 149, 233; 150, 234; 150, 235; 151, 236; 151, 237; 154, 238; 154, 239; 157, 240; 158, 241; 158, 242; 159, 243; 160, 244; 160, 245; 161, 246; 162, 247; 162, 248; 163, 249; 164, 250; 164, 251; 165, 252; 168, 253; 169, 254; 169, 255; 170, 256; 170, 257; 171, 258; 173, 259; 173, 260; 175, 261; 175, 262; 177, 263; 177, 264; 179, 265; 179, 266; 179, 267; 181, 268; 181, 269; 183, 270; 183, 271; 185, 272; 185, 273; 187, 274; 187, 275; 189, 276; 189, 277; 191, 278; 191, 279; 193, 280; 193, 281; 196, 282; 199, 283; 199, 284; 201, 285; 201, 286; 203, 287; 203, 288; 205, 289; 205, 290; 207, 291; 207, 292; 210, 293; 211, 294; 212, 295; 213, 296; 214, 297; 215, 298; 223, 299; 225, 300; 225, 301; 225, 302; 227, 303; 227, 304; 229, 305; 229, 306; 231, 307; 231, 308; 233, 309; 233, 310; 235, 311; 235, 312; 243, 313; 246, 314; 249, 315; 249, 316; 252, 317; 252, 318; 258, 319; 258, 320; 260, 321; 260, 322; 270, 323; 270, 324; 271, 325; 271, 326; 273, 327; 273, 328; 275, 329; 275, 330; 281, 331; 282, 332; 282, 333; 288, 334; 290, 335; 293, 336; 293, 337; 294, 338; 294, 339; 295, 340; 295, 341; 296, 342; 296, 343; 297, 344; 297, 345; 298, 346; 298, 347; 299, 348; 299, 349; 300, 350; 301, 351; 302, 352; 304, 353; 304, 354; 304, 355; 305, 356; 305, 357; 306, 358; 307, 359; 307, 360; 308, 361; 308, 362; 309, 363; 309, 364; 310, 365; 310, 366; 312, 367; 312, 368; 319, 369; 319, 370; 320, 371; 320, 372; 321, 373; 321, 374; 325, 375; 325, 376; 328, 377; 330, 378; 331, 379; 331, 380; 334, 381; 334, 382; 337, 383; 337, 384; 339, 385; 339, 386; 341, 387; 341, 388; 343, 389; 343, 390; 345, 391; 345, 392; 347, 393; 347, 394; 349, 395; 349, 396; 350, 397; 350, 398; 351, 399; 351, 400; 352, 401; 352, 402; 356, 403; 356, 404; 362, 405; 362, 406; 364, 407; 364, 408; 366, 409; 366, 410; 368, 411; 379, 412; 379, 413; 380, 414; 381, 415; 381, 416; 381, 417; 384, 418; 386, 419; 387, 420; 387, 421; 388, 422; 388, 423; 389, 424; 389, 425; 392, 426; 394, 427; 394, 428; 395, 429; 395, 430; 396, 431; 396, 432; 398, 433; 398, 434; 402, 435; 402, 436; 405, 437; 405, 438; 406, 439; 407, 440; 407, 441; 408, 442; 408, 443; 409, 444; 409, 445; 411, 446; 411, 447; 418, 448; 418, 449; 419, 450; 419, 451; 422, 452; 422, 453; 423, 454; 423, 455; 424, 456; 424, 457; 425, 458; 426, 459; 426, 460; 427, 461; 427, 462; 428, 463; 428, 464; 429, 465; 429, 466; 430, 467; 430, 468; 430, 469; 431, 470; 431, 471; 432, 472; 432, 473; 432, 474; 434, 475; 434, 476; 444, 477; 444, 478; 454, 479; 454, 480; 460, 481; 460, 482; 474, 483; 474, 484; 475, 485; 475, 486; 476, 487; 477, 488; 477, 489; 478, 490; 487, 491 | def _get_efron_values_batch(self, X, T, E, weights, beta): # pylint: disable=too-many-locals
"""
Assumes sorted on ascending on T
Calculates the first and second order vector differentials, with respect to beta.
A good explanation for how Efron handles ties. Consider three of five subjects who fail at the time.
As it is not known a priori that who is the first to fail, so one-third of
(φ1 + φ2 + φ3) is adjusted from sum_j^{5} φj after one fails. Similarly two-third
of (φ1 + φ2 + φ3) is adjusted after first two individuals fail, etc.
Returns
-------
hessian: (d, d) numpy array,
gradient: (1, d) numpy array
log_likelihood: float
"""
n, d = X.shape
hessian = np.zeros((d, d))
gradient = np.zeros((d,))
log_lik = 0
# weights = weights[:, None]
# Init risk and tie sums to zero
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 are sorted by -T
_, 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)
# Calculate sums of Risk set
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
# Calculate the sums of Tie set
deaths = E[slice_]
tied_death_counts = array_sum_to_scalar(deaths.astype(int))
if tied_death_counts == 0:
# no deaths, can continue
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:
# a lot of this is now in Einstein notation for performance, but see original "expanded" code here
# https://github.com/CamDavidsonPilon/lifelines/blob/e7056e7817272eb5dff5983556954f56c33301b1/lifelines/fitters/coxph_fitter.py#L755-L789
# it's faster if we can skip computing these when we don't need to.
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)
# computes outer products and sums them together.
# Naive approach is to
# 1) broadcast tie_phi_x_x and increasing_proportion into a (tied_death_counts, d, d) matrix
# 2) broadcast risk_phi_x_x and denom into a (tied_death_counts, d, d) matrix
# 3) subtract them, and then sum to (d, d)
# Alternatively, we can sum earlier without having to explicitly create (_, d, d) matrices. This is used here.
#
a1 = np.einsum("ab,i->ab", risk_phi_x_x, denom) - np.einsum(
"ab,i->ab", tie_phi_x_x, increasing_proportion * denom
)
else:
# no tensors here, but do some casting to make it easier in the converging step next.
denom = 1.0 / np.array([risk_phi])
numer = risk_phi_x
a1 = risk_phi_x_x * denom
summand = numer * denom[:, None]
# This is a batch outer product.
# given a matrix t, for each row, m, compute it's outer product: m.dot(m.T), and stack these new matrices together.
# which would be: np.einsum("Bi, Bj->Bij", t, t)
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; 1, function_definition; 2, function_name:_treeify; 3, parameters; 4, block; 5, identifier:values; 6, expression_statement; 7, if_statement; 8, expression_statement; 9, comment:# Tree indices work as follows:; 10, comment:# 0 is the root; 11, comment:# 2n+1 is the left child of n; 12, comment:# 2n+2 is the right child of n; 13, comment:# So we now rearrange `values` into that format...; 14, comment:# The first step is to remove the bottom row of leaves, which might not be exactly full; 15, expression_statement; 16, expression_statement; 17, if_statement; 18, comment:# Now `values` is length 2**n - 1, so can be packed efficiently into a tree; 19, comment:# Last row of nodes is indices 0, 2, ..., 2**n - 2; 20, comment:# Second-last row is indices 1, 5, ..., 2**n - 3; 21, comment:# nth-last row is indices (2**n - 1)::(2**(n+1)); 22, expression_statement; 23, expression_statement; 24, expression_statement; 25, while_statement; 26, return_statement; 27, comment:"""Convert the np.ndarray `values` into a complete balanced tree.
Assumes `values` is sorted ascending. Returns a list `t` of the same length in which t[i] >
t[2i+1] and t[i] < t[2i+2] for all i."""; 28, comparison_operator:len(values) == 1; 29, comment:# this case causes problems later; 30, block; 31, assignment; 32, assignment; 33, assignment; 34, comparison_operator:len_ragged_row > 0; 35, block; 36, assignment; 37, assignment; 38, assignment; 39, comparison_operator:values_start < len(values); 40, block; 41, identifier:tree; 42, call; 43, integer:1; 44, return_statement; 45, identifier:tree; 46, call; 47, identifier:last_full_row; 48, call; 49, identifier:len_ragged_row; 50, binary_operator:len(values) - (2 ** (last_full_row + 1) - 1); 51, identifier:len_ragged_row; 52, integer:0; 53, expression_statement; 54, expression_statement; 55, expression_statement; 56, identifier:values_start; 57, integer:0; 58, identifier:values_space; 59, integer:2; 60, identifier:values_len; 61, binary_operator:2 ** last_full_row; 62, identifier:values_start; 63, call; 64, expression_statement; 65, expression_statement; 66, expression_statement; 67, expression_statement; 68, identifier:len; 69, argument_list; 70, identifier:values; 71, attribute; 72, argument_list; 73, identifier:int; 74, argument_list; 75, call; 76, parenthesized_expression; 77, assignment; 78, assignment; 79, assignment; 80, integer:2; 81, identifier:last_full_row; 82, identifier:len; 83, argument_list; 84, assignment; 85, augmented_assignment; 86, augmented_assignment; 87, assignment; 88, identifier:values; 89, identifier:np; 90, identifier:empty_like; 91, identifier:values; 92, binary_operator:np.log2(len(values) + 1) - 1; 93, identifier:len; 94, argument_list; 95, binary_operator:2 ** (last_full_row + 1) - 1; 96, identifier:bottom_row_ix; 97, subscript; 98, subscript; 99, subscript; 100, identifier:values; 101, call; 102, identifier:values; 103, subscript; 104, subscript; 105, identifier:values_start; 106, call; 107, identifier:values_space; 108, integer:2; 109, identifier:values_len; 110, call; 111, call; 112, integer:1; 113, identifier:values; 114, binary_operator:2 ** (last_full_row + 1); 115, integer:1; 116, attribute; 117, slice; 118, identifier:tree; 119, slice; 120, identifier:values; 121, identifier:bottom_row_ix; 122, attribute; 123, argument_list; 124, identifier:tree; 125, slice; 126, identifier:values; 127, slice; 128, identifier:int; 129, argument_list; 130, identifier:int; 131, argument_list; 132, attribute; 133, argument_list; 134, integer:2; 135, parenthesized_expression; 136, identifier:np; 137, identifier:s_; 138, binary_operator:2 * len_ragged_row; 139, integer:2; 140, unary_operator; 141, identifier:np; 142, identifier:delete; 143, identifier:values; 144, identifier:bottom_row_ix; 145, binary_operator:values_len - 1; 146, binary_operator:2 * values_len - 1; 147, identifier:values_start; 148, identifier:values_space; 149, binary_operator:values_space / 2; 150, binary_operator:values_len / 2; 151, identifier:np; 152, identifier:log2; 153, binary_operator:len(values) + 1; 154, binary_operator:last_full_row + 1; 155, integer:2; 156, identifier:len_ragged_row; 157, identifier:len_ragged_row; 158, identifier:values_len; 159, integer:1; 160, binary_operator:2 * values_len; 161, integer:1; 162, identifier:values_space; 163, integer:2; 164, identifier:values_len; 165, integer:2; 166, call; 167, integer:1; 168, identifier:last_full_row; 169, integer:1; 170, integer:2; 171, identifier:values_len; 172, identifier:len; 173, argument_list; 174, identifier:values | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 6, 27; 7, 28; 7, 29; 7, 30; 8, 31; 15, 32; 16, 33; 17, 34; 17, 35; 22, 36; 23, 37; 24, 38; 25, 39; 25, 40; 26, 41; 28, 42; 28, 43; 30, 44; 31, 45; 31, 46; 32, 47; 32, 48; 33, 49; 33, 50; 34, 51; 34, 52; 35, 53; 35, 54; 35, 55; 36, 56; 36, 57; 37, 58; 37, 59; 38, 60; 38, 61; 39, 62; 39, 63; 40, 64; 40, 65; 40, 66; 40, 67; 42, 68; 42, 69; 44, 70; 46, 71; 46, 72; 48, 73; 48, 74; 50, 75; 50, 76; 53, 77; 54, 78; 55, 79; 61, 80; 61, 81; 63, 82; 63, 83; 64, 84; 65, 85; 66, 86; 67, 87; 69, 88; 71, 89; 71, 90; 72, 91; 74, 92; 75, 93; 75, 94; 76, 95; 77, 96; 77, 97; 78, 98; 78, 99; 79, 100; 79, 101; 83, 102; 84, 103; 84, 104; 85, 105; 85, 106; 86, 107; 86, 108; 87, 109; 87, 110; 92, 111; 92, 112; 94, 113; 95, 114; 95, 115; 97, 116; 97, 117; 98, 118; 98, 119; 99, 120; 99, 121; 101, 122; 101, 123; 103, 124; 103, 125; 104, 126; 104, 127; 106, 128; 106, 129; 110, 130; 110, 131; 111, 132; 111, 133; 114, 134; 114, 135; 116, 136; 116, 137; 117, 138; 117, 139; 119, 140; 122, 141; 122, 142; 123, 143; 123, 144; 125, 145; 125, 146; 127, 147; 127, 148; 129, 149; 131, 150; 132, 151; 132, 152; 133, 153; 135, 154; 138, 155; 138, 156; 140, 157; 145, 158; 145, 159; 146, 160; 146, 161; 149, 162; 149, 163; 150, 164; 150, 165; 153, 166; 153, 167; 154, 168; 154, 169; 160, 170; 160, 171; 166, 172; 166, 173; 173, 174 | def _treeify(values):
"""Convert the np.ndarray `values` into a complete balanced tree.
Assumes `values` is sorted ascending. Returns a list `t` of the same length in which t[i] >
t[2i+1] and t[i] < t[2i+2] for all i."""
if len(values) == 1: # this case causes problems later
return values
tree = np.empty_like(values)
# Tree indices work as follows:
# 0 is the root
# 2n+1 is the left child of n
# 2n+2 is the right child of n
# So we now rearrange `values` into that format...
# The first step is to remove the bottom row of leaves, which might not be exactly full
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)
# Now `values` is length 2**n - 1, so can be packed efficiently into a tree
# Last row of nodes is indices 0, 2, ..., 2**n - 2
# Second-last row is indices 1, 5, ..., 2**n - 3
# nth-last row is indices (2**n - 1)::(2**(n+1))
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; 1, function_definition; 2, function_name:nearest_neighbors; 3, parameters; 4, block; 5, identifier:self; 6, identifier:word; 7, default_parameter; 8, expression_statement; 9, comment:#TODO(rmyeid): Use scikit ball tree, if scikit is available; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, return_statement; 15, identifier:top_k; 16, integer:10; 17, comment:"""Return the nearest k words to the given `word`.
Args:
word (string): single word.
top_k (integer): decides how many neighbors to report.
Returns:
A list of words sorted by the distances. The closest is the first.
Note:
L2 metric is used to calculate distances.
"""; 18, assignment; 19, assignment; 20, assignment; 21, assignment; 22, list_comprehension; 23, identifier:point; 24, subscript; 25, identifier:diff; 26, binary_operator:self.vectors - point; 27, identifier:distances; 28, call; 29, identifier:top_ids; 30, subscript; 31, subscript; 32, for_in_clause; 33, identifier:self; 34, identifier:word; 35, attribute; 36, identifier:point; 37, attribute; 38, argument_list; 39, call; 40, slice; 41, attribute; 42, identifier:i; 43, identifier:i; 44, identifier:top_ids; 45, identifier:self; 46, identifier:vectors; 47, attribute; 48, identifier:norm; 49, identifier:diff; 50, keyword_argument; 51, attribute; 52, argument_list; 53, integer:1; 54, binary_operator:top_k+1; 55, attribute; 56, identifier:id_word; 57, identifier:np; 58, identifier:linalg; 59, identifier:axis; 60, integer:1; 61, identifier:distances; 62, identifier:argsort; 63, identifier:top_k; 64, integer:1; 65, identifier:self; 66, identifier:vocabulary | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 7, 15; 7, 16; 8, 17; 10, 18; 11, 19; 12, 20; 13, 21; 14, 22; 18, 23; 18, 24; 19, 25; 19, 26; 20, 27; 20, 28; 21, 29; 21, 30; 22, 31; 22, 32; 24, 33; 24, 34; 26, 35; 26, 36; 28, 37; 28, 38; 30, 39; 30, 40; 31, 41; 31, 42; 32, 43; 32, 44; 35, 45; 35, 46; 37, 47; 37, 48; 38, 49; 38, 50; 39, 51; 39, 52; 40, 53; 40, 54; 41, 55; 41, 56; 47, 57; 47, 58; 50, 59; 50, 60; 51, 61; 51, 62; 54, 63; 54, 64; 55, 65; 55, 66 | def nearest_neighbors(self, word, top_k=10):
"""Return the nearest k words to the given `word`.
Args:
word (string): single word.
top_k (integer): decides how many neighbors to report.
Returns:
A list of words sorted by the distances. The closest is the first.
Note:
L2 metric is used to calculate distances.
"""
#TODO(rmyeid): Use scikit ball tree, if scikit is available
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; 1, function_definition; 2, function_name:find_range; 3, parameters; 4, block; 5, identifier:values; 6, default_parameter; 7, expression_statement; 8, try_statement; 9, identifier:soft_range; 10, list; 11, comment:"""
Safely finds either the numerical min and max of
a set of values, falling back to the first and
the last value in the sorted list of values.
"""; 12, block; 13, except_clause; 14, expression_statement; 15, expression_statement; 16, if_statement; 17, if_statement; 18, return_statement; 19, block; 20, assignment; 21, assignment; 22, call; 23, block; 24, comparison_operator:values.dtype.kind == 'M'; 25, block; 26, expression_list; 27, try_statement; 28, identifier:values; 29, call; 30, identifier:values; 31, conditional_expression:np.squeeze(values) if len(values.shape) > 1 else values; 32, identifier:len; 33, argument_list; 34, expression_statement; 35, attribute; 36, string; 37, return_statement; 38, call; 39, call; 40, block; 41, except_clause; 42, attribute; 43, argument_list; 44, call; 45, comparison_operator:len(values.shape) > 1; 46, identifier:values; 47, identifier:soft_range; 48, assignment; 49, attribute; 50, identifier:kind; 51, string_content:M; 52, expression_list; 53, attribute; 54, argument_list; 55, attribute; 56, argument_list; 57, expression_statement; 58, return_statement; 59, block; 60, identifier:np; 61, identifier:array; 62, identifier:values; 63, attribute; 64, argument_list; 65, call; 66, integer:1; 67, identifier:values; 68, call; 69, identifier:values; 70, identifier:dtype; 71, call; 72, call; 73, identifier:np; 74, identifier:nanmin; 75, identifier:values; 76, identifier:np; 77, identifier:nanmax; 78, identifier:values; 79, assignment; 80, tuple; 81, return_statement; 82, identifier:np; 83, identifier:squeeze; 84, identifier:values; 85, identifier:len; 86, argument_list; 87, attribute; 88, argument_list; 89, attribute; 90, argument_list; 91, attribute; 92, argument_list; 93, identifier:values; 94, call; 95, subscript; 96, subscript; 97, tuple; 98, attribute; 99, identifier:np; 100, identifier:concatenate; 101, list; 102, identifier:values; 103, identifier:min; 104, identifier:values; 105, identifier:max; 106, identifier:sorted; 107, argument_list; 108, identifier:values; 109, integer:0; 110, identifier:values; 111, unary_operator; 112, None; 113, None; 114, identifier:values; 115, identifier:shape; 116, identifier:values; 117, identifier:soft_range; 118, identifier:values; 119, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 6, 9; 6, 10; 7, 11; 8, 12; 8, 13; 12, 14; 12, 15; 12, 16; 12, 17; 12, 18; 13, 19; 14, 20; 15, 21; 16, 22; 16, 23; 17, 24; 17, 25; 18, 26; 19, 27; 20, 28; 20, 29; 21, 30; 21, 31; 22, 32; 22, 33; 23, 34; 24, 35; 24, 36; 25, 37; 26, 38; 26, 39; 27, 40; 27, 41; 29, 42; 29, 43; 31, 44; 31, 45; 31, 46; 33, 47; 34, 48; 35, 49; 35, 50; 36, 51; 37, 52; 38, 53; 38, 54; 39, 55; 39, 56; 40, 57; 40, 58; 41, 59; 42, 60; 42, 61; 43, 62; 44, 63; 44, 64; 45, 65; 45, 66; 48, 67; 48, 68; 49, 69; 49, 70; 52, 71; 52, 72; 53, 73; 53, 74; 54, 75; 55, 76; 55, 77; 56, 78; 57, 79; 58, 80; 59, 81; 63, 82; 63, 83; 64, 84; 65, 85; 65, 86; 68, 87; 68, 88; 71, 89; 71, 90; 72, 91; 72, 92; 79, 93; 79, 94; 80, 95; 80, 96; 81, 97; 86, 98; 87, 99; 87, 100; 88, 101; 89, 102; 89, 103; 91, 104; 91, 105; 94, 106; 94, 107; 95, 108; 95, 109; 96, 110; 96, 111; 97, 112; 97, 113; 98, 114; 98, 115; 101, 116; 101, 117; 107, 118; 111, 119 | def find_range(values, soft_range=[]):
"""
Safely finds either the numerical min and max of
a set of values, falling back to the first and
the last value in the sorted list of values.
"""
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; 1, function_definition; 2, function_name:dimension_sort; 3, parameters; 4, block; 5, identifier:odict; 6, identifier:kdims; 7, identifier:vdims; 8, identifier:key_index; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, if_statement; 16, if_statement; 17, comment:"""
Sorts data by key using usual Python tuple sorting semantics
or sorts in categorical order for any categorical Dimensions.
"""; 18, assignment; 19, assignment; 20, assignment; 21, assignment; 22, assignment; 23, comparison_operator:len(set(key_index)) != len(key_index); 24, block; 25, else_clause; 26, comparison_operator:sys.version_info.major == 3; 27, block; 28, else_clause; 29, identifier:sortkws; 30, dictionary; 31, identifier:ndims; 32, call; 33, identifier:dimensions; 34, binary_operator:kdims+vdims; 35, identifier:indexes; 36, list_comprehension; 37, identifier:cached_values; 38, dictionary_comprehension; 39, call; 40, call; 41, raise_statement; 42, block; 43, attribute; 44, integer:3; 45, return_statement; 46, block; 47, identifier:len; 48, argument_list; 49, identifier:kdims; 50, identifier:vdims; 51, tuple; 52, for_in_clause; 53, pair; 54, for_in_clause; 55, identifier:len; 56, argument_list; 57, identifier:len; 58, argument_list; 59, call; 60, expression_statement; 61, attribute; 62, identifier:major; 63, call; 64, return_statement; 65, identifier:kdims; 66, subscript; 67, call; 68, conditional_expression:i if i in range(ndims) else i-ndims; 69, identifier:i; 70, identifier:key_index; 71, attribute; 72, binary_operator:[None]+list(d.values); 73, identifier:d; 74, identifier:dimensions; 75, call; 76, identifier:key_index; 77, identifier:ValueError; 78, argument_list; 79, assignment; 80, identifier:sys; 81, identifier:version_info; 82, identifier:python2sort; 83, argument_list; 84, call; 85, identifier:dimensions; 86, identifier:i; 87, identifier:int; 88, argument_list; 89, identifier:i; 90, comparison_operator:i in range(ndims); 91, binary_operator:i-ndims; 92, identifier:d; 93, identifier:name; 94, list; 95, call; 96, identifier:set; 97, argument_list; 98, string:"Cannot sort on duplicated dimensions"; 99, subscript; 100, lambda; 101, call; 102, dictionary_splat; 103, identifier:sorted; 104, argument_list; 105, comparison_operator:i not in range(ndims); 106, identifier:i; 107, call; 108, identifier:i; 109, identifier:ndims; 110, None; 111, identifier:list; 112, argument_list; 113, identifier:key_index; 114, identifier:sortkws; 115, string; 116, lambda_parameters; 117, call; 118, attribute; 119, argument_list; 120, identifier:sortkws; 121, call; 122, dictionary_splat; 123, identifier:i; 124, call; 125, identifier:range; 126, argument_list; 127, attribute; 128, string_content:key; 129, identifier:x; 130, identifier:tuple; 131, generator_expression; 132, identifier:odict; 133, identifier:items; 134, attribute; 135, argument_list; 136, identifier:sortkws; 137, identifier:range; 138, argument_list; 139, identifier:ndims; 140, identifier:d; 141, identifier:values; 142, conditional_expression:cached_values[dim.name].index(x[t][d])
if dim.values else x[t][d]; 143, for_in_clause; 144, identifier:odict; 145, identifier:items; 146, identifier:ndims; 147, call; 148, attribute; 149, subscript; 150, pattern_list; 151, call; 152, attribute; 153, argument_list; 154, identifier:dim; 155, identifier:values; 156, subscript; 157, identifier:d; 158, identifier:i; 159, tuple_pattern; 160, identifier:enumerate; 161, argument_list; 162, subscript; 163, identifier:index; 164, subscript; 165, identifier:x; 166, identifier:t; 167, identifier:dim; 168, identifier:t; 169, identifier:d; 170, identifier:indexes; 171, identifier:cached_values; 172, attribute; 173, subscript; 174, identifier:d; 175, identifier:dim; 176, identifier:name; 177, identifier:x; 178, identifier:t | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 9, 17; 10, 18; 11, 19; 12, 20; 13, 21; 14, 22; 15, 23; 15, 24; 15, 25; 16, 26; 16, 27; 16, 28; 18, 29; 18, 30; 19, 31; 19, 32; 20, 33; 20, 34; 21, 35; 21, 36; 22, 37; 22, 38; 23, 39; 23, 40; 24, 41; 25, 42; 26, 43; 26, 44; 27, 45; 28, 46; 32, 47; 32, 48; 34, 49; 34, 50; 36, 51; 36, 52; 38, 53; 38, 54; 39, 55; 39, 56; 40, 57; 40, 58; 41, 59; 42, 60; 43, 61; 43, 62; 45, 63; 46, 64; 48, 65; 51, 66; 51, 67; 51, 68; 52, 69; 52, 70; 53, 71; 53, 72; 54, 73; 54, 74; 56, 75; 58, 76; 59, 77; 59, 78; 60, 79; 61, 80; 61, 81; 63, 82; 63, 83; 64, 84; 66, 85; 66, 86; 67, 87; 67, 88; 68, 89; 68, 90; 68, 91; 71, 92; 71, 93; 72, 94; 72, 95; 75, 96; 75, 97; 78, 98; 79, 99; 79, 100; 83, 101; 83, 102; 84, 103; 84, 104; 88, 105; 90, 106; 90, 107; 91, 108; 91, 109; 94, 110; 95, 111; 95, 112; 97, 113; 99, 114; 99, 115; 100, 116; 100, 117; 101, 118; 101, 119; 102, 120; 104, 121; 104, 122; 105, 123; 105, 124; 107, 125; 107, 126; 112, 127; 115, 128; 116, 129; 117, 130; 117, 131; 118, 132; 118, 133; 121, 134; 121, 135; 122, 136; 124, 137; 124, 138; 126, 139; 127, 140; 127, 141; 131, 142; 131, 143; 134, 144; 134, 145; 138, 146; 142, 147; 142, 148; 142, 149; 143, 150; 143, 151; 147, 152; 147, 153; 148, 154; 148, 155; 149, 156; 149, 157; 150, 158; 150, 159; 151, 160; 151, 161; 152, 162; 152, 163; 153, 164; 156, 165; 156, 166; 159, 167; 159, 168; 159, 169; 161, 170; 162, 171; 162, 172; 164, 173; 164, 174; 172, 175; 172, 176; 173, 177; 173, 178 | def dimension_sort(odict, kdims, vdims, key_index):
"""
Sorts data by key using usual Python tuple sorting semantics
or sorts in categorical order for any categorical Dimensions.
"""
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; 1, function_definition; 2, function_name:sort_topologically; 3, parameters; 4, block; 5, identifier:graph; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, function_definition; 10, function_definition; 11, for_statement; 12, return_statement; 13, comment:"""
Stackless topological sorting.
graph = {
3: [1],
5: [3],
4: [2],
6: [4],
}
sort_topologically(graph)
[[1, 2], [3, 4], [5, 6]]
"""; 14, assignment; 15, assignment; 16, function_name:add_level_to_name; 17, parameters; 18, block; 19, function_name:walk_depth_first; 20, parameters; 21, block; 22, identifier:name; 23, identifier:graph; 24, block; 25, call; 26, identifier:levels_by_name; 27, dictionary; 28, identifier:names_by_level; 29, call; 30, identifier:name; 31, identifier:level; 32, expression_statement; 33, expression_statement; 34, identifier:name; 35, expression_statement; 36, while_statement; 37, expression_statement; 38, identifier:list; 39, argument_list; 40, identifier:defaultdict; 41, argument_list; 42, assignment; 43, call; 44, assignment; 45, parenthesized_expression; 46, block; 47, call; 48, call; 49, identifier:list; 50, subscript; 51, identifier:level; 52, attribute; 53, argument_list; 54, identifier:stack; 55, list; 56, identifier:stack; 57, expression_statement; 58, if_statement; 59, if_statement; 60, expression_statement; 61, expression_statement; 62, if_statement; 63, expression_statement; 64, expression_statement; 65, identifier:walk_depth_first; 66, argument_list; 67, attribute; 68, argument_list; 69, identifier:levels_by_name; 70, identifier:name; 71, subscript; 72, identifier:append; 73, identifier:name; 74, identifier:name; 75, assignment; 76, comparison_operator:name in levels_by_name; 77, block; 78, boolean_operator; 79, block; 80, assignment; 81, assignment; 82, identifier:children_not_calculated; 83, block; 84, assignment; 85, call; 86, identifier:name; 87, identifier:itertools; 88, identifier:takewhile; 89, lambda; 90, generator_expression; 91, identifier:names_by_level; 92, identifier:level; 93, identifier:name; 94, call; 95, identifier:name; 96, identifier:levels_by_name; 97, continue_statement; 98, comparison_operator:name not in graph; 99, not_operator; 100, expression_statement; 101, expression_statement; 102, continue_statement; 103, identifier:children; 104, subscript; 105, identifier:children_not_calculated; 106, list_comprehension; 107, expression_statement; 108, expression_statement; 109, continue_statement; 110, identifier:level; 111, binary_operator:1 + max(levels_by_name[lname] for lname in children); 112, identifier:add_level_to_name; 113, argument_list; 114, lambda_parameters; 115, comparison_operator:x is not None; 116, call; 117, for_in_clause; 118, attribute; 119, argument_list; 120, identifier:name; 121, identifier:graph; 122, subscript; 123, assignment; 124, call; 125, identifier:graph; 126, identifier:name; 127, identifier:child; 128, for_in_clause; 129, if_clause; 130, call; 131, call; 132, integer:1; 133, call; 134, identifier:name; 135, identifier:level; 136, identifier:x; 137, identifier:x; 138, None; 139, attribute; 140, argument_list; 141, identifier:i; 142, call; 143, identifier:stack; 144, identifier:pop; 145, identifier:graph; 146, identifier:name; 147, identifier:level; 148, integer:0; 149, identifier:add_level_to_name; 150, argument_list; 151, identifier:child; 152, identifier:children; 153, comparison_operator:child not in levels_by_name; 154, attribute; 155, argument_list; 156, attribute; 157, argument_list; 158, identifier:max; 159, generator_expression; 160, identifier:names_by_level; 161, identifier:get; 162, identifier:i; 163, None; 164, attribute; 165, argument_list; 166, identifier:name; 167, identifier:level; 168, identifier:child; 169, identifier:levels_by_name; 170, identifier:stack; 171, identifier:append; 172, identifier:name; 173, identifier:stack; 174, identifier:extend; 175, identifier:children_not_calculated; 176, subscript; 177, for_in_clause; 178, identifier:itertools; 179, identifier:count; 180, identifier:levels_by_name; 181, identifier:lname; 182, identifier:lname; 183, identifier:children | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 6, 13; 7, 14; 8, 15; 9, 16; 9, 17; 9, 18; 10, 19; 10, 20; 10, 21; 11, 22; 11, 23; 11, 24; 12, 25; 14, 26; 14, 27; 15, 28; 15, 29; 17, 30; 17, 31; 18, 32; 18, 33; 20, 34; 21, 35; 21, 36; 24, 37; 25, 38; 25, 39; 29, 40; 29, 41; 32, 42; 33, 43; 35, 44; 36, 45; 36, 46; 37, 47; 39, 48; 41, 49; 42, 50; 42, 51; 43, 52; 43, 53; 44, 54; 44, 55; 45, 56; 46, 57; 46, 58; 46, 59; 46, 60; 46, 61; 46, 62; 46, 63; 46, 64; 47, 65; 47, 66; 48, 67; 48, 68; 50, 69; 50, 70; 52, 71; 52, 72; 53, 73; 55, 74; 57, 75; 58, 76; 58, 77; 59, 78; 59, 79; 60, 80; 61, 81; 62, 82; 62, 83; 63, 84; 64, 85; 66, 86; 67, 87; 67, 88; 68, 89; 68, 90; 71, 91; 71, 92; 75, 93; 75, 94; 76, 95; 76, 96; 77, 97; 78, 98; 78, 99; 79, 100; 79, 101; 79, 102; 80, 103; 80, 104; 81, 105; 81, 106; 83, 107; 83, 108; 83, 109; 84, 110; 84, 111; 85, 112; 85, 113; 89, 114; 89, 115; 90, 116; 90, 117; 94, 118; 94, 119; 98, 120; 98, 121; 99, 122; 100, 123; 101, 124; 104, 125; 104, 126; 106, 127; 106, 128; 106, 129; 107, 130; 108, 131; 111, 132; 111, 133; 113, 134; 113, 135; 114, 136; 115, 137; 115, 138; 116, 139; 116, 140; 117, 141; 117, 142; 118, 143; 118, 144; 122, 145; 122, 146; 123, 147; 123, 148; 124, 149; 124, 150; 128, 151; 128, 152; 129, 153; 130, 154; 130, 155; 131, 156; 131, 157; 133, 158; 133, 159; 139, 160; 139, 161; 140, 162; 140, 163; 142, 164; 142, 165; 150, 166; 150, 167; 153, 168; 153, 169; 154, 170; 154, 171; 155, 172; 156, 173; 156, 174; 157, 175; 159, 176; 159, 177; 164, 178; 164, 179; 176, 180; 176, 181; 177, 182; 177, 183 | def sort_topologically(graph):
"""
Stackless topological sorting.
graph = {
3: [1],
5: [3],
4: [2],
6: [4],
}
sort_topologically(graph)
[[1, 2], [3, 4], [5, 6]]
"""
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; 1, function_definition; 2, function_name:layer_sort; 3, parameters; 4, block; 5, identifier:hmap; 6, expression_statement; 7, expression_statement; 8, for_statement; 9, return_statement; 10, comment:"""
Find a global ordering for layers in a HoloMap of CompositeOverlay
types.
"""; 11, assignment; 12, identifier:o; 13, identifier:hmap; 14, block; 15, list_comprehension; 16, identifier:orderings; 17, dictionary; 18, expression_statement; 19, if_statement; 20, identifier:i; 21, for_in_clause; 22, for_in_clause; 23, assignment; 24, boolean_operator; 25, block; 26, else_clause; 27, identifier:g; 28, call; 29, identifier:i; 30, call; 31, identifier:okeys; 32, list_comprehension; 33, comparison_operator:len(okeys) == 1; 34, not_operator; 35, expression_statement; 36, block; 37, identifier:sort_topologically; 38, argument_list; 39, identifier:sorted; 40, argument_list; 41, call; 42, for_in_clause; 43, call; 44, integer:1; 45, comparison_operator:okeys[0] in orderings; 46, assignment; 47, expression_statement; 48, identifier:orderings; 49, identifier:g; 50, identifier:get_overlay_spec; 51, argument_list; 52, pattern_list; 53, call; 54, identifier:len; 55, argument_list; 56, subscript; 57, identifier:orderings; 58, subscript; 59, list; 60, call; 61, identifier:o; 62, identifier:k; 63, identifier:v; 64, identifier:k; 65, identifier:v; 66, attribute; 67, argument_list; 68, identifier:okeys; 69, identifier:okeys; 70, integer:0; 71, identifier:orderings; 72, subscript; 73, attribute; 74, argument_list; 75, attribute; 76, identifier:items; 77, identifier:okeys; 78, integer:0; 79, identifier:orderings; 80, identifier:update; 81, dictionary_comprehension; 82, identifier:o; 83, identifier:data; 84, pair; 85, for_in_clause; 86, identifier:k; 87, conditional_expression:[] if k == v else [v]; 88, pattern_list; 89, call; 90, list; 91, comparison_operator:k == v; 92, list; 93, identifier:k; 94, identifier:v; 95, identifier:zip; 96, argument_list; 97, identifier:k; 98, identifier:v; 99, identifier:v; 100, subscript; 101, identifier:okeys; 102, identifier:okeys; 103, slice; 104, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 8, 13; 8, 14; 9, 15; 11, 16; 11, 17; 14, 18; 14, 19; 15, 20; 15, 21; 15, 22; 18, 23; 19, 24; 19, 25; 19, 26; 21, 27; 21, 28; 22, 29; 22, 30; 23, 31; 23, 32; 24, 33; 24, 34; 25, 35; 26, 36; 28, 37; 28, 38; 30, 39; 30, 40; 32, 41; 32, 42; 33, 43; 33, 44; 34, 45; 35, 46; 36, 47; 38, 48; 40, 49; 41, 50; 41, 51; 42, 52; 42, 53; 43, 54; 43, 55; 45, 56; 45, 57; 46, 58; 46, 59; 47, 60; 51, 61; 51, 62; 51, 63; 52, 64; 52, 65; 53, 66; 53, 67; 55, 68; 56, 69; 56, 70; 58, 71; 58, 72; 60, 73; 60, 74; 66, 75; 66, 76; 72, 77; 72, 78; 73, 79; 73, 80; 74, 81; 75, 82; 75, 83; 81, 84; 81, 85; 84, 86; 84, 87; 85, 88; 85, 89; 87, 90; 87, 91; 87, 92; 88, 93; 88, 94; 89, 95; 89, 96; 91, 97; 91, 98; 92, 99; 96, 100; 96, 101; 100, 102; 100, 103; 103, 104 | def layer_sort(hmap):
"""
Find a global ordering for layers in a HoloMap of CompositeOverlay
types.
"""
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; 1, function_definition; 2, function_name:arglexsort; 3, parameters; 4, block; 5, identifier:arrays; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, comment:"""
Returns the indices of the lexicographical sorting
order of the supplied arrays.
"""; 12, assignment; 13, assignment; 14, pattern_list; 15, call; 16, block; 17, call; 18, identifier:dtypes; 19, call; 20, identifier:recarray; 21, call; 22, identifier:i; 23, identifier:array; 24, identifier:enumerate; 25, argument_list; 26, expression_statement; 27, attribute; 28, argument_list; 29, attribute; 30, generator_expression; 31, attribute; 32, argument_list; 33, identifier:arrays; 34, assignment; 35, identifier:recarray; 36, identifier:argsort; 37, string; 38, identifier:join; 39, attribute; 40, for_in_clause; 41, identifier:np; 42, identifier:empty; 43, call; 44, keyword_argument; 45, subscript; 46, identifier:array; 47, string_content:,; 48, attribute; 49, identifier:str; 50, identifier:array; 51, identifier:arrays; 52, identifier:len; 53, argument_list; 54, identifier:dtype; 55, identifier:dtypes; 56, identifier:recarray; 57, binary_operator:'f%s' % i; 58, identifier:array; 59, identifier:dtype; 60, subscript; 61, string; 62, identifier:i; 63, identifier:arrays; 64, integer:0; 65, string_content:f%s | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 7, 12; 8, 13; 9, 14; 9, 15; 9, 16; 10, 17; 12, 18; 12, 19; 13, 20; 13, 21; 14, 22; 14, 23; 15, 24; 15, 25; 16, 26; 17, 27; 17, 28; 19, 29; 19, 30; 21, 31; 21, 32; 25, 33; 26, 34; 27, 35; 27, 36; 29, 37; 29, 38; 30, 39; 30, 40; 31, 41; 31, 42; 32, 43; 32, 44; 34, 45; 34, 46; 37, 47; 39, 48; 39, 49; 40, 50; 40, 51; 43, 52; 43, 53; 44, 54; 44, 55; 45, 56; 45, 57; 48, 58; 48, 59; 53, 60; 57, 61; 57, 62; 60, 63; 60, 64; 61, 65 | def arglexsort(arrays):
"""
Returns the indices of the lexicographical sorting
order of the supplied 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; 1, function_definition; 2, function_name:sort; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, expression_statement; 9, if_statement; 10, expression_statement; 11, return_statement; 12, identifier:by; 13, None; 14, identifier:reverse; 15, False; 16, comment:"""
Sorts the data by the values along the supplied dimensions.
Args:
by: Dimension(s) to sort by
reverse (bool, optional): Reverse sort order
Returns:
Sorted Dataset
"""; 17, comparison_operator:by is None; 18, block; 19, elif_clause; 20, assignment; 21, call; 22, identifier:by; 23, None; 24, expression_statement; 25, not_operator; 26, block; 27, identifier:sorted_columns; 28, call; 29, attribute; 30, argument_list; 31, assignment; 32, call; 33, expression_statement; 34, attribute; 35, argument_list; 36, identifier:self; 37, identifier:clone; 38, identifier:sorted_columns; 39, identifier:by; 40, attribute; 41, identifier:isinstance; 42, argument_list; 43, assignment; 44, attribute; 45, identifier:sort; 46, identifier:self; 47, identifier:by; 48, identifier:reverse; 49, identifier:self; 50, identifier:kdims; 51, identifier:by; 52, identifier:list; 53, identifier:by; 54, list; 55, identifier:self; 56, identifier:interface; 57, identifier:by | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 6, 13; 7, 14; 7, 15; 8, 16; 9, 17; 9, 18; 9, 19; 10, 20; 11, 21; 17, 22; 17, 23; 18, 24; 19, 25; 19, 26; 20, 27; 20, 28; 21, 29; 21, 30; 24, 31; 25, 32; 26, 33; 28, 34; 28, 35; 29, 36; 29, 37; 30, 38; 31, 39; 31, 40; 32, 41; 32, 42; 33, 43; 34, 44; 34, 45; 35, 46; 35, 47; 35, 48; 40, 49; 40, 50; 42, 51; 42, 52; 43, 53; 43, 54; 44, 55; 44, 56; 54, 57 | def sort(self, by=None, reverse=False):
"""
Sorts the data by the values along the supplied dimensions.
Args:
by: Dimension(s) to sort by
reverse (bool, optional): Reverse sort order
Returns:
Sorted Dataset
"""
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; 1, function_definition; 2, function_name:glyph_order; 3, parameters; 4, block; 5, identifier:keys; 6, default_parameter; 7, expression_statement; 8, expression_statement; 9, function_definition; 10, return_statement; 11, identifier:draw_order; 12, list; 13, comment:"""
Orders a set of glyph handles using regular sort and an explicit
sort order. The explicit draw order must take the form of a list
of glyph names while the keys should be glyph names with a custom
suffix. The draw order may only match subset of the keys and any
matched items will take precedence over other entries.
"""; 14, assignment; 15, function_name:order_fn; 16, parameters; 17, block; 18, call; 19, identifier:keys; 20, call; 21, identifier:glyph; 22, expression_statement; 23, return_statement; 24, identifier:sorted; 25, argument_list; 26, identifier:sorted; 27, argument_list; 28, assignment; 29, parenthesized_expression; 30, identifier:keys; 31, keyword_argument; 32, identifier:keys; 33, identifier:matches; 34, list_comprehension; 35, conditional_expression:(draw_order.index(matches[0]), glyph) if matches else
(1e9+keys.index(glyph), glyph); 36, identifier:key; 37, identifier:order_fn; 38, identifier:item; 39, for_in_clause; 40, if_clause; 41, tuple; 42, identifier:matches; 43, tuple; 44, identifier:item; 45, identifier:draw_order; 46, call; 47, call; 48, identifier:glyph; 49, binary_operator:1e9+keys.index(glyph); 50, identifier:glyph; 51, attribute; 52, argument_list; 53, attribute; 54, argument_list; 55, float:1e9; 56, call; 57, identifier:glyph; 58, identifier:startswith; 59, identifier:item; 60, identifier:draw_order; 61, identifier:index; 62, subscript; 63, attribute; 64, argument_list; 65, identifier:matches; 66, integer:0; 67, identifier:keys; 68, identifier:index; 69, identifier:glyph | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 6, 12; 7, 13; 8, 14; 9, 15; 9, 16; 9, 17; 10, 18; 14, 19; 14, 20; 16, 21; 17, 22; 17, 23; 18, 24; 18, 25; 20, 26; 20, 27; 22, 28; 23, 29; 25, 30; 25, 31; 27, 32; 28, 33; 28, 34; 29, 35; 31, 36; 31, 37; 34, 38; 34, 39; 34, 40; 35, 41; 35, 42; 35, 43; 39, 44; 39, 45; 40, 46; 41, 47; 41, 48; 43, 49; 43, 50; 46, 51; 46, 52; 47, 53; 47, 54; 49, 55; 49, 56; 51, 57; 51, 58; 52, 59; 53, 60; 53, 61; 54, 62; 56, 63; 56, 64; 62, 65; 62, 66; 63, 67; 63, 68; 64, 69 | def glyph_order(keys, draw_order=[]):
"""
Orders a set of glyph handles using regular sort and an explicit
sort order. The explicit draw order must take the form of a list
of glyph names while the keys should be glyph names with a custom
suffix. The draw order may only match subset of the keys and any
matched items will take precedence over other entries.
"""
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; 1, function_definition; 2, function_name:_get_coords; 3, parameters; 4, block; 5, identifier:self; 6, identifier:obj; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, comment:# Determine global orderings of y-values using topological sort; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, for_statement; 16, if_statement; 17, return_statement; 18, comment:"""
Get the coordinates of the 2D aggregate, maintaining the correct
sorting order.
"""; 19, assignment; 20, assignment; 21, assignment; 22, assignment; 23, assignment; 24, assignment; 25, identifier:group; 26, identifier:grouped; 27, block; 28, boolean_operator; 29, block; 30, elif_clause; 31, expression_list; 32, pattern_list; 33, subscript; 34, identifier:xcoords; 35, call; 36, identifier:ycoords; 37, call; 38, identifier:grouped; 39, call; 40, identifier:orderings; 41, call; 42, identifier:sort; 43, True; 44, expression_statement; 45, if_statement; 46, if_statement; 47, identifier:sort; 48, call; 49, expression_statement; 50, not_operator; 51, block; 52, identifier:xcoords; 53, identifier:ycoords; 54, identifier:xdim; 55, identifier:ydim; 56, call; 57, slice; 58, attribute; 59, argument_list; 60, attribute; 61, argument_list; 62, attribute; 63, argument_list; 64, identifier:OrderedDict; 65, argument_list; 66, assignment; 67, comparison_operator:len(vals) == 1; 68, block; 69, else_clause; 70, identifier:sort; 71, block; 72, identifier:one_to_one; 73, argument_list; 74, assignment; 75, call; 76, expression_statement; 77, expression_statement; 78, attribute; 79, argument_list; 80, integer:2; 81, identifier:obj; 82, identifier:dimension_values; 83, identifier:xdim; 84, False; 85, identifier:obj; 86, identifier:dimension_values; 87, identifier:ydim; 88, False; 89, call; 90, identifier:values; 91, identifier:vals; 92, call; 93, call; 94, integer:1; 95, expression_statement; 96, block; 97, if_statement; 98, identifier:orderings; 99, identifier:ycoords; 100, identifier:ycoords; 101, call; 102, identifier:is_cyclic; 103, argument_list; 104, assignment; 105, assignment; 106, identifier:obj; 107, identifier:dimensions; 108, keyword_argument; 109, attribute; 110, argument_list; 111, attribute; 112, argument_list; 113, identifier:len; 114, argument_list; 115, assignment; 116, for_statement; 117, comparison_operator:vals.dtype.kind in ('i', 'f'); 118, block; 119, else_clause; 120, attribute; 121, argument_list; 122, identifier:orderings; 123, identifier:coords; 124, call; 125, identifier:ycoords; 126, conditional_expression:coords if len(coords) == len(ycoords) else np.sort(ycoords); 127, identifier:label; 128, True; 129, identifier:obj; 130, identifier:groupby; 131, identifier:xdim; 132, keyword_argument; 133, keyword_argument; 134, identifier:group; 135, identifier:dimension_values; 136, identifier:ydim; 137, False; 138, identifier:vals; 139, subscript; 140, list; 141, identifier:i; 142, call; 143, block; 144, attribute; 145, tuple; 146, expression_statement; 147, block; 148, identifier:np; 149, identifier:sort; 150, identifier:ycoords; 151, identifier:list; 152, argument_list; 153, identifier:coords; 154, comparison_operator:len(coords) == len(ycoords); 155, call; 156, identifier:container_type; 157, identifier:OrderedDict; 158, identifier:group_type; 159, identifier:Dataset; 160, identifier:orderings; 161, subscript; 162, subscript; 163, identifier:range; 164, argument_list; 165, expression_statement; 166, expression_statement; 167, attribute; 168, identifier:kind; 169, string; 170, string; 171, assignment; 172, expression_statement; 173, call; 174, call; 175, call; 176, attribute; 177, argument_list; 178, identifier:vals; 179, integer:0; 180, identifier:vals; 181, integer:0; 182, binary_operator:len(vals)-1; 183, assignment; 184, assignment; 185, identifier:vals; 186, identifier:dtype; 187, string_content:i; 188, string_content:f; 189, identifier:sort; 190, call; 191, assignment; 192, attribute; 193, argument_list; 194, identifier:len; 195, argument_list; 196, identifier:len; 197, argument_list; 198, identifier:np; 199, identifier:sort; 200, identifier:ycoords; 201, call; 202, integer:1; 203, pattern_list; 204, subscript; 205, subscript; 206, list; 207, attribute; 208, argument_list; 209, identifier:sort; 210, call; 211, identifier:itertools; 212, identifier:chain; 213, list_splat; 214, identifier:coords; 215, identifier:ycoords; 216, identifier:len; 217, argument_list; 218, identifier:p1; 219, identifier:p2; 220, identifier:vals; 221, slice; 222, identifier:orderings; 223, identifier:p1; 224, identifier:p2; 225, parenthesized_expression; 226, identifier:all; 227, attribute; 228, argument_list; 229, call; 230, identifier:vals; 231, identifier:i; 232, binary_operator:i+2; 233, comparison_operator:np.diff(vals)>=0; 234, identifier:np; 235, identifier:array_equal; 236, call; 237, identifier:vals; 238, identifier:sort_topologically; 239, argument_list; 240, identifier:i; 241, integer:2; 242, call; 243, integer:0; 244, attribute; 245, argument_list; 246, identifier:orderings; 247, attribute; 248, argument_list; 249, identifier:np; 250, identifier:sort; 251, identifier:vals; 252, identifier:np; 253, identifier:diff; 254, identifier:vals | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 7, 18; 8, 19; 9, 20; 10, 21; 12, 22; 13, 23; 14, 24; 15, 25; 15, 26; 15, 27; 16, 28; 16, 29; 16, 30; 17, 31; 19, 32; 19, 33; 20, 34; 20, 35; 21, 36; 21, 37; 22, 38; 22, 39; 23, 40; 23, 41; 24, 42; 24, 43; 27, 44; 27, 45; 27, 46; 28, 47; 28, 48; 29, 49; 30, 50; 30, 51; 31, 52; 31, 53; 32, 54; 32, 55; 33, 56; 33, 57; 35, 58; 35, 59; 37, 60; 37, 61; 39, 62; 39, 63; 41, 64; 41, 65; 44, 66; 45, 67; 45, 68; 45, 69; 46, 70; 46, 71; 48, 72; 48, 73; 49, 74; 50, 75; 51, 76; 51, 77; 56, 78; 56, 79; 57, 80; 58, 81; 58, 82; 59, 83; 59, 84; 60, 85; 60, 86; 61, 87; 61, 88; 62, 89; 62, 90; 66, 91; 66, 92; 67, 93; 67, 94; 68, 95; 69, 96; 71, 97; 73, 98; 73, 99; 74, 100; 74, 101; 75, 102; 75, 103; 76, 104; 77, 105; 78, 106; 78, 107; 79, 108; 89, 109; 89, 110; 92, 111; 92, 112; 93, 113; 93, 114; 95, 115; 96, 116; 97, 117; 97, 118; 97, 119; 101, 120; 101, 121; 103, 122; 104, 123; 104, 124; 105, 125; 105, 126; 108, 127; 108, 128; 109, 129; 109, 130; 110, 131; 110, 132; 110, 133; 111, 134; 111, 135; 112, 136; 112, 137; 114, 138; 115, 139; 115, 140; 116, 141; 116, 142; 116, 143; 117, 144; 117, 145; 118, 146; 119, 147; 120, 148; 120, 149; 121, 150; 124, 151; 124, 152; 126, 153; 126, 154; 126, 155; 132, 156; 132, 157; 133, 158; 133, 159; 139, 160; 139, 161; 140, 162; 142, 163; 142, 164; 143, 165; 143, 166; 144, 167; 144, 168; 145, 169; 145, 170; 146, 171; 147, 172; 152, 173; 154, 174; 154, 175; 155, 176; 155, 177; 161, 178; 161, 179; 162, 180; 162, 181; 164, 182; 165, 183; 166, 184; 167, 185; 167, 186; 169, 187; 170, 188; 171, 189; 171, 190; 172, 191; 173, 192; 173, 193; 174, 194; 174, 195; 175, 196; 175, 197; 176, 198; 176, 199; 177, 200; 182, 201; 182, 202; 183, 203; 183, 204; 184, 205; 184, 206; 190, 207; 190, 208; 191, 209; 191, 210; 192, 211; 192, 212; 193, 213; 195, 214; 197, 215; 201, 216; 201, 217; 203, 218; 203, 219; 204, 220; 204, 221; 205, 222; 205, 223; 206, 224; 207, 225; 207, 226; 210, 227; 210, 228; 213, 229; 217, 230; 221, 231; 221, 232; 225, 233; 227, 234; 227, 235; 228, 236; 228, 237; 229, 238; 229, 239; 232, 240; 232, 241; 233, 242; 233, 243; 236, 244; 236, 245; 239, 246; 242, 247; 242, 248; 244, 249; 244, 250; 245, 251; 247, 252; 247, 253; 248, 254 | def _get_coords(self, obj):
"""
Get the coordinates of the 2D aggregate, maintaining the correct
sorting order.
"""
xdim, ydim = obj.dimensions(label=True)[:2]
xcoords = obj.dimension_values(xdim, False)
ycoords = obj.dimension_values(ydim, False)
# Determine global orderings of y-values using topological sort
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; 1, function_definition; 2, function_name:most_frequent_terms; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, comment:# sort terms by number of occurrences in descending order; 9, expression_statement; 10, expression_statement; 11, if_statement; 12, identifier:count; 13, integer:0; 14, comment:"""
Returns ``count`` of terms sorted by their frequency
in descending order.
:parameter int count:
Max. number of returned terms. Value 0 means no limit (default).
"""; 15, assignment; 16, assignment; 17, comparison_operator:count == 0; 18, block; 19, elif_clause; 20, else_clause; 21, identifier:terms; 22, call; 23, identifier:terms; 24, call; 25, identifier:count; 26, integer:0; 27, return_statement; 28, comparison_operator:count > 0; 29, block; 30, block; 31, identifier:sorted; 32, argument_list; 33, identifier:tuple; 34, generator_expression; 35, identifier:terms; 36, identifier:count; 37, integer:0; 38, return_statement; 39, raise_statement; 40, call; 41, keyword_argument; 42, subscript; 43, for_in_clause; 44, subscript; 45, call; 46, attribute; 47, argument_list; 48, identifier:key; 49, lambda; 50, identifier:i; 51, integer:0; 52, identifier:i; 53, identifier:terms; 54, identifier:terms; 55, slice; 56, identifier:ValueError; 57, argument_list; 58, attribute; 59, identifier:items; 60, lambda_parameters; 61, unary_operator; 62, identifier:count; 63, string:"Only non-negative values are allowed for count of terms."; 64, identifier:self; 65, identifier:_terms; 66, identifier:i; 67, subscript; 68, identifier:i; 69, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 6, 13; 7, 14; 9, 15; 10, 16; 11, 17; 11, 18; 11, 19; 11, 20; 15, 21; 15, 22; 16, 23; 16, 24; 17, 25; 17, 26; 18, 27; 19, 28; 19, 29; 20, 30; 22, 31; 22, 32; 24, 33; 24, 34; 27, 35; 28, 36; 28, 37; 29, 38; 30, 39; 32, 40; 32, 41; 34, 42; 34, 43; 38, 44; 39, 45; 40, 46; 40, 47; 41, 48; 41, 49; 42, 50; 42, 51; 43, 52; 43, 53; 44, 54; 44, 55; 45, 56; 45, 57; 46, 58; 46, 59; 49, 60; 49, 61; 55, 62; 57, 63; 58, 64; 58, 65; 60, 66; 61, 67; 67, 68; 67, 69 | def most_frequent_terms(self, count=0):
"""
Returns ``count`` of terms sorted by their frequency
in descending order.
:parameter int count:
Max. number of returned terms. Value 0 means no limit (default).
"""
# sort terms by number of occurrences in descending order
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; 1, function_definition; 2, function_name:sort_values; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, expression_statement; 8, if_statement; 9, identifier:ascending; 10, False; 11, comment:""" Sorts the values of this series
"""; 12, comparison_operator:self.index_type is not None; 13, block; 14, else_clause; 15, attribute; 16, None; 17, expression_statement; 18, expression_statement; 19, expression_statement; 20, expression_statement; 21, expression_statement; 22, return_statement; 23, block; 24, identifier:self; 25, identifier:index_type; 26, assignment; 27, assignment; 28, assignment; 29, assignment; 30, assignment; 31, call; 32, expression_statement; 33, identifier:index_expr; 34, call; 35, identifier:column_expr; 36, call; 37, identifier:zip_expr; 38, call; 39, identifier:result_expr; 40, call; 41, identifier:unzip_expr; 42, call; 43, identifier:SeriesWeld; 44, argument_list; 45, assignment; 46, attribute; 47, argument_list; 48, attribute; 49, argument_list; 50, attribute; 51, argument_list; 52, attribute; 53, argument_list; 54, attribute; 55, argument_list; 56, identifier:unzip_expr; 57, attribute; 58, attribute; 59, attribute; 60, attribute; 61, attribute; 62, identifier:result_expr; 63, call; 64, identifier:grizzly_impl; 65, identifier:get_field; 66, attribute; 67, integer:0; 68, identifier:grizzly_impl; 69, identifier:get_field; 70, attribute; 71, integer:1; 72, identifier:grizzly_impl; 73, identifier:zip_columns; 74, list; 75, identifier:grizzly_impl; 76, identifier:sort; 77, identifier:zip_expr; 78, integer:1; 79, attribute; 80, identifier:ascending; 81, identifier:grizzly_impl; 82, identifier:unzip_columns; 83, identifier:result_expr; 84, list; 85, identifier:self; 86, identifier:weld_type; 87, identifier:self; 88, identifier:df; 89, identifier:self; 90, identifier:column_name; 91, identifier:self; 92, identifier:index_type; 93, identifier:self; 94, identifier:index_name; 95, attribute; 96, argument_list; 97, identifier:self; 98, identifier:expr; 99, identifier:self; 100, identifier:expr; 101, identifier:index_expr; 102, identifier:column_expr; 103, identifier:self; 104, identifier:weld_type; 105, attribute; 106, attribute; 107, identifier:grizzly_impl; 108, identifier:sort; 109, attribute; 110, identifier:self; 111, identifier:index_type; 112, identifier:self; 113, identifier:weld_type; 114, identifier:self; 115, identifier:expr | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 6, 9; 6, 10; 7, 11; 8, 12; 8, 13; 8, 14; 12, 15; 12, 16; 13, 17; 13, 18; 13, 19; 13, 20; 13, 21; 13, 22; 14, 23; 15, 24; 15, 25; 17, 26; 18, 27; 19, 28; 20, 29; 21, 30; 22, 31; 23, 32; 26, 33; 26, 34; 27, 35; 27, 36; 28, 37; 28, 38; 29, 39; 29, 40; 30, 41; 30, 42; 31, 43; 31, 44; 32, 45; 34, 46; 34, 47; 36, 48; 36, 49; 38, 50; 38, 51; 40, 52; 40, 53; 42, 54; 42, 55; 44, 56; 44, 57; 44, 58; 44, 59; 44, 60; 44, 61; 45, 62; 45, 63; 46, 64; 46, 65; 47, 66; 47, 67; 48, 68; 48, 69; 49, 70; 49, 71; 50, 72; 50, 73; 51, 74; 52, 75; 52, 76; 53, 77; 53, 78; 53, 79; 53, 80; 54, 81; 54, 82; 55, 83; 55, 84; 57, 85; 57, 86; 58, 87; 58, 88; 59, 89; 59, 90; 60, 91; 60, 92; 61, 93; 61, 94; 63, 95; 63, 96; 66, 97; 66, 98; 70, 99; 70, 100; 74, 101; 74, 102; 79, 103; 79, 104; 84, 105; 84, 106; 95, 107; 95, 108; 96, 109; 105, 110; 105, 111; 106, 112; 106, 113; 109, 114; 109, 115 | def sort_values(self, ascending=False):
""" Sorts the values of this series
"""
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; 1, function_definition; 2, function_name:sort; 3, parameters; 4, block; 5, identifier:expr; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, if_statement; 13, if_statement; 14, if_statement; 15, expression_statement; 16, expression_statement; 17, return_statement; 18, identifier:field; 19, None; 20, identifier:keytype; 21, None; 22, identifier:ascending; 23, True; 24, comment:"""
Sorts the vector.
If the field parameter is provided then the sort
operators on a vector of structs where the sort key
is the field of the struct.
Args:
expr (WeldObject)
field (Int)
"""; 25, assignment; 26, assignment; 27, call; 28, block; 29, comparison_operator:field is not None; 30, block; 31, else_clause; 32, not_operator; 33, comment:# The type is not necessarily f64.; 34, block; 35, assignment; 36, assignment; 37, identifier:weld_obj; 38, identifier:weld_obj; 39, call; 40, identifier:expr_var; 41, call; 42, identifier:isinstance; 43, argument_list; 44, expression_statement; 45, expression_statement; 46, identifier:field; 47, None; 48, expression_statement; 49, block; 50, identifier:ascending; 51, expression_statement; 52, identifier:weld_template; 53, comment:"""
sort(%(expr)s, |x| %(key)s)
"""; 54, attribute; 55, binary_operator:weld_template % {"expr":expr_var, "key":key_str}; 56, identifier:WeldObject; 57, argument_list; 58, attribute; 59, argument_list; 60, identifier:expr; 61, identifier:WeldObject; 62, assignment; 63, assignment; 64, assignment; 65, expression_statement; 66, assignment; 67, identifier:weld_obj; 68, identifier:weld_code; 69, identifier:weld_template; 70, dictionary; 71, identifier:encoder_; 72, identifier:decoder_; 73, identifier:weld_obj; 74, identifier:update; 75, identifier:expr; 76, identifier:expr_var; 77, attribute; 78, subscript; 79, identifier:expr; 80, identifier:key_str; 81, binary_operator:"x.$%s" % field; 82, assignment; 83, identifier:key_str; 84, binary_operator:key_str + "* %s(-1)" % keytype; 85, pair; 86, pair; 87, identifier:expr; 88, identifier:obj_id; 89, attribute; 90, identifier:expr_var; 91, string:"x.$%s"; 92, identifier:field; 93, identifier:key_str; 94, string:"x"; 95, identifier:key_str; 96, binary_operator:"* %s(-1)" % keytype; 97, string:"expr"; 98, identifier:expr_var; 99, string:"key"; 100, identifier:key_str; 101, identifier:weld_obj; 102, identifier:dependencies; 103, string:"* %s(-1)"; 104, identifier:keytype | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 6, 18; 6, 19; 7, 20; 7, 21; 8, 22; 8, 23; 9, 24; 10, 25; 11, 26; 12, 27; 12, 28; 13, 29; 13, 30; 13, 31; 14, 32; 14, 33; 14, 34; 15, 35; 16, 36; 17, 37; 25, 38; 25, 39; 26, 40; 26, 41; 27, 42; 27, 43; 28, 44; 28, 45; 29, 46; 29, 47; 30, 48; 31, 49; 32, 50; 34, 51; 35, 52; 35, 53; 36, 54; 36, 55; 39, 56; 39, 57; 41, 58; 41, 59; 43, 60; 43, 61; 44, 62; 45, 63; 48, 64; 49, 65; 51, 66; 54, 67; 54, 68; 55, 69; 55, 70; 57, 71; 57, 72; 58, 73; 58, 74; 59, 75; 62, 76; 62, 77; 63, 78; 63, 79; 64, 80; 64, 81; 65, 82; 66, 83; 66, 84; 70, 85; 70, 86; 77, 87; 77, 88; 78, 89; 78, 90; 81, 91; 81, 92; 82, 93; 82, 94; 84, 95; 84, 96; 85, 97; 85, 98; 86, 99; 86, 100; 89, 101; 89, 102; 96, 103; 96, 104 | def sort(expr, field = None, keytype=None, ascending=True):
"""
Sorts the vector.
If the field parameter is provided then the sort
operators on a vector of structs where the sort key
is the field of the struct.
Args:
expr (WeldObject)
field (Int)
"""
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:
# The type is not necessarily f64.
key_str = key_str + "* %s(-1)" % keytype
weld_template = """
sort(%(expr)s, |x| %(key)s)
"""
weld_obj.weld_code = weld_template % {"expr":expr_var, "key":key_str}
return weld_obj |
0, module; 1, function_definition; 2, function_name:expand_filename_pattern; 3, parameters; 4, block; 5, identifier:self; 6, identifier:pattern; 7, identifier:base_dir; 8, default_parameter; 9, expression_statement; 10, comment:# replace vars like ${benchmark_path},; 11, comment:# with converting to list and back, we can use the function 'substitute_vars()'; 12, expression_statement; 13, assert_statement; 14, expression_statement; 15, if_statement; 16, expression_statement; 17, comment:# sort alphabetical,; 18, expression_statement; 19, if_statement; 20, return_statement; 21, identifier:sourcefile; 22, None; 23, comment:"""
The function expand_filename_pattern expands a filename pattern to a sorted list
of filenames. The pattern can contain variables and wildcards.
If base_dir is given and pattern is not absolute, base_dir and pattern are joined.
"""; 24, assignment; 25, comparison_operator:len(expandedPattern) == 1; 26, assignment; 27, comparison_operator:expandedPattern != pattern; 28, block; 29, assignment; 30, call; 31, not_operator; 32, block; 33, identifier:fileList; 34, identifier:expandedPattern; 35, call; 36, call; 37, integer:1; 38, identifier:expandedPattern; 39, subscript; 40, identifier:expandedPattern; 41, identifier:pattern; 42, expression_statement; 43, identifier:fileList; 44, call; 45, attribute; 46, argument_list; 47, identifier:fileList; 48, expression_statement; 49, identifier:substitute_vars; 50, argument_list; 51, identifier:len; 52, argument_list; 53, identifier:expandedPattern; 54, integer:0; 55, call; 56, attribute; 57, argument_list; 58, identifier:fileList; 59, identifier:sort; 60, call; 61, list; 62, identifier:self; 63, identifier:sourcefile; 64, identifier:expandedPattern; 65, attribute; 66, argument_list; 67, identifier:util; 68, identifier:expand_filename_pattern; 69, identifier:expandedPattern; 70, identifier:base_dir; 71, attribute; 72, argument_list; 73, identifier:pattern; 74, identifier:logging; 75, identifier:debug; 76, string:"Expanded variables in expression %r to %r."; 77, identifier:pattern; 78, identifier:expandedPattern; 79, identifier:logging; 80, identifier:warning; 81, string:"No files found matching %r."; 82, identifier:pattern | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 8, 21; 8, 22; 9, 23; 12, 24; 13, 25; 14, 26; 15, 27; 15, 28; 16, 29; 18, 30; 19, 31; 19, 32; 20, 33; 24, 34; 24, 35; 25, 36; 25, 37; 26, 38; 26, 39; 27, 40; 27, 41; 28, 42; 29, 43; 29, 44; 30, 45; 30, 46; 31, 47; 32, 48; 35, 49; 35, 50; 36, 51; 36, 52; 39, 53; 39, 54; 42, 55; 44, 56; 44, 57; 45, 58; 45, 59; 48, 60; 50, 61; 50, 62; 50, 63; 52, 64; 55, 65; 55, 66; 56, 67; 56, 68; 57, 69; 57, 70; 60, 71; 60, 72; 61, 73; 65, 74; 65, 75; 66, 76; 66, 77; 66, 78; 71, 79; 71, 80; 72, 81; 72, 82 | def expand_filename_pattern(self, pattern, base_dir, sourcefile=None):
"""
The function expand_filename_pattern expands a filename pattern to a sorted list
of filenames. The pattern can contain variables and wildcards.
If base_dir is given and pattern is not absolute, base_dir and pattern are joined.
"""
# replace vars like ${benchmark_path},
# with converting to list and back, we can use the function 'substitute_vars()'
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)
# sort alphabetical,
fileList.sort()
if not fileList:
logging.warning("No files found matching %r.", pattern)
return fileList |
0, module; 1, function_definition; 2, function_name:get_file_list; 3, parameters; 4, block; 5, identifier:shortFile; 6, expression_statement; 7, if_statement; 8, comment:# expand tilde and variables; 9, expression_statement; 10, comment:# expand wildcards; 11, expression_statement; 12, comment:# sort alphabetical,; 13, comment:# if list is emtpy, sorting returns None, so better do not sort; 14, if_statement; 15, return_statement; 16, comment:"""
The function get_file_list expands a short filename to a sorted list
of filenames. The short filename can contain variables and wildcards.
"""; 17, comparison_operator:"://" in shortFile; 18, comment:# seems to be a URL; 19, block; 20, assignment; 21, assignment; 22, comparison_operator:len(fileList) != 0; 23, block; 24, else_clause; 25, identifier:fileList; 26, string:"://"; 27, identifier:shortFile; 28, return_statement; 29, identifier:expandedFile; 30, call; 31, identifier:fileList; 32, call; 33, call; 34, integer:0; 35, expression_statement; 36, block; 37, list; 38, attribute; 39, argument_list; 40, attribute; 41, argument_list; 42, identifier:len; 43, argument_list; 44, call; 45, expression_statement; 46, identifier:shortFile; 47, attribute; 48, identifier:expandvars; 49, call; 50, identifier:glob; 51, identifier:glob; 52, identifier:expandedFile; 53, identifier:fileList; 54, attribute; 55, argument_list; 56, call; 57, identifier:os; 58, identifier:path; 59, attribute; 60, argument_list; 61, identifier:fileList; 62, identifier:sort; 63, attribute; 64, argument_list; 65, attribute; 66, identifier:expanduser; 67, identifier:shortFile; 68, identifier:logging; 69, identifier:warning; 70, string:"No file matches '%s'."; 71, identifier:shortFile; 72, identifier:os; 73, identifier:path | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 6, 16; 7, 17; 7, 18; 7, 19; 9, 20; 11, 21; 14, 22; 14, 23; 14, 24; 15, 25; 17, 26; 17, 27; 19, 28; 20, 29; 20, 30; 21, 31; 21, 32; 22, 33; 22, 34; 23, 35; 24, 36; 28, 37; 30, 38; 30, 39; 32, 40; 32, 41; 33, 42; 33, 43; 35, 44; 36, 45; 37, 46; 38, 47; 38, 48; 39, 49; 40, 50; 40, 51; 41, 52; 43, 53; 44, 54; 44, 55; 45, 56; 47, 57; 47, 58; 49, 59; 49, 60; 54, 61; 54, 62; 56, 63; 56, 64; 59, 65; 59, 66; 60, 67; 63, 68; 63, 69; 64, 70; 64, 71; 65, 72; 65, 73 | def get_file_list(shortFile):
"""
The function get_file_list expands a short filename to a sorted list
of filenames. The short filename can contain variables and wildcards.
"""
if "://" in shortFile: # seems to be a URL
return [shortFile]
# expand tilde and variables
expandedFile = os.path.expandvars(os.path.expanduser(shortFile))
# expand wildcards
fileList = glob.glob(expandedFile)
# sort alphabetical,
# if list is emtpy, sorting returns None, so better do not sort
if len(fileList) != 0:
fileList.sort()
else:
logging.warning("No file matches '%s'.", shortFile)
return fileList |
0, module; 1, function_definition; 2, function_name:FPS; 3, parameters; 4, block; 5, identifier:name; 6, identifier:sort; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, return_statement; 11, identifier:explicit_name; 12, None; 13, comment:"""
Creates a floating-point symbol.
:param name: The name of the symbol
:param sort: The sort of the floating point
:param explicit_name: If False, an identifier is appended to the name to ensure uniqueness.
:return: An FP AST.
"""; 14, assignment; 15, call; 16, identifier:n; 17, call; 18, identifier:FP; 19, argument_list; 20, identifier:_make_name; 21, argument_list; 22, string; 23, tuple; 24, keyword_argument; 25, keyword_argument; 26, keyword_argument; 27, identifier:name; 28, attribute; 29, conditional_expression:False if explicit_name is None else explicit_name; 30, keyword_argument; 31, string_content:FPS; 32, identifier:n; 33, identifier:sort; 34, identifier:variables; 35, set; 36, identifier:symbolic; 37, True; 38, identifier:length; 39, attribute; 40, identifier:sort; 41, identifier:length; 42, False; 43, comparison_operator:explicit_name is None; 44, identifier:explicit_name; 45, identifier:prefix; 46, string; 47, identifier:n; 48, identifier:sort; 49, identifier:length; 50, identifier:explicit_name; 51, None; 52, string_content:FP_ | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 7, 11; 7, 12; 8, 13; 9, 14; 10, 15; 14, 16; 14, 17; 15, 18; 15, 19; 17, 20; 17, 21; 19, 22; 19, 23; 19, 24; 19, 25; 19, 26; 21, 27; 21, 28; 21, 29; 21, 30; 22, 31; 23, 32; 23, 33; 24, 34; 24, 35; 25, 36; 25, 37; 26, 38; 26, 39; 28, 40; 28, 41; 29, 42; 29, 43; 29, 44; 30, 45; 30, 46; 35, 47; 39, 48; 39, 49; 43, 50; 43, 51; 46, 52 | def FPS(name, sort, explicit_name=None):
"""
Creates a floating-point symbol.
:param name: The name of the symbol
:param sort: The sort of the floating point
:param explicit_name: If False, an identifier is appended to the name to ensure uniqueness.
:return: An FP AST.
"""
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; 1, function_definition; 2, function_name:to_fp; 3, parameters; 4, block; 5, identifier:self; 6, identifier:sort; 7, default_parameter; 8, expression_statement; 9, if_statement; 10, return_statement; 11, identifier:rm; 12, None; 13, comment:"""
Convert this float to a different sort
:param sort: The sort to convert to
:param rm: Optional: The rounding mode to use
:return: An FP AST
"""; 14, comparison_operator:rm is None; 15, block; 16, call; 17, identifier:rm; 18, None; 19, expression_statement; 20, identifier:fpToFP; 21, argument_list; 22, assignment; 23, identifier:rm; 24, identifier:self; 25, identifier:sort; 26, identifier:rm; 27, call; 28, attribute; 29, argument_list; 30, attribute; 31, identifier:default; 32, identifier:fp; 33, identifier:RM | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 7, 11; 7, 12; 8, 13; 9, 14; 9, 15; 10, 16; 14, 17; 14, 18; 15, 19; 16, 20; 16, 21; 19, 22; 21, 23; 21, 24; 21, 25; 22, 26; 22, 27; 27, 28; 27, 29; 28, 30; 28, 31; 30, 32; 30, 33 | def to_fp(self, sort, rm=None):
"""
Convert this float to a different sort
:param sort: The sort to convert to
:param rm: Optional: The rounding mode to use
:return: An FP AST
"""
if rm is None:
rm = fp.RM.default()
return fpToFP(rm, self, sort) |
0, module; 1, function_definition; 2, function_name:val_to_fp; 3, parameters; 4, block; 5, identifier:self; 6, identifier:sort; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, if_statement; 11, if_statement; 12, expression_statement; 13, return_statement; 14, identifier:signed; 15, True; 16, identifier:rm; 17, None; 18, comment:"""
Interpret this bitvector as an integer, and return the floating-point representation of that integer.
:param sort: The sort of floating point value to return
:param signed: Optional: whether this value is a signed integer
:param rm: Optional: the rounding mode to use
:return: An FP AST whose value is the same as this BV
"""; 19, comparison_operator:rm is None; 20, block; 21, comparison_operator:sort is None; 22, block; 23, assignment; 24, call; 25, identifier:rm; 26, None; 27, expression_statement; 28, identifier:sort; 29, None; 30, expression_statement; 31, identifier:op; 32, conditional_expression:fp.fpToFP if signed else fp.fpToFPUnsigned; 33, identifier:op; 34, argument_list; 35, assignment; 36, assignment; 37, attribute; 38, identifier:signed; 39, attribute; 40, identifier:rm; 41, identifier:self; 42, identifier:sort; 43, identifier:rm; 44, call; 45, identifier:sort; 46, call; 47, identifier:fp; 48, identifier:fpToFP; 49, identifier:fp; 50, identifier:fpToFPUnsigned; 51, attribute; 52, argument_list; 53, attribute; 54, argument_list; 55, attribute; 56, identifier:default; 57, attribute; 58, identifier:from_size; 59, attribute; 60, attribute; 61, identifier:RM; 62, attribute; 63, identifier:FSort; 64, identifier:self; 65, identifier:length; 66, identifier:fp; 67, identifier:fp; 68, identifier:fp; 69, identifier:fp | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 7, 15; 8, 16; 8, 17; 9, 18; 10, 19; 10, 20; 11, 21; 11, 22; 12, 23; 13, 24; 19, 25; 19, 26; 20, 27; 21, 28; 21, 29; 22, 30; 23, 31; 23, 32; 24, 33; 24, 34; 27, 35; 30, 36; 32, 37; 32, 38; 32, 39; 34, 40; 34, 41; 34, 42; 35, 43; 35, 44; 36, 45; 36, 46; 37, 47; 37, 48; 39, 49; 39, 50; 44, 51; 44, 52; 46, 53; 46, 54; 51, 55; 51, 56; 53, 57; 53, 58; 54, 59; 55, 60; 55, 61; 57, 62; 57, 63; 59, 64; 59, 65; 60, 66; 60, 67; 62, 68; 62, 69 | def val_to_fp(self, sort, signed=True, rm=None):
"""
Interpret this bitvector as an integer, and return the floating-point representation of that integer.
:param sort: The sort of floating point value to return
:param signed: Optional: whether this value is a signed integer
:param rm: Optional: the rounding mode to use
:return: An FP AST whose value is the same as this BV
"""
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; 1, function_definition; 2, function_name:sort_orbitals; 3, parameters; 4, block; 5, identifier:element_pdos; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, for_statement; 11, return_statement; 12, comment:"""Sort the orbitals of an element's projected density of states.
Sorts the orbitals based on a standard format. E.g. s < p < d.
Will also sort lm decomposed orbitals. This is useful for plotting/saving.
Args:
element_pdos (dict): An element's pdos. Should be formatted as a
:obj:`dict` of ``{orbital: dos}``. Where dos is a
:obj:`~pymatgen.electronic_structure.dos.Dos` object. For example::
{'s': dos, 'px': dos}
Returns:
list: The sorted orbitals.
"""; 13, assignment; 14, assignment; 15, assignment; 16, identifier:key; 17, identifier:sorted_orbitals; 18, block; 19, identifier:sorted_keys; 20, identifier:sorted_orbitals; 21, list; 22, identifier:unsorted_keys; 23, call; 24, identifier:sorted_keys; 25, list; 26, if_statement; 27, string; 28, string; 29, string; 30, string; 31, string; 32, string; 33, string; 34, string; 35, string; 36, string; 37, string; 38, string; 39, string; 40, string; 41, string; 42, string; 43, string; 44, string; 45, string; 46, attribute; 47, argument_list; 48, comparison_operator:key in unsorted_keys; 49, block; 50, string_content:s; 51, string_content:p; 52, string_content:py; 53, string_content:pz; 54, string_content:px; 55, string_content:d; 56, string_content:dxy; 57, string_content:dyz; 58, string_content:dz2; 59, string_content:dxz; 60, string_content:dx2; 61, string_content:f; 62, string_content:f_3; 63, string_content:f_2; 64, string_content:f_1; 65, string_content:f_0; 66, string_content:f1; 67, string_content:f2; 68, string_content:f3; 69, identifier:element_pdos; 70, identifier:keys; 71, identifier:key; 72, identifier:unsorted_keys; 73, expression_statement; 74, call; 75, attribute; 76, argument_list; 77, identifier:sorted_keys; 78, identifier:append; 79, identifier:key | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 7, 13; 8, 14; 9, 15; 10, 16; 10, 17; 10, 18; 11, 19; 13, 20; 13, 21; 14, 22; 14, 23; 15, 24; 15, 25; 18, 26; 21, 27; 21, 28; 21, 29; 21, 30; 21, 31; 21, 32; 21, 33; 21, 34; 21, 35; 21, 36; 21, 37; 21, 38; 21, 39; 21, 40; 21, 41; 21, 42; 21, 43; 21, 44; 21, 45; 23, 46; 23, 47; 26, 48; 26, 49; 27, 50; 28, 51; 29, 52; 30, 53; 31, 54; 32, 55; 33, 56; 34, 57; 35, 58; 36, 59; 37, 60; 38, 61; 39, 62; 40, 63; 41, 64; 42, 65; 43, 66; 44, 67; 45, 68; 46, 69; 46, 70; 48, 71; 48, 72; 49, 73; 73, 74; 74, 75; 74, 76; 75, 77; 75, 78; 76, 79 | def sort_orbitals(element_pdos):
"""Sort the orbitals of an element's projected density of states.
Sorts the orbitals based on a standard format. E.g. s < p < d.
Will also sort lm decomposed orbitals. This is useful for plotting/saving.
Args:
element_pdos (dict): An element's pdos. Should be formatted as a
:obj:`dict` of ``{orbital: dos}``. Where dos is a
:obj:`~pymatgen.electronic_structure.dos.Dos` object. For example::
{'s': dos, 'px': dos}
Returns:
list: The sorted orbitals.
"""
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; 1, function_definition; 2, function_name:find_vasprun_files; 3, parameters; 4, block; 5, expression_statement; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, for_statement; 10, return_statement; 11, comment:"""Search for vasprun files from the current directory.
The precedence order for file locations is:
1. First search for folders named: 'split-0*'
2. Else, look in the current directory.
The split folder names should always be zero based, therefore easily
sortable.
"""; 12, assignment; 13, assignment; 14, assignment; 15, identifier:fol; 16, identifier:folders; 17, block; 18, identifier:filenames; 19, identifier:folders; 20, call; 21, identifier:folders; 22, conditional_expression:sorted(folders) if folders else ['.']; 23, identifier:filenames; 24, list; 25, expression_statement; 26, expression_statement; 27, if_statement; 28, attribute; 29, argument_list; 30, call; 31, identifier:folders; 32, list; 33, assignment; 34, assignment; 35, call; 36, block; 37, elif_clause; 38, else_clause; 39, identifier:glob; 40, identifier:glob; 41, string; 42, identifier:sorted; 43, argument_list; 44, string; 45, identifier:vr_file; 46, call; 47, identifier:vr_file_gz; 48, call; 49, attribute; 50, argument_list; 51, expression_statement; 52, call; 53, block; 54, block; 55, string_content:split-*; 56, identifier:folders; 57, string_content:.; 58, attribute; 59, argument_list; 60, attribute; 61, argument_list; 62, attribute; 63, identifier:exists; 64, identifier:vr_file; 65, call; 66, attribute; 67, argument_list; 68, expression_statement; 69, expression_statement; 70, expression_statement; 71, attribute; 72, identifier:join; 73, identifier:fol; 74, string; 75, attribute; 76, identifier:join; 77, identifier:fol; 78, string; 79, identifier:os; 80, identifier:path; 81, attribute; 82, argument_list; 83, attribute; 84, identifier:exists; 85, identifier:vr_file_gz; 86, call; 87, call; 88, call; 89, identifier:os; 90, identifier:path; 91, string_content:vasprun.xml; 92, identifier:os; 93, identifier:path; 94, string_content:vasprun.xml.gz; 95, identifier:filenames; 96, identifier:append; 97, identifier:vr_file; 98, identifier:os; 99, identifier:path; 100, attribute; 101, argument_list; 102, attribute; 103, argument_list; 104, attribute; 105, argument_list; 106, identifier:filenames; 107, identifier:append; 108, identifier:vr_file_gz; 109, identifier:logging; 110, identifier:error; 111, call; 112, identifier:sys; 113, identifier:exit; 114, attribute; 115, argument_list; 116, string; 117, identifier:format; 118, identifier:fol; 119, string_content:ERROR: No vasprun.xml found in {}! | 0, 1; 1, 2; 1, 3; 1, 4; 4, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 5, 11; 6, 12; 7, 13; 8, 14; 9, 15; 9, 16; 9, 17; 10, 18; 12, 19; 12, 20; 13, 21; 13, 22; 14, 23; 14, 24; 17, 25; 17, 26; 17, 27; 20, 28; 20, 29; 22, 30; 22, 31; 22, 32; 25, 33; 26, 34; 27, 35; 27, 36; 27, 37; 27, 38; 28, 39; 28, 40; 29, 41; 30, 42; 30, 43; 32, 44; 33, 45; 33, 46; 34, 47; 34, 48; 35, 49; 35, 50; 36, 51; 37, 52; 37, 53; 38, 54; 41, 55; 43, 56; 44, 57; 46, 58; 46, 59; 48, 60; 48, 61; 49, 62; 49, 63; 50, 64; 51, 65; 52, 66; 52, 67; 53, 68; 54, 69; 54, 70; 58, 71; 58, 72; 59, 73; 59, 74; 60, 75; 60, 76; 61, 77; 61, 78; 62, 79; 62, 80; 65, 81; 65, 82; 66, 83; 66, 84; 67, 85; 68, 86; 69, 87; 70, 88; 71, 89; 71, 90; 74, 91; 75, 92; 75, 93; 78, 94; 81, 95; 81, 96; 82, 97; 83, 98; 83, 99; 86, 100; 86, 101; 87, 102; 87, 103; 88, 104; 88, 105; 100, 106; 100, 107; 101, 108; 102, 109; 102, 110; 103, 111; 104, 112; 104, 113; 111, 114; 111, 115; 114, 116; 114, 117; 115, 118; 116, 119 | def find_vasprun_files():
"""Search for vasprun files from the current directory.
The precedence order for file locations is:
1. First search for folders named: 'split-0*'
2. Else, look in the current directory.
The split folder names should always be zero based, therefore easily
sortable.
"""
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; 1, function_definition; 2, function_name:feed; 3, parameters; 4, block; 5, identifier:self; 6, identifier:byts; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, while_statement; 11, return_statement; 12, string; 13, call; 14, assignment; 15, True; 16, block; 17, identifier:retn; 18, string_content: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.; 19, attribute; 20, argument_list; 21, identifier:retn; 22, list; 23, try_statement; 24, attribute; 25, identifier:feed; 26, identifier:byts; 27, block; 28, except_clause; 29, identifier:self; 30, identifier:unpk; 31, expression_statement; 32, expression_statement; 33, expression_statement; 34, expression_statement; 35, attribute; 36, block; 37, assignment; 38, assignment; 39, call; 40, assignment; 41, attribute; 42, identifier:OutOfData; 43, break_statement; 44, identifier:item; 45, call; 46, identifier:tell; 47, call; 48, attribute; 49, argument_list; 50, attribute; 51, identifier:tell; 52, identifier:msgpack; 53, identifier:exceptions; 54, attribute; 55, argument_list; 56, attribute; 57, argument_list; 58, identifier:retn; 59, identifier:append; 60, tuple; 61, identifier:self; 62, identifier:size; 63, attribute; 64, identifier:unpack; 65, attribute; 66, identifier:tell; 67, binary_operator:tell - self.size; 68, identifier:item; 69, identifier:self; 70, identifier:unpk; 71, identifier:self; 72, identifier:unpk; 73, identifier:tell; 74, attribute; 75, identifier:self; 76, identifier:size | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 7, 12; 8, 13; 9, 14; 10, 15; 10, 16; 11, 17; 12, 18; 13, 19; 13, 20; 14, 21; 14, 22; 16, 23; 19, 24; 19, 25; 20, 26; 23, 27; 23, 28; 24, 29; 24, 30; 27, 31; 27, 32; 27, 33; 27, 34; 28, 35; 28, 36; 31, 37; 32, 38; 33, 39; 34, 40; 35, 41; 35, 42; 36, 43; 37, 44; 37, 45; 38, 46; 38, 47; 39, 48; 39, 49; 40, 50; 40, 51; 41, 52; 41, 53; 45, 54; 45, 55; 47, 56; 47, 57; 48, 58; 48, 59; 49, 60; 50, 61; 50, 62; 54, 63; 54, 64; 56, 65; 56, 66; 60, 67; 60, 68; 63, 69; 63, 70; 65, 71; 65, 72; 67, 73; 67, 74; 74, 75; 74, 76 | 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; 1, function_definition; 2, function_name:maximum_consecutive_dry_days; 3, parameters; 4, block; 5, identifier:pr; 6, default_parameter; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, return_statement; 12, identifier:thresh; 13, string; 14, identifier:freq; 15, string; 16, comment:r"""Maximum number of consecutive dry days
Return the maximum number of consecutive days within the period where precipitation
is below a certain threshold.
Parameters
----------
pr : xarray.DataArray
Mean daily precipitation flux [mm]
thresh : str
Threshold precipitation on which to base evaluation [mm]. Default : '1 mm/day'
freq : str, optional
Resampling frequency
Returns
-------
xarray.DataArray
The maximum number of consecutive dry days.
Notes
-----
Let :math:`\mathbf{p}=p_0, p_1, \ldots, p_n` be a daily precipitation series and :math:`thresh` the threshold
under which a day is considered dry. Then let :math:`\mathbf{s}` be the sorted vector of indices :math:`i` where
:math:`[p_i < thresh] \neq [p_{i+1} < thresh]`, that is, the days when the temperature crosses the threshold.
Then the maximum number of consecutive dry days is given by
.. math::
\max(\mathbf{d}) \quad \mathrm{where} \quad d_j = (s_j - s_{j-1}) [p_{s_j} > thresh]
where :math:`[P]` is 1 if :math:`P` is true, and 0 if false. Note that this formula does not handle sequences at
the start and end of the series, but the numerical algorithm does.
"""; 17, assignment; 18, assignment; 19, call; 20, string_content:1 mm/day; 21, string_content:YS; 22, identifier:t; 23, call; 24, identifier:group; 25, call; 26, attribute; 27, argument_list; 28, attribute; 29, argument_list; 30, attribute; 31, argument_list; 32, identifier:group; 33, identifier:apply; 34, attribute; 35, keyword_argument; 36, identifier:utils; 37, identifier:convert_units_to; 38, identifier:thresh; 39, identifier:pr; 40, string; 41, parenthesized_expression; 42, identifier:resample; 43, keyword_argument; 44, identifier:rl; 45, identifier:longest_run; 46, identifier:dim; 47, string; 48, string_content:hydro; 49, comparison_operator:pr < t; 50, identifier:time; 51, identifier:freq; 52, string_content:time; 53, identifier:pr; 54, identifier:t | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 6, 13; 7, 14; 7, 15; 8, 16; 9, 17; 10, 18; 11, 19; 13, 20; 15, 21; 17, 22; 17, 23; 18, 24; 18, 25; 19, 26; 19, 27; 23, 28; 23, 29; 25, 30; 25, 31; 26, 32; 26, 33; 27, 34; 27, 35; 28, 36; 28, 37; 29, 38; 29, 39; 29, 40; 30, 41; 30, 42; 31, 43; 34, 44; 34, 45; 35, 46; 35, 47; 40, 48; 41, 49; 43, 50; 43, 51; 47, 52; 49, 53; 49, 54 | def maximum_consecutive_dry_days(pr, thresh='1 mm/day', freq='YS'):
r"""Maximum number of consecutive dry days
Return the maximum number of consecutive days within the period where precipitation
is below a certain threshold.
Parameters
----------
pr : xarray.DataArray
Mean daily precipitation flux [mm]
thresh : str
Threshold precipitation on which to base evaluation [mm]. Default : '1 mm/day'
freq : str, optional
Resampling frequency
Returns
-------
xarray.DataArray
The maximum number of consecutive dry days.
Notes
-----
Let :math:`\mathbf{p}=p_0, p_1, \ldots, p_n` be a daily precipitation series and :math:`thresh` the threshold
under which a day is considered dry. Then let :math:`\mathbf{s}` be the sorted vector of indices :math:`i` where
:math:`[p_i < thresh] \neq [p_{i+1} < thresh]`, that is, the days when the temperature crosses the threshold.
Then the maximum number of consecutive dry days is given by
.. math::
\max(\mathbf{d}) \quad \mathrm{where} \quad d_j = (s_j - s_{j-1}) [p_{s_j} > thresh]
where :math:`[P]` is 1 if :math:`P` is true, and 0 if false. Note that this formula does not handle sequences at
the start and end of the series, but the numerical algorithm does.
"""
t = utils.convert_units_to(thresh, pr, 'hydro')
group = (pr < t).resample(time=freq)
return group.apply(rl.longest_run, dim='time') |
0, module; 1, function_definition; 2, function_name:daily_downsampler; 3, parameters; 4, block; 5, identifier:da; 6, default_parameter; 7, expression_statement; 8, comment:# generate tags from da.time and freq; 9, if_statement; 10, expression_statement; 11, expression_statement; 12, if_statement; 13, comment:# add tags to buffer DataArray; 14, expression_statement; 15, expression_statement; 16, comment:# return groupby according to tags; 17, return_statement; 18, identifier:freq; 19, string; 20, comment:r"""Daily climate data downsampler
Parameters
----------
da : xarray.DataArray
freq : string
Returns
-------
xarray.DataArray
Note
----
Usage Example
grouper = daily_downsampler(da_std, freq='YS')
x2 = grouper.mean()
# add time coords to x2 and change dimension tags to time
time1 = daily_downsampler(da_std.time, freq=freq).first()
x2.coords['time'] = ('tags', time1.values)
x2 = x2.swap_dims({'tags': 'time'})
x2 = x2.sortby('time')
"""; 21, call; 22, block; 23, else_clause; 24, assignment; 25, assignment; 26, comparison_operator:freq == 'YS'; 27, comment:# year start frequency; 28, block; 29, elif_clause; 30, elif_clause; 31, else_clause; 32, assignment; 33, assignment; 34, call; 35, string_content:YS; 36, identifier:isinstance; 37, argument_list; 38, expression_statement; 39, expression_statement; 40, comment:# cannot use year, month, season attributes, not available for all calendars ...; 41, block; 42, identifier:seasons; 43, list_comprehension; 44, identifier:n_t; 45, attribute; 46, identifier:freq; 47, string; 48, expression_statement; 49, comparison_operator:freq == 'MS'; 50, comment:# month start frequency; 51, block; 52, comparison_operator:freq == 'QS-DEC'; 53, comment:# DJF, MAM, JJA, SON seasons; 54, comment:# construct tags from list of season+year, increasing year for December; 55, block; 56, block; 57, identifier:buffer; 58, call; 59, subscript; 60, tuple; 61, attribute; 62, argument_list; 63, subscript; 64, attribute; 65, assignment; 66, assignment; 67, expression_statement; 68, expression_statement; 69, subscript; 70, for_in_clause; 71, attribute; 72, identifier:size; 73, string_content:YS; 74, assignment; 75, identifier:freq; 76, string; 77, expression_statement; 78, identifier:freq; 79, string; 80, expression_statement; 81, for_statement; 82, expression_statement; 83, raise_statement; 84, attribute; 85, argument_list; 86, attribute; 87, string; 88, string; 89, identifier:l_tags; 90, identifier:buffer; 91, identifier:groupby; 92, string; 93, attribute; 94, integer:0; 95, identifier:np; 96, identifier:datetime64; 97, identifier:years; 98, list_comprehension; 99, identifier:months; 100, list_comprehension; 101, assignment; 102, assignment; 103, call; 104, binary_operator:int(m) - 1; 105, identifier:m; 106, identifier:months; 107, identifier:da; 108, identifier:time; 109, identifier:l_tags; 110, identifier:years; 111, string_content:MS; 112, assignment; 113, string_content:QS-DEC; 114, assignment; 115, identifier:i; 116, call; 117, block; 118, assignment; 119, call; 120, identifier:da; 121, identifier:copy; 122, identifier:buffer; 123, identifier:coords; 124, string_content:tags; 125, string_content:time; 126, string_content:tags; 127, attribute; 128, identifier:values; 129, call; 130, for_in_clause; 131, call; 132, for_in_clause; 133, identifier:years; 134, list_comprehension; 135, identifier:months; 136, list_comprehension; 137, attribute; 138, argument_list; 139, call; 140, integer:1; 141, identifier:l_tags; 142, list_comprehension; 143, identifier:ys; 144, list; 145, identifier:range; 146, argument_list; 147, expression_statement; 148, expression_statement; 149, expression_statement; 150, if_statement; 151, expression_statement; 152, identifier:l_tags; 153, identifier:ys; 154, identifier:RuntimeError; 155, argument_list; 156, identifier:da; 157, identifier:time; 158, attribute; 159, argument_list; 160, identifier:y; 161, attribute; 162, attribute; 163, argument_list; 164, identifier:m; 165, attribute; 166, call; 167, for_in_clause; 168, call; 169, for_in_clause; 170, string; 171, identifier:split; 172, identifier:int; 173, argument_list; 174, binary_operator:years[i] + months[i]; 175, for_in_clause; 176, identifier:n_t; 177, assignment; 178, assignment; 179, assignment; 180, comparison_operator:m == '12'; 181, block; 182, call; 183, call; 184, string; 185, identifier:format; 186, identifier:y; 187, attribute; 188, identifier:values; 189, string; 190, identifier:format; 191, identifier:m; 192, attribute; 193, identifier:values; 194, attribute; 195, argument_list; 196, identifier:v; 197, attribute; 198, attribute; 199, argument_list; 200, identifier:v; 201, attribute; 202, string_content:DJF DJF MAM MAM MAM JJA JJA JJA SON SON SON DJF; 203, identifier:m; 204, subscript; 205, subscript; 206, identifier:i; 207, call; 208, identifier:m; 209, subscript; 210, identifier:s; 211, subscript; 212, identifier:y; 213, subscript; 214, identifier:m; 215, string; 216, expression_statement; 217, attribute; 218, argument_list; 219, attribute; 220, argument_list; 221, string_content:{:04d}; 222, attribute; 223, identifier:year; 224, string_content:{:02d}; 225, attribute; 226, identifier:month; 227, string; 228, identifier:format; 229, attribute; 230, attribute; 231, identifier:values; 232, string; 233, identifier:format; 234, attribute; 235, attribute; 236, identifier:values; 237, identifier:years; 238, identifier:i; 239, identifier:months; 240, identifier:i; 241, identifier:range; 242, argument_list; 243, identifier:months; 244, identifier:i; 245, identifier:seasons; 246, identifier:i; 247, identifier:years; 248, identifier:i; 249, string_content:12; 250, assignment; 251, identifier:ys; 252, identifier:append; 253, binary_operator:y + s; 254, string; 255, identifier:format; 256, identifier:freq; 257, attribute; 258, identifier:dt; 259, attribute; 260, identifier:dt; 261, string_content:{:04d}; 262, identifier:v; 263, identifier:year; 264, identifier:da; 265, identifier:time; 266, string_content:{:02d}; 267, identifier:v; 268, identifier:month; 269, identifier:da; 270, identifier:time; 271, identifier:n_t; 272, identifier:y; 273, call; 274, identifier:y; 275, identifier:s; 276, string_content:freqency {:s} not implemented; 277, identifier:da; 278, identifier:time; 279, identifier:da; 280, identifier:time; 281, identifier:str; 282, argument_list; 283, binary_operator:int(y) + 1; 284, call; 285, integer:1; 286, identifier:int; 287, argument_list; 288, identifier:y | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 6, 18; 6, 19; 7, 20; 9, 21; 9, 22; 9, 23; 10, 24; 11, 25; 12, 26; 12, 27; 12, 28; 12, 29; 12, 30; 12, 31; 14, 32; 15, 33; 17, 34; 19, 35; 21, 36; 21, 37; 22, 38; 22, 39; 23, 40; 23, 41; 24, 42; 24, 43; 25, 44; 25, 45; 26, 46; 26, 47; 28, 48; 29, 49; 29, 50; 29, 51; 30, 52; 30, 53; 30, 54; 30, 55; 31, 56; 32, 57; 32, 58; 33, 59; 33, 60; 34, 61; 34, 62; 37, 63; 37, 64; 38, 65; 39, 66; 41, 67; 41, 68; 43, 69; 43, 70; 45, 71; 45, 72; 47, 73; 48, 74; 49, 75; 49, 76; 51, 77; 52, 78; 52, 79; 55, 80; 55, 81; 55, 82; 56, 83; 58, 84; 58, 85; 59, 86; 59, 87; 60, 88; 60, 89; 61, 90; 61, 91; 62, 92; 63, 93; 63, 94; 64, 95; 64, 96; 65, 97; 65, 98; 66, 99; 66, 100; 67, 101; 68, 102; 69, 103; 69, 104; 70, 105; 70, 106; 71, 107; 71, 108; 74, 109; 74, 110; 76, 111; 77, 112; 79, 113; 80, 114; 81, 115; 81, 116; 81, 117; 82, 118; 83, 119; 84, 120; 84, 121; 86, 122; 86, 123; 87, 124; 88, 125; 92, 126; 93, 127; 93, 128; 98, 129; 98, 130; 100, 131; 100, 132; 101, 133; 101, 134; 102, 135; 102, 136; 103, 137; 103, 138; 104, 139; 104, 140; 112, 141; 112, 142; 114, 143; 114, 144; 116, 145; 116, 146; 117, 147; 117, 148; 117, 149; 117, 150; 117, 151; 118, 152; 118, 153; 119, 154; 119, 155; 127, 156; 127, 157; 129, 158; 129, 159; 130, 160; 130, 161; 131, 162; 131, 163; 132, 164; 132, 165; 134, 166; 134, 167; 136, 168; 136, 169; 137, 170; 137, 171; 139, 172; 139, 173; 142, 174; 142, 175; 146, 176; 147, 177; 148, 178; 149, 179; 150, 180; 150, 181; 151, 182; 155, 183; 158, 184; 158, 185; 159, 186; 161, 187; 161, 188; 162, 189; 162, 190; 163, 191; 165, 192; 165, 193; 166, 194; 166, 195; 167, 196; 167, 197; 168, 198; 168, 199; 169, 200; 169, 201; 170, 202; 173, 203; 174, 204; 174, 205; 175, 206; 175, 207; 177, 208; 177, 209; 178, 210; 178, 211; 179, 212; 179, 213; 180, 214; 180, 215; 181, 216; 182, 217; 182, 218; 183, 219; 183, 220; 184, 221; 187, 222; 187, 223; 189, 224; 192, 225; 192, 226; 194, 227; 194, 228; 195, 229; 197, 230; 197, 231; 198, 232; 198, 233; 199, 234; 201, 235; 201, 236; 204, 237; 204, 238; 205, 239; 205, 240; 207, 241; 207, 242; 209, 243; 209, 244; 211, 245; 211, 246; 213, 247; 213, 248; 215, 249; 216, 250; 217, 251; 217, 252; 218, 253; 219, 254; 219, 255; 220, 256; 222, 257; 222, 258; 225, 259; 225, 260; 227, 261; 229, 262; 229, 263; 230, 264; 230, 265; 232, 266; 234, 267; 234, 268; 235, 269; 235, 270; 242, 271; 250, 272; 250, 273; 253, 274; 253, 275; 254, 276; 257, 277; 257, 278; 259, 279; 259, 280; 273, 281; 273, 282; 282, 283; 283, 284; 283, 285; 284, 286; 284, 287; 287, 288 | def daily_downsampler(da, freq='YS'):
r"""Daily climate data downsampler
Parameters
----------
da : xarray.DataArray
freq : string
Returns
-------
xarray.DataArray
Note
----
Usage Example
grouper = daily_downsampler(da_std, freq='YS')
x2 = grouper.mean()
# add time coords to x2 and change dimension tags to time
time1 = daily_downsampler(da_std.time, freq=freq).first()
x2.coords['time'] = ('tags', time1.values)
x2 = x2.swap_dims({'tags': 'time'})
x2 = x2.sortby('time')
"""
# generate tags from da.time and freq
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:
# cannot use year, month, season attributes, not available for all calendars ...
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':
# year start frequency
l_tags = years
elif freq == 'MS':
# month start frequency
l_tags = [years[i] + months[i] for i in range(n_t)]
elif freq == 'QS-DEC':
# DJF, MAM, JJA, SON seasons
# construct tags from list of season+year, increasing year for December
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))
# add tags to buffer DataArray
buffer = da.copy()
buffer.coords['tags'] = ('time', l_tags)
# return groupby according to tags
return buffer.groupby('tags') |
0, module; 1, function_definition; 2, function_name:identify_vertex_neighbours; 3, parameters; 4, block; 5, identifier:self; 6, identifier:vertex; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, return_statement; 13, comment:"""
Find the neighbour-vertices in the triangulation for the given vertex
Searches self.simplices for vertex entries and sorts neighbours
"""; 14, assignment; 15, assignment; 16, assignment; 17, call; 18, identifier:neighbour_array; 19, identifier:simplices; 20, attribute; 21, pattern_list; 22, call; 23, identifier:neighbour_array; 24, call; 25, attribute; 26, argument_list; 27, identifier:self; 28, identifier:simplices; 29, identifier:ridx; 30, identifier:cidx; 31, attribute; 32, argument_list; 33, attribute; 34, argument_list; 35, identifier:neighbour_array; 36, identifier:remove; 37, identifier:vertex; 38, identifier:np; 39, identifier:where; 40, comparison_operator:simplices == vertex; 41, call; 42, identifier:tolist; 43, identifier:simplices; 44, identifier:vertex; 45, attribute; 46, argument_list; 47, identifier:np; 48, identifier:unique; 49, call; 50, attribute; 51, argument_list; 52, identifier:np; 53, identifier:hstack; 54, list; 55, subscript; 56, identifier:simplices; 57, identifier:ridx | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 7, 13; 8, 14; 9, 15; 10, 16; 11, 17; 12, 18; 14, 19; 14, 20; 15, 21; 15, 22; 16, 23; 16, 24; 17, 25; 17, 26; 20, 27; 20, 28; 21, 29; 21, 30; 22, 31; 22, 32; 24, 33; 24, 34; 25, 35; 25, 36; 26, 37; 31, 38; 31, 39; 32, 40; 33, 41; 33, 42; 40, 43; 40, 44; 41, 45; 41, 46; 45, 47; 45, 48; 46, 49; 49, 50; 49, 51; 50, 52; 50, 53; 51, 54; 54, 55; 55, 56; 55, 57 | def identify_vertex_neighbours(self, vertex):
"""
Find the neighbour-vertices in the triangulation for the given vertex
Searches self.simplices for vertex entries and sorts neighbours
"""
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; 1, function_definition; 2, function_name:json_encode; 3, parameters; 4, block; 5, identifier:self; 6, identifier:out; 7, default_parameter; 8, default_parameter; 9, default_parameter; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, for_statement; 14, identifier:limit; 15, None; 16, identifier:sort_keys; 17, False; 18, identifier:indent; 19, None; 20, string; 21, assignment; 22, assignment; 23, identifier:chunk; 24, call; 25, block; 26, string_content: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; 27, identifier:stream; 28, call; 29, identifier:enc; 30, call; 31, attribute; 32, argument_list; 33, expression_statement; 34, attribute; 35, argument_list; 36, attribute; 37, argument_list; 38, identifier:enc; 39, identifier:iterencode; 40, identifier:stream; 41, call; 42, identifier:self; 43, identifier:_json_stream; 44, identifier:limit; 45, identifier:json; 46, identifier:JSONEncoder; 47, keyword_argument; 48, keyword_argument; 49, attribute; 50, argument_list; 51, identifier:indent; 52, identifier:indent; 53, identifier:sort_keys; 54, identifier:sort_keys; 55, identifier:out; 56, identifier:write; 57, binary_operator:u'%s' % chunk; 58, string; 59, identifier:chunk; 60, string_content:%s | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 7, 15; 8, 16; 8, 17; 9, 18; 9, 19; 10, 20; 11, 21; 12, 22; 13, 23; 13, 24; 13, 25; 20, 26; 21, 27; 21, 28; 22, 29; 22, 30; 24, 31; 24, 32; 25, 33; 28, 34; 28, 35; 30, 36; 30, 37; 31, 38; 31, 39; 32, 40; 33, 41; 34, 42; 34, 43; 35, 44; 36, 45; 36, 46; 37, 47; 37, 48; 41, 49; 41, 50; 47, 51; 47, 52; 48, 53; 48, 54; 49, 55; 49, 56; 50, 57; 57, 58; 57, 59; 58, 60 | 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; 1, function_definition; 2, function_name:quick_search; 3, parameters; 4, block; 5, identifier:self; 6, identifier:request; 7, dictionary_splat_pattern; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, return_statement; 12, identifier:kw; 13, string; 14, assignment; 15, assignment; 16, call; 17, string_content: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)`; 18, identifier:body; 19, call; 20, identifier:params; 21, call; 22, attribute; 23, argument_list; 24, attribute; 25, argument_list; 26, attribute; 27, argument_list; 28, call; 29, identifier:get_body; 30, identifier:json; 31, identifier:dumps; 32, identifier:request; 33, identifier:self; 34, identifier:_params; 35, identifier:kw; 36, attribute; 37, argument_list; 38, attribute; 39, identifier:response; 40, call; 41, identifier:self; 42, identifier:dispatcher; 43, attribute; 44, argument_list; 45, identifier:models; 46, identifier:Request; 47, call; 48, attribute; 49, keyword_argument; 50, keyword_argument; 51, keyword_argument; 52, keyword_argument; 53, attribute; 54, argument_list; 55, identifier:self; 56, identifier:auth; 57, identifier:params; 58, identifier:params; 59, identifier:body_type; 60, attribute; 61, identifier:data; 62, identifier:body; 63, identifier:method; 64, string; 65, identifier:self; 66, identifier:_url; 67, string; 68, identifier:models; 69, identifier:Items; 70, string_content:POST; 71, string_content:data/v1/quick-search | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 7, 12; 8, 13; 9, 14; 10, 15; 11, 16; 13, 17; 14, 18; 14, 19; 15, 20; 15, 21; 16, 22; 16, 23; 19, 24; 19, 25; 21, 26; 21, 27; 22, 28; 22, 29; 24, 30; 24, 31; 25, 32; 26, 33; 26, 34; 27, 35; 28, 36; 28, 37; 36, 38; 36, 39; 37, 40; 38, 41; 38, 42; 40, 43; 40, 44; 43, 45; 43, 46; 44, 47; 44, 48; 44, 49; 44, 50; 44, 51; 44, 52; 47, 53; 47, 54; 48, 55; 48, 56; 49, 57; 49, 58; 50, 59; 50, 60; 51, 61; 51, 62; 52, 63; 52, 64; 53, 65; 53, 66; 54, 67; 60, 68; 60, 69; 64, 70; 67, 71 | 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; 1, function_definition; 2, function_name:saved_search; 3, parameters; 4, block; 5, identifier:self; 6, identifier:sid; 7, dictionary_splat_pattern; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, return_statement; 12, identifier:kw; 13, string; 14, assignment; 15, assignment; 16, call; 17, string_content: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)`; 18, identifier:path; 19, binary_operator:'data/v1/searches/%s/results' % sid; 20, identifier:params; 21, call; 22, attribute; 23, argument_list; 24, string; 25, identifier:sid; 26, attribute; 27, argument_list; 28, call; 29, identifier:get_body; 30, string_content:data/v1/searches/%s/results; 31, identifier:self; 32, identifier:_params; 33, identifier:kw; 34, attribute; 35, argument_list; 36, identifier:self; 37, identifier:_get; 38, call; 39, keyword_argument; 40, keyword_argument; 41, attribute; 42, argument_list; 43, identifier:body_type; 44, attribute; 45, identifier:params; 46, identifier:params; 47, identifier:self; 48, identifier:_url; 49, identifier:path; 50, identifier:models; 51, identifier:Items | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 7, 12; 8, 13; 9, 14; 10, 15; 11, 16; 13, 17; 14, 18; 14, 19; 15, 20; 15, 21; 16, 22; 16, 23; 19, 24; 19, 25; 21, 26; 21, 27; 22, 28; 22, 29; 24, 30; 26, 31; 26, 32; 27, 33; 28, 34; 28, 35; 34, 36; 34, 37; 35, 38; 35, 39; 35, 40; 38, 41; 38, 42; 39, 43; 39, 44; 40, 45; 40, 46; 41, 47; 41, 48; 42, 49; 44, 50; 44, 51 | 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; 1, function_definition; 2, function_name:_sortValue_isItalic; 3, parameters; 4, block; 5, identifier:font; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, if_statement; 10, if_statement; 11, return_statement; 12, comment:"""
Returns 0 if the font is italic.
Returns 1 if the font is not italic.
"""; 13, assignment; 14, assignment; 15, boolean_operator; 16, block; 17, comparison_operator:info.italicAngle not in (None, 0); 18, block; 19, integer:1; 20, identifier:info; 21, attribute; 22, identifier:styleMapStyleName; 23, attribute; 24, comparison_operator:styleMapStyleName is not None; 25, comparison_operator:"italic" in styleMapStyleName; 26, return_statement; 27, attribute; 28, tuple; 29, return_statement; 30, identifier:font; 31, identifier:info; 32, identifier:info; 33, identifier:styleMapStyleName; 34, identifier:styleMapStyleName; 35, None; 36, string:"italic"; 37, identifier:styleMapStyleName; 38, integer:0; 39, identifier:info; 40, identifier:italicAngle; 41, None; 42, integer:0; 43, integer:0 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 7, 13; 8, 14; 9, 15; 9, 16; 10, 17; 10, 18; 11, 19; 13, 20; 13, 21; 14, 22; 14, 23; 15, 24; 15, 25; 16, 26; 17, 27; 17, 28; 18, 29; 21, 30; 21, 31; 23, 32; 23, 33; 24, 34; 24, 35; 25, 36; 25, 37; 26, 38; 27, 39; 27, 40; 28, 41; 28, 42; 29, 43 | def _sortValue_isItalic(font):
"""
Returns 0 if the font is italic.
Returns 1 if the font is not italic.
"""
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; 1, function_definition; 2, function_name:_sortValue_isMonospace; 3, parameters; 4, block; 5, identifier:font; 6, expression_statement; 7, if_statement; 8, if_statement; 9, expression_statement; 10, for_statement; 11, return_statement; 12, comment:"""
Returns 0 if the font is monospace.
Returns 1 if the font is not monospace.
"""; 13, attribute; 14, block; 15, not_operator; 16, block; 17, assignment; 18, identifier:glyph; 19, identifier:font; 20, block; 21, integer:0; 22, attribute; 23, identifier:postscriptIsFixedPitch; 24, return_statement; 25, call; 26, return_statement; 27, identifier:testWidth; 28, None; 29, if_statement; 30, identifier:font; 31, identifier:info; 32, integer:0; 33, identifier:len; 34, argument_list; 35, integer:1; 36, comparison_operator:testWidth is None; 37, block; 38, else_clause; 39, identifier:font; 40, identifier:testWidth; 41, None; 42, expression_statement; 43, block; 44, assignment; 45, if_statement; 46, identifier:testWidth; 47, attribute; 48, comparison_operator:testWidth != glyph.width; 49, block; 50, identifier:glyph; 51, identifier:width; 52, identifier:testWidth; 53, attribute; 54, return_statement; 55, identifier:glyph; 56, identifier:width; 57, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 7, 13; 7, 14; 8, 15; 8, 16; 9, 17; 10, 18; 10, 19; 10, 20; 11, 21; 13, 22; 13, 23; 14, 24; 15, 25; 16, 26; 17, 27; 17, 28; 20, 29; 22, 30; 22, 31; 24, 32; 25, 33; 25, 34; 26, 35; 29, 36; 29, 37; 29, 38; 34, 39; 36, 40; 36, 41; 37, 42; 38, 43; 42, 44; 43, 45; 44, 46; 44, 47; 45, 48; 45, 49; 47, 50; 47, 51; 48, 52; 48, 53; 49, 54; 53, 55; 53, 56; 54, 57 | def _sortValue_isMonospace(font):
"""
Returns 0 if the font is monospace.
Returns 1 if the font is not monospace.
"""
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; 1, function_definition; 2, function_name:flair_template_sync; 3, parameters; 4, block; 5, identifier:self; 6, identifier:editable; 7, identifier:limit; 8, comment:# pylint: disable=R0912; 9, identifier:static; 10, identifier:sort; 11, identifier:use_css; 12, identifier:use_text; 13, expression_statement; 14, comment:# Parameter verification; 15, if_statement; 16, expression_statement; 17, if_statement; 18, comment:# Build current flair list along with static values; 19, expression_statement; 20, if_statement; 21, if_statement; 22, for_statement; 23, if_statement; 24, comment:# Sort flair list items according to the specified sort; 25, if_statement; 26, comment:# Clear current templates and store flair according to the sort; 27, if_statement; 28, expression_statement; 29, for_statement; 30, comment:"""Synchronize templates with flair that already exists on the site.
:param editable: Indicates that all the options should be editable.
:param limit: The minimum number of users that must share the flair
before it is added as a template.
:param static: A list of flair templates that will always be added.
:param sort: The order to sort the flair templates.
:param use_css: Include css in the templates.
:param use_text: Include text in the templates.
"""; 31, boolean_operator; 32, block; 33, assignment; 34, comparison_operator:sort not in sorts; 35, block; 36, assignment; 37, identifier:static; 38, block; 39, attribute; 40, block; 41, identifier:flair; 42, call; 43, block; 44, attribute; 45, block; 46, comparison_operator:sort == 'alpha'; 47, block; 48, else_clause; 49, attribute; 50, block; 51, call; 52, pattern_list; 53, identifier:items; 54, block; 55, not_operator; 56, not_operator; 57, raise_statement; 58, identifier:sorts; 59, tuple; 60, identifier:sort; 61, identifier:sorts; 62, raise_statement; 63, identifier:counter; 64, dictionary; 65, for_statement; 66, identifier:self; 67, identifier:verbose; 68, expression_statement; 69, expression_statement; 70, attribute; 71, argument_list; 72, if_statement; 73, if_statement; 74, if_statement; 75, identifier:self; 76, identifier:verbose; 77, expression_statement; 78, identifier:sort; 79, string; 80, expression_statement; 81, block; 82, identifier:self; 83, identifier:verbose; 84, expression_statement; 85, attribute; 86, argument_list; 87, identifier:key; 88, identifier:count; 89, if_statement; 90, if_statement; 91, if_statement; 92, expression_statement; 93, identifier:use_text; 94, identifier:use_css; 95, call; 96, string; 97, string; 98, call; 99, identifier:key; 100, identifier:static; 101, block; 102, call; 103, call; 104, identifier:self; 105, identifier:current_flair; 106, attribute; 107, block; 108, boolean_operator; 109, block; 110, elif_clause; 111, else_clause; 112, comparison_operator:key in counter; 113, block; 114, else_clause; 115, call; 116, string_content:alpha; 117, assignment; 118, expression_statement; 119, call; 120, attribute; 121, identifier:clear; 122, boolean_operator; 123, block; 124, boolean_operator; 125, block; 126, elif_clause; 127, else_clause; 128, attribute; 129, block; 130, call; 131, identifier:Exception; 132, argument_list; 133, string_content:alpha; 134, string_content:size; 135, identifier:Exception; 136, argument_list; 137, if_statement; 138, expression_statement; 139, attribute; 140, argument_list; 141, attribute; 142, argument_list; 143, identifier:self; 144, identifier:verbose; 145, expression_statement; 146, expression_statement; 147, identifier:use_text; 148, identifier:use_css; 149, expression_statement; 150, identifier:use_text; 151, block; 152, block; 153, identifier:key; 154, identifier:counter; 155, expression_statement; 156, block; 157, identifier:print; 158, argument_list; 159, identifier:items; 160, call; 161, assignment; 162, identifier:print; 163, argument_list; 164, attribute; 165, identifier:templates; 166, not_operator; 167, comparison_operator:count < limit; 168, expression_statement; 169, continue_statement; 170, identifier:use_text; 171, identifier:use_css; 172, expression_statement; 173, identifier:use_text; 174, block; 175, block; 176, identifier:self; 177, identifier:verbose; 178, expression_statement; 179, attribute; 180, argument_list; 181, string; 182, call; 183, boolean_operator; 184, block; 185, assignment; 186, attribute; 187, identifier:write; 188, string; 189, attribute; 190, identifier:flush; 191, call; 192, call; 193, assignment; 194, expression_statement; 195, expression_statement; 196, augmented_assignment; 197, expression_statement; 198, identifier:sorted; 199, argument_list; 200, identifier:items; 201, call; 202, string; 203, attribute; 204, identifier:flair; 205, identifier:key; 206, identifier:count; 207, identifier:limit; 208, call; 209, assignment; 210, expression_statement; 211, expression_statement; 212, call; 213, attribute; 214, identifier:add; 215, identifier:text; 216, identifier:css; 217, identifier:editable; 218, string_content:At least one of use_text or use_css must be True; 219, attribute; 220, argument_list; 221, identifier:use_css; 222, identifier:use_text; 223, expression_statement; 224, if_statement; 225, expression_statement; 226, subscript; 227, identifier:limit; 228, identifier:sys; 229, identifier:stdout; 230, string_content; 231, identifier:sys; 232, identifier:stdout; 233, attribute; 234, argument_list; 235, attribute; 236, argument_list; 237, identifier:key; 238, tuple; 239, assignment; 240, assignment; 241, subscript; 242, integer:1; 243, assignment; 244, call; 245, identifier:sorted; 246, argument_list; 247, string_content:Clearing current flair templates; 248, identifier:self; 249, identifier:sub; 250, identifier:print; 251, argument_list; 252, pattern_list; 253, identifier:key; 254, assignment; 255, assignment; 256, identifier:print; 257, argument_list; 258, attribute; 259, identifier:templates; 260, string; 261, identifier:format; 262, call; 263, assignment; 264, comparison_operator:len(parts) != 2; 265, block; 266, assignment; 267, identifier:counter; 268, identifier:key; 269, escape_sequence:\n; 270, attribute; 271, identifier:write; 272, string; 273, attribute; 274, identifier:flush; 275, subscript; 276, subscript; 277, identifier:key; 278, subscript; 279, identifier:key; 280, subscript; 281, identifier:counter; 282, identifier:key; 283, subscript; 284, integer:1; 285, attribute; 286, argument_list; 287, call; 288, keyword_argument; 289, keyword_argument; 290, string; 291, identifier:text; 292, identifier:css; 293, pattern_list; 294, expression_list; 295, pattern_list; 296, expression_list; 297, call; 298, attribute; 299, identifier:flair; 300, string_content:Sort must be one of: {}; 301, attribute; 302, argument_list; 303, identifier:parts; 304, call; 305, call; 306, integer:2; 307, raise_statement; 308, identifier:key; 309, identifier:parts; 310, identifier:sys; 311, identifier:stdout; 312, string_content:.; 313, identifier:sys; 314, identifier:stdout; 315, identifier:flair; 316, string; 317, identifier:flair; 318, string; 319, identifier:flair; 320, string; 321, identifier:flair; 322, string; 323, identifier:counter; 324, identifier:key; 325, identifier:counter; 326, identifier:items; 327, attribute; 328, argument_list; 329, identifier:key; 330, lambda; 331, identifier:reverse; 332, True; 333, string_content:a; 334, identifier:text; 335, identifier:css; 336, identifier:key; 337, string; 338, identifier:text; 339, identifier:css; 340, string; 341, identifier:key; 342, attribute; 343, argument_list; 344, identifier:self; 345, identifier:sub; 346, string; 347, identifier:join; 348, identifier:sorts; 349, identifier:tuple; 350, generator_expression; 351, identifier:len; 352, argument_list; 353, call; 354, string_content:flair_text; 355, string_content:flair_css_class; 356, string_content:flair_text; 357, string_content:flair_css_class; 358, identifier:counter; 359, identifier:items; 360, lambda_parameters; 361, subscript; 362, string; 363, identifier:format; 364, identifier:text; 365, identifier:css; 366, string_content:,; 367, call; 368, for_in_clause; 369, identifier:parts; 370, identifier:Exception; 371, argument_list; 372, identifier:x; 373, identifier:x; 374, integer:1; 375, string_content:Adding template: text: {!r} css: {!r}; 376, attribute; 377, argument_list; 378, identifier:x; 379, call; 380, call; 381, identifier:x; 382, identifier:strip; 383, attribute; 384, argument_list; 385, attribute; 386, argument_list; 387, identifier:key; 388, identifier:split; 389, string; 390, concatenated_string; 391, identifier:format; 392, identifier:parts; 393, string_content:,; 394, string; 395, string; 396, string; 397, string_content:--static argument {!r} must have two; 398, string_content:parts (comma separated) when using; 399, string_content:both text and css. | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 4, 27; 4, 28; 4, 29; 13, 30; 15, 31; 15, 32; 16, 33; 17, 34; 17, 35; 19, 36; 20, 37; 20, 38; 21, 39; 21, 40; 22, 41; 22, 42; 22, 43; 23, 44; 23, 45; 25, 46; 25, 47; 25, 48; 27, 49; 27, 50; 28, 51; 29, 52; 29, 53; 29, 54; 31, 55; 31, 56; 32, 57; 33, 58; 33, 59; 34, 60; 34, 61; 35, 62; 36, 63; 36, 64; 38, 65; 39, 66; 39, 67; 40, 68; 40, 69; 42, 70; 42, 71; 43, 72; 43, 73; 43, 74; 44, 75; 44, 76; 45, 77; 46, 78; 46, 79; 47, 80; 48, 81; 49, 82; 49, 83; 50, 84; 51, 85; 51, 86; 52, 87; 52, 88; 54, 89; 54, 90; 54, 91; 54, 92; 55, 93; 56, 94; 57, 95; 59, 96; 59, 97; 62, 98; 65, 99; 65, 100; 65, 101; 68, 102; 69, 103; 70, 104; 70, 105; 72, 106; 72, 107; 73, 108; 73, 109; 73, 110; 73, 111; 74, 112; 74, 113; 74, 114; 77, 115; 79, 116; 80, 117; 81, 118; 84, 119; 85, 120; 85, 121; 89, 122; 89, 123; 90, 124; 90, 125; 90, 126; 90, 127; 91, 128; 91, 129; 92, 130; 95, 131; 95, 132; 96, 133; 97, 134; 98, 135; 98, 136; 101, 137; 101, 138; 102, 139; 102, 140; 103, 141; 103, 142; 106, 143; 106, 144; 107, 145; 107, 146; 108, 147; 108, 148; 109, 149; 110, 150; 110, 151; 111, 152; 112, 153; 112, 154; 113, 155; 114, 156; 115, 157; 115, 158; 117, 159; 117, 160; 118, 161; 119, 162; 119, 163; 120, 164; 120, 165; 122, 166; 122, 167; 123, 168; 123, 169; 124, 170; 124, 171; 125, 172; 126, 173; 126, 174; 127, 175; 128, 176; 128, 177; 129, 178; 130, 179; 130, 180; 132, 181; 136, 182; 137, 183; 137, 184; 138, 185; 139, 186; 139, 187; 140, 188; 141, 189; 141, 190; 145, 191; 146, 192; 149, 193; 151, 194; 152, 195; 155, 196; 156, 197; 160, 198; 160, 199; 161, 200; 161, 201; 163, 202; 164, 203; 164, 204; 166, 205; 167, 206; 167, 207; 168, 208; 172, 209; 174, 210; 175, 211; 178, 212; 179, 213; 179, 214; 180, 215; 180, 216; 180, 217; 181, 218; 182, 219; 182, 220; 183, 221; 183, 222; 184, 223; 184, 224; 184, 225; 185, 226; 185, 227; 186, 228; 186, 229; 188, 230; 189, 231; 189, 232; 191, 233; 191, 234; 192, 235; 192, 236; 193, 237; 193, 238; 194, 239; 195, 240; 196, 241; 196, 242; 197, 243; 199, 244; 201, 245; 201, 246; 202, 247; 203, 248; 203, 249; 208, 250; 208, 251; 209, 252; 209, 253; 210, 254; 211, 255; 212, 256; 212, 257; 213, 258; 213, 259; 219, 260; 219, 261; 220, 262; 223, 263; 224, 264; 224, 265; 225, 266; 226, 267; 226, 268; 230, 269; 233, 270; 233, 271; 234, 272; 235, 273; 235, 274; 238, 275; 238, 276; 239, 277; 239, 278; 240, 279; 240, 280; 241, 281; 241, 282; 243, 283; 243, 284; 244, 285; 244, 286; 246, 287; 246, 288; 246, 289; 251, 290; 252, 291; 252, 292; 254, 293; 254, 294; 255, 295; 255, 296; 257, 297; 258, 298; 258, 299; 260, 300; 262, 301; 262, 302; 263, 303; 263, 304; 264, 305; 264, 306; 265, 307; 266, 308; 266, 309; 270, 310; 270, 311; 272, 312; 273, 313; 273, 314; 275, 315; 275, 316; 276, 317; 276, 318; 278, 319; 278, 320; 280, 321; 280, 322; 283, 323; 283, 324; 285, 325; 285, 326; 287, 327; 287, 328; 288, 329; 288, 330; 289, 331; 289, 332; 290, 333; 293, 334; 293, 335; 294, 336; 294, 337; 295, 338; 295, 339; 296, 340; 296, 341; 297, 342; 297, 343; 298, 344; 298, 345; 301, 346; 301, 347; 302, 348; 304, 349; 304, 350; 305, 351; 305, 352; 307, 353; 316, 354; 318, 355; 320, 356; 322, 357; 327, 358; 327, 359; 330, 360; 330, 361; 342, 362; 342, 363; 343, 364; 343, 365; 346, 366; 350, 367; 350, 368; 352, 369; 353, 370; 353, 371; 360, 372; 361, 373; 361, 374; 362, 375; 367, 376; 367, 377; 368, 378; 368, 379; 371, 380; 376, 381; 376, 382; 379, 383; 379, 384; 380, 385; 380, 386; 383, 387; 383, 388; 384, 389; 385, 390; 385, 391; 386, 392; 389, 393; 390, 394; 390, 395; 390, 396; 394, 397; 395, 398; 396, 399 | def flair_template_sync(self, editable, limit, # pylint: disable=R0912
static, sort, use_css, use_text):
"""Synchronize templates with flair that already exists on the site.
:param editable: Indicates that all the options should be editable.
:param limit: The minimum number of users that must share the flair
before it is added as a template.
:param static: A list of flair templates that will always be added.
:param sort: The order to sort the flair templates.
:param use_css: Include css in the templates.
:param use_text: Include text in the templates.
"""
# Parameter verification
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)))
# Build current flair list along with static values
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()
# Sort flair list items according to the specified sort
if sort == 'alpha':
items = sorted(counter.items())
else:
items = sorted(counter.items(), key=lambda x: x[1], reverse=True)
# Clear current templates and store flair according to the sort
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; 1, function_definition; 2, function_name:props; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, comment:# Parse Inputs; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, if_statement; 15, if_statement; 16, if_statement; 17, comment:# Deal with hidden props; 18, expression_statement; 19, expression_statement; 20, comment:# Remove values of the wrong element; 21, expression_statement; 22, expression_statement; 23, comment:# Convert to nice list for printing; 24, expression_statement; 25, comment:# Repeat for associated objects if deep is True; 26, if_statement; 27, return_statement; 28, identifier:element; 29, None; 30, identifier:mode; 31, string; 32, identifier:deep; 33, False; 34, comment:r"""
Returns a list containing the names of all defined pore or throat
properties.
Parameters
----------
element : string, optional
Can be either 'pore' or 'throat' to specify what properties are
returned. If no element is given, both are returned
mode : string, optional
Controls what type of properties are returned. Options are:
**'all'** : Returns all properties on the object (default)
**'models'** : Returns only properties that are associated with a
model
**'constants'** : returns data values that were *not* generated by
a model, but manaully created.
deep : boolean
If ``True`` this will also return the data on any associated
subdomain objects
Returns
-------
A an alphabetically sorted list containing the string name of all
pore or throat properties currently defined. This list is an iterable,
so is useful for scanning through properties.
See Also
--------
labels
keys
Examples
--------
>>> import openpnm as op
>>> pn = op.network.Cubic(shape=[3, 3, 3])
>>> pn.props('pore')
['pore.coords']
>>> pn.props('throat')
['throat.conns']
>>> pn.props()
['pore.coords', 'throat.conns']
"""; 35, assignment; 36, assignment; 37, assignment; 38, comparison_operator:mode == 'all'; 39, block; 40, comparison_operator:mode == 'constants'; 41, block; 42, comparison_operator:mode == 'models'; 43, block; 44, assignment; 45, assignment; 46, assignment; 47, assignment; 48, assignment; 49, identifier:deep; 50, block; 51, identifier:vals; 52, string_content:all; 53, identifier:element; 54, call; 55, identifier:allowed_modes; 56, list; 57, identifier:mode; 58, call; 59, identifier:mode; 60, string; 61, expression_statement; 62, identifier:mode; 63, string; 64, if_statement; 65, identifier:mode; 66, string; 67, if_statement; 68, identifier:hide; 69, call; 70, identifier:vals; 71, call; 72, identifier:temp; 73, call; 74, identifier:vals; 75, call; 76, identifier:vals; 77, call; 78, if_statement; 79, if_statement; 80, attribute; 81, argument_list; 82, string; 83, string; 84, string; 85, attribute; 86, argument_list; 87, string_content:all; 88, assignment; 89, string_content:constants; 90, call; 91, block; 92, else_clause; 93, string_content:models; 94, call; 95, block; 96, else_clause; 97, identifier:set; 98, argument_list; 99, attribute; 100, argument_list; 101, identifier:set; 102, argument_list; 103, attribute; 104, argument_list; 105, identifier:PrintableList; 106, argument_list; 107, call; 108, block; 109, call; 110, block; 111, identifier:self; 112, identifier:_parse_element; 113, keyword_argument; 114, string_content:all; 115, string_content:constants; 116, string_content:models; 117, identifier:self; 118, identifier:_parse_mode; 119, keyword_argument; 120, keyword_argument; 121, keyword_argument; 122, identifier:vals; 123, call; 124, identifier:hasattr; 125, argument_list; 126, expression_statement; 127, expression_statement; 128, block; 129, identifier:hasattr; 130, argument_list; 131, expression_statement; 132, expression_statement; 133, block; 134, list_comprehension; 135, identifier:vals; 136, identifier:difference; 137, identifier:hide; 138, list_comprehension; 139, call; 140, identifier:difference; 141, identifier:temp; 142, call; 143, attribute; 144, argument_list; 145, for_statement; 146, attribute; 147, argument_list; 148, for_statement; 149, identifier:element; 150, identifier:element; 151, identifier:mode; 152, identifier:mode; 153, identifier:allowed; 154, identifier:allowed_modes; 155, identifier:single; 156, True; 157, identifier:set; 158, argument_list; 159, identifier:self; 160, string; 161, assignment; 162, assignment; 163, expression_statement; 164, identifier:self; 165, string; 166, assignment; 167, assignment; 168, expression_statement; 169, expression_statement; 170, identifier:i; 171, for_in_clause; 172, if_clause; 173, identifier:i; 174, for_in_clause; 175, if_clause; 176, identifier:set; 177, argument_list; 178, identifier:list; 179, argument_list; 180, identifier:self; 181, identifier:_isa; 182, string; 183, identifier:item; 184, call; 185, block; 186, identifier:self; 187, identifier:_isa; 188, string; 189, identifier:item; 190, call; 191, block; 192, call; 193, string_content:models; 194, identifier:temp; 195, call; 196, identifier:vals; 197, call; 198, assignment; 199, string_content:models; 200, identifier:temp; 201, call; 202, identifier:vals; 203, call; 204, call; 205, assignment; 206, identifier:i; 207, call; 208, call; 209, identifier:i; 210, identifier:vals; 211, comparison_operator:i.split('.')[0] not in element; 212, identifier:vals; 213, identifier:vals; 214, string_content:phase; 215, attribute; 216, argument_list; 217, expression_statement; 218, string_content:network; 219, attribute; 220, argument_list; 221, expression_statement; 222, attribute; 223, argument_list; 224, identifier:set; 225, argument_list; 226, attribute; 227, argument_list; 228, identifier:vals; 229, call; 230, identifier:set; 231, argument_list; 232, attribute; 233, argument_list; 234, attribute; 235, argument_list; 236, identifier:vals; 237, call; 238, attribute; 239, argument_list; 240, attribute; 241, argument_list; 242, subscript; 243, identifier:element; 244, attribute; 245, identifier:find_physics; 246, keyword_argument; 247, augmented_assignment; 248, call; 249, identifier:values; 250, augmented_assignment; 251, identifier:self; 252, identifier:keys; 253, keyword_argument; 254, call; 255, identifier:temp; 256, identifier:difference; 257, call; 258, identifier:set; 259, argument_list; 260, call; 261, identifier:temp; 262, identifier:intersection; 263, call; 264, identifier:logger; 265, identifier:warning; 266, string; 267, identifier:set; 268, argument_list; 269, identifier:self; 270, identifier:keys; 271, subscript; 272, identifier:startswith; 273, string; 274, call; 275, integer:0; 276, identifier:self; 277, identifier:project; 278, identifier:phase; 279, identifier:self; 280, identifier:vals; 281, call; 282, attribute; 283, argument_list; 284, identifier:vals; 285, call; 286, identifier:mode; 287, string; 288, attribute; 289, argument_list; 290, attribute; 291, argument_list; 292, call; 293, attribute; 294, argument_list; 295, attribute; 296, argument_list; 297, string_content:Object does not have a models attribute; 298, call; 299, integer:1; 300, string_content:_; 301, attribute; 302, argument_list; 303, attribute; 304, argument_list; 305, attribute; 306, identifier:geometries; 307, attribute; 308, argument_list; 309, string_content:props; 310, identifier:self; 311, identifier:keys; 312, keyword_argument; 313, attribute; 314, identifier:keys; 315, attribute; 316, argument_list; 317, identifier:self; 318, identifier:keys; 319, keyword_argument; 320, attribute; 321, identifier:keys; 322, attribute; 323, argument_list; 324, identifier:i; 325, identifier:split; 326, string; 327, identifier:item; 328, identifier:props; 329, keyword_argument; 330, keyword_argument; 331, keyword_argument; 332, identifier:self; 333, identifier:project; 334, identifier:item; 335, identifier:props; 336, keyword_argument; 337, keyword_argument; 338, keyword_argument; 339, identifier:mode; 340, string; 341, identifier:self; 342, identifier:models; 343, identifier:self; 344, identifier:keys; 345, keyword_argument; 346, identifier:mode; 347, string; 348, identifier:self; 349, identifier:models; 350, identifier:i; 351, identifier:split; 352, string; 353, string_content:.; 354, identifier:element; 355, identifier:element; 356, identifier:mode; 357, identifier:mode; 358, identifier:deep; 359, False; 360, identifier:element; 361, identifier:element; 362, identifier:mode; 363, identifier:mode; 364, identifier:deep; 365, False; 366, string_content:props; 367, identifier:mode; 368, string; 369, string_content:props; 370, string_content:.; 371, string_content:props | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 4, 25; 4, 26; 4, 27; 6, 28; 6, 29; 7, 30; 7, 31; 8, 32; 8, 33; 9, 34; 11, 35; 12, 36; 13, 37; 14, 38; 14, 39; 15, 40; 15, 41; 16, 42; 16, 43; 18, 44; 19, 45; 21, 46; 22, 47; 24, 48; 26, 49; 26, 50; 27, 51; 31, 52; 35, 53; 35, 54; 36, 55; 36, 56; 37, 57; 37, 58; 38, 59; 38, 60; 39, 61; 40, 62; 40, 63; 41, 64; 42, 65; 42, 66; 43, 67; 44, 68; 44, 69; 45, 70; 45, 71; 46, 72; 46, 73; 47, 74; 47, 75; 48, 76; 48, 77; 50, 78; 50, 79; 54, 80; 54, 81; 56, 82; 56, 83; 56, 84; 58, 85; 58, 86; 60, 87; 61, 88; 63, 89; 64, 90; 64, 91; 64, 92; 66, 93; 67, 94; 67, 95; 67, 96; 69, 97; 69, 98; 71, 99; 71, 100; 73, 101; 73, 102; 75, 103; 75, 104; 77, 105; 77, 106; 78, 107; 78, 108; 79, 109; 79, 110; 80, 111; 80, 112; 81, 113; 82, 114; 83, 115; 84, 116; 85, 117; 85, 118; 86, 119; 86, 120; 86, 121; 88, 122; 88, 123; 90, 124; 90, 125; 91, 126; 91, 127; 92, 128; 94, 129; 94, 130; 95, 131; 95, 132; 96, 133; 98, 134; 99, 135; 99, 136; 100, 137; 102, 138; 103, 139; 103, 140; 104, 141; 106, 142; 107, 143; 107, 144; 108, 145; 109, 146; 109, 147; 110, 148; 113, 149; 113, 150; 119, 151; 119, 152; 120, 153; 120, 154; 121, 155; 121, 156; 123, 157; 123, 158; 125, 159; 125, 160; 126, 161; 127, 162; 128, 163; 130, 164; 130, 165; 131, 166; 132, 167; 133, 168; 133, 169; 134, 170; 134, 171; 134, 172; 138, 173; 138, 174; 138, 175; 139, 176; 139, 177; 142, 178; 142, 179; 143, 180; 143, 181; 144, 182; 145, 183; 145, 184; 145, 185; 146, 186; 146, 187; 147, 188; 148, 189; 148, 190; 148, 191; 158, 192; 160, 193; 161, 194; 161, 195; 162, 196; 162, 197; 163, 198; 165, 199; 166, 200; 166, 201; 167, 202; 167, 203; 168, 204; 169, 205; 171, 206; 171, 207; 172, 208; 174, 209; 174, 210; 175, 211; 177, 212; 179, 213; 182, 214; 184, 215; 184, 216; 185, 217; 188, 218; 190, 219; 190, 220; 191, 221; 192, 222; 192, 223; 195, 224; 195, 225; 197, 226; 197, 227; 198, 228; 198, 229; 201, 230; 201, 231; 203, 232; 203, 233; 204, 234; 204, 235; 205, 236; 205, 237; 207, 238; 207, 239; 208, 240; 208, 241; 211, 242; 211, 243; 215, 244; 215, 245; 216, 246; 217, 247; 219, 248; 219, 249; 221, 250; 222, 251; 222, 252; 223, 253; 225, 254; 226, 255; 226, 256; 227, 257; 229, 258; 229, 259; 231, 260; 232, 261; 232, 262; 233, 263; 234, 264; 234, 265; 235, 266; 237, 267; 237, 268; 238, 269; 238, 270; 240, 271; 240, 272; 241, 273; 242, 274; 242, 275; 244, 276; 244, 277; 246, 278; 246, 279; 247, 280; 247, 281; 248, 282; 248, 283; 250, 284; 250, 285; 253, 286; 253, 287; 254, 288; 254, 289; 257, 290; 257, 291; 259, 292; 260, 293; 260, 294; 263, 295; 263, 296; 266, 297; 271, 298; 271, 299; 273, 300; 274, 301; 274, 302; 281, 303; 281, 304; 282, 305; 282, 306; 285, 307; 285, 308; 287, 309; 288, 310; 288, 311; 289, 312; 290, 313; 290, 314; 292, 315; 292, 316; 293, 317; 293, 318; 294, 319; 295, 320; 295, 321; 298, 322; 298, 323; 301, 324; 301, 325; 302, 326; 303, 327; 303, 328; 304, 329; 304, 330; 304, 331; 305, 332; 305, 333; 307, 334; 307, 335; 308, 336; 308, 337; 308, 338; 312, 339; 312, 340; 313, 341; 313, 342; 315, 343; 315, 344; 316, 345; 319, 346; 319, 347; 320, 348; 320, 349; 322, 350; 322, 351; 323, 352; 326, 353; 329, 354; 329, 355; 330, 356; 330, 357; 331, 358; 331, 359; 336, 360; 336, 361; 337, 362; 337, 363; 338, 364; 338, 365; 340, 366; 345, 367; 345, 368; 347, 369; 352, 370; 368, 371 | def props(self, element=None, mode='all', deep=False):
r"""
Returns a list containing the names of all defined pore or throat
properties.
Parameters
----------
element : string, optional
Can be either 'pore' or 'throat' to specify what properties are
returned. If no element is given, both are returned
mode : string, optional
Controls what type of properties are returned. Options are:
**'all'** : Returns all properties on the object (default)
**'models'** : Returns only properties that are associated with a
model
**'constants'** : returns data values that were *not* generated by
a model, but manaully created.
deep : boolean
If ``True`` this will also return the data on any associated
subdomain objects
Returns
-------
A an alphabetically sorted list containing the string name of all
pore or throat properties currently defined. This list is an iterable,
so is useful for scanning through properties.
See Also
--------
labels
keys
Examples
--------
>>> import openpnm as op
>>> pn = op.network.Cubic(shape=[3, 3, 3])
>>> pn.props('pore')
['pore.coords']
>>> pn.props('throat')
['throat.conns']
>>> pn.props()
['pore.coords', 'throat.conns']
"""
# Parse Inputs
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()
# Deal with hidden props
hide = set([i for i in self.keys() if i.split('.')[1].startswith('_')])
vals = vals.difference(hide)
# Remove values of the wrong element
temp = set([i for i in vals if i.split('.')[0] not in element])
vals = set(vals).difference(temp)
# Convert to nice list for printing
vals = PrintableList(list(vals))
# Repeat for associated objects if deep is True
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; 1, function_definition; 2, function_name:set_residual; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, if_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, expression_statement; 17, expression_statement; 18, for_statement; 19, expression_statement; 20, comment:# we have added new clusters that are currently isolated and we; 21, comment:# need to stop them invading until they merge into an invading; 22, comment:# cluster; 23, for_statement; 24, identifier:pores; 25, list; 26, identifier:overwrite; 27, False; 28, comment:r"""
Method to start invasion in a network w. residual saturation.
Called after inlets are set.
Parameters
----------
pores : array_like
The pores locations that are to be filled with invader at the
beginning of the simulation.
overwrite : boolean
If ``True`` then all existing inlet locations will be removed and
then the supplied locations will be added. If ``False``, then
supplied locations are added to any already existing locations.
Notes
-----
Currently works for pores only and treats inner throats, i.e.
those that connect two pores in the cluster as invaded and outer ones
as uninvaded. Uninvaded throats are added to a new residual cluster
queue but do not start invading independently if not connected to an
inlet.
Step 1. Identify clusters in the phase occupancy.
Step 2. Look for clusters that are connected or contain an inlet
Step 3. For those that are merge into inlet cluster. May be connected
to more than one - run should sort this out
Step 4. For those that are isolated set the queue to not invading.
Step 5. (in run) When isolated cluster is met my invading cluster it
merges in and starts invading
"""; 29, assignment; 30, identifier:overwrite; 31, block; 32, assignment; 33, assignment; 34, assignment; 35, assignment; 36, assignment; 37, assignment; 38, assignment; 39, identifier:rcluster_id; 40, identifier:rcluster_ids; 41, block; 42, assignment; 43, identifier:c_num; 44, call; 45, block; 46, identifier:Ps; 47, call; 48, expression_statement; 49, subscript; 50, True; 51, identifier:residual; 52, subscript; 53, identifier:net; 54, attribute; 55, identifier:conns; 56, subscript; 57, identifier:rclusters; 58, attribute; 59, identifier:rcluster_ids; 60, call; 61, identifier:initial_num; 62, binary_operator:len(self.queue)-1; 63, expression_statement; 64, expression_statement; 65, expression_statement; 66, if_statement; 67, expression_statement; 68, comment:# Set the residual pores and inner throats as part of cluster; 69, expression_statement; 70, expression_statement; 71, expression_statement; 72, expression_statement; 73, expression_statement; 74, expression_statement; 75, expression_statement; 76, comment:# Add all the outer throats to the queue; 77, expression_statement; 78, for_statement; 79, attribute; 80, binary_operator:[True]*len(self.queue); 81, identifier:range; 82, argument_list; 83, if_statement; 84, attribute; 85, argument_list; 86, assignment; 87, subscript; 88, identifier:Ps; 89, identifier:self; 90, string; 91, attribute; 92, identifier:network; 93, identifier:net; 94, string; 95, call; 96, identifier:sites; 97, attribute; 98, argument_list; 99, call; 100, integer:1; 101, assignment; 102, assignment; 103, assignment; 104, comparison_operator:len(existing) > 0; 105, comment:# There was at least one inlet cluster connected to this; 106, comment:# residual cluster, pick the first one.; 107, block; 108, else_clause; 109, assignment; 110, assignment; 111, assignment; 112, assignment; 113, assignment; 114, assignment; 115, assignment; 116, assignment; 117, assignment; 118, identifier:T; 119, identifier:Ts; 120, block; 121, identifier:self; 122, identifier:invasion_running; 123, list; 124, call; 125, call; 126, comparison_operator:c_num > initial_num; 127, block; 128, identifier:self; 129, identifier:_parse_indices; 130, identifier:pores; 131, subscript; 132, False; 133, identifier:self; 134, string; 135, string_content:pore.residual; 136, identifier:self; 137, identifier:project; 138, string_content:throat.conns; 139, identifier:site_percolation; 140, argument_list; 141, identifier:np; 142, identifier:unique; 143, subscript; 144, identifier:len; 145, argument_list; 146, identifier:rPs; 147, comparison_operator:rclusters == rcluster_id; 148, identifier:existing; 149, call; 150, identifier:existing; 151, subscript; 152, call; 153, integer:0; 154, expression_statement; 155, comment:# Make a new cluster queue; 156, block; 157, identifier:queue; 158, subscript; 159, subscript; 160, identifier:cluster_num; 161, identifier:Ts; 162, call; 163, subscript; 164, identifier:cluster_num; 165, subscript; 166, integer:0; 167, subscript; 168, integer:0; 169, subscript; 170, unary_operator; 171, subscript; 172, unary_operator; 173, identifier:Ts; 174, call; 175, expression_statement; 176, comment:# Pc; 177, expression_statement; 178, comment:# Element Index; 179, expression_statement; 180, comment:# Element Type (Pore of Throat); 181, expression_statement; 182, expression_statement; 183, True; 184, identifier:len; 185, argument_list; 186, identifier:len; 187, argument_list; 188, identifier:c_num; 189, identifier:initial_num; 190, expression_statement; 191, identifier:self; 192, string; 193, string_content:pore.residual; 194, identifier:conns; 195, identifier:residual; 196, identifier:rclusters; 197, comparison_operator:rclusters > -1; 198, attribute; 199, identifier:rclusters; 200, identifier:rcluster_id; 201, attribute; 202, argument_list; 203, identifier:existing; 204, comparison_operator:existing > -1; 205, identifier:len; 206, argument_list; 207, assignment; 208, expression_statement; 209, expression_statement; 210, attribute; 211, identifier:cluster_num; 212, subscript; 213, identifier:rPs; 214, attribute; 215, argument_list; 216, subscript; 217, identifier:Ts; 218, subscript; 219, identifier:rPs; 220, subscript; 221, identifier:Ts; 222, subscript; 223, identifier:rPs; 224, attribute; 225, subscript; 226, identifier:Ts; 227, attribute; 228, attribute; 229, argument_list; 230, assignment; 231, call; 232, call; 233, call; 234, call; 235, attribute; 236, attribute; 237, assignment; 238, string_content:pore.residual; 239, identifier:rclusters; 240, unary_operator; 241, identifier:self; 242, identifier:queue; 243, identifier:np; 244, identifier:unique; 245, subscript; 246, identifier:existing; 247, unary_operator; 248, identifier:existing; 249, identifier:cluster_num; 250, subscript; 251, assignment; 252, call; 253, identifier:self; 254, identifier:queue; 255, identifier:self; 256, string; 257, identifier:net; 258, identifier:find_neighbor_throats; 259, keyword_argument; 260, keyword_argument; 261, keyword_argument; 262, identifier:self; 263, string; 264, identifier:self; 265, string; 266, identifier:self; 267, string; 268, identifier:self; 269, string; 270, identifier:np; 271, identifier:inf; 272, identifier:self; 273, string; 274, identifier:np; 275, identifier:inf; 276, identifier:net; 277, identifier:find_neighbor_throats; 278, keyword_argument; 279, keyword_argument; 280, keyword_argument; 281, identifier:data; 282, list; 283, attribute; 284, argument_list; 285, attribute; 286, argument_list; 287, attribute; 288, argument_list; 289, attribute; 290, argument_list; 291, identifier:self; 292, identifier:queue; 293, identifier:self; 294, identifier:queue; 295, subscript; 296, False; 297, integer:1; 298, subscript; 299, identifier:rPs; 300, integer:1; 301, identifier:existing; 302, integer:0; 303, identifier:cluster_num; 304, call; 305, attribute; 306, argument_list; 307, string_content:pore.cluster; 308, identifier:pores; 309, identifier:rPs; 310, identifier:flatten; 311, True; 312, identifier:mode; 313, string; 314, string_content:throat.cluster; 315, string_content:pore.invasion_sequence; 316, string_content:throat.invasion_sequence; 317, string_content:pore.invasion_pressure; 318, string_content:throat.invasion_pressure; 319, identifier:pores; 320, identifier:rPs; 321, identifier:flatten; 322, True; 323, identifier:mode; 324, string; 325, identifier:data; 326, identifier:append; 327, subscript; 328, identifier:data; 329, identifier:append; 330, identifier:T; 331, identifier:data; 332, identifier:append; 333, string; 334, identifier:hq; 335, identifier:heappush; 336, identifier:queue; 337, identifier:data; 338, attribute; 339, identifier:c_num; 340, identifier:self; 341, string; 342, identifier:len; 343, argument_list; 344, attribute; 345, identifier:append; 346, list; 347, string_content:xnor; 348, string_content:exclusive_or; 349, subscript; 350, identifier:T; 351, string_content:throat; 352, identifier:self; 353, identifier:invasion_running; 354, string_content:pore.cluster; 355, attribute; 356, identifier:self; 357, identifier:queue; 358, identifier:self; 359, string; 360, identifier:self; 361, identifier:queue; 362, string_content:throat.entry_pressure | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 6, 24; 6, 25; 7, 26; 7, 27; 8, 28; 9, 29; 10, 30; 10, 31; 11, 32; 12, 33; 13, 34; 14, 35; 15, 36; 16, 37; 17, 38; 18, 39; 18, 40; 18, 41; 19, 42; 23, 43; 23, 44; 23, 45; 29, 46; 29, 47; 31, 48; 32, 49; 32, 50; 33, 51; 33, 52; 34, 53; 34, 54; 35, 55; 35, 56; 36, 57; 36, 58; 37, 59; 37, 60; 38, 61; 38, 62; 41, 63; 41, 64; 41, 65; 41, 66; 41, 67; 41, 68; 41, 69; 41, 70; 41, 71; 41, 72; 41, 73; 41, 74; 41, 75; 41, 76; 41, 77; 41, 78; 42, 79; 42, 80; 44, 81; 44, 82; 45, 83; 47, 84; 47, 85; 48, 86; 49, 87; 49, 88; 52, 89; 52, 90; 54, 91; 54, 92; 56, 93; 56, 94; 58, 95; 58, 96; 60, 97; 60, 98; 62, 99; 62, 100; 63, 101; 64, 102; 65, 103; 66, 104; 66, 105; 66, 106; 66, 107; 66, 108; 67, 109; 69, 110; 70, 111; 71, 112; 72, 113; 73, 114; 74, 115; 75, 116; 77, 117; 78, 118; 78, 119; 78, 120; 79, 121; 79, 122; 80, 123; 80, 124; 82, 125; 83, 126; 83, 127; 84, 128; 84, 129; 85, 130; 86, 131; 86, 132; 87, 133; 87, 134; 90, 135; 91, 136; 91, 137; 94, 138; 95, 139; 95, 140; 97, 141; 97, 142; 98, 143; 99, 144; 99, 145; 101, 146; 101, 147; 102, 148; 102, 149; 103, 150; 103, 151; 104, 152; 104, 153; 107, 154; 108, 155; 108, 156; 109, 157; 109, 158; 110, 159; 110, 160; 111, 161; 111, 162; 112, 163; 112, 164; 113, 165; 113, 166; 114, 167; 114, 168; 115, 169; 115, 170; 116, 171; 116, 172; 117, 173; 117, 174; 120, 175; 120, 176; 120, 177; 120, 178; 120, 179; 120, 180; 120, 181; 120, 182; 123, 183; 124, 184; 124, 185; 125, 186; 125, 187; 126, 188; 126, 189; 127, 190; 131, 191; 131, 192; 134, 193; 140, 194; 140, 195; 143, 196; 143, 197; 145, 198; 147, 199; 147, 200; 149, 201; 149, 202; 151, 203; 151, 204; 152, 205; 152, 206; 154, 207; 156, 208; 156, 209; 158, 210; 158, 211; 159, 212; 159, 213; 162, 214; 162, 215; 163, 216; 163, 217; 165, 218; 165, 219; 167, 220; 167, 221; 169, 222; 169, 223; 170, 224; 171, 225; 171, 226; 172, 227; 174, 228; 174, 229; 175, 230; 177, 231; 179, 232; 181, 233; 182, 234; 185, 235; 187, 236; 190, 237; 192, 238; 197, 239; 197, 240; 198, 241; 198, 242; 201, 243; 201, 244; 202, 245; 204, 246; 204, 247; 206, 248; 207, 249; 207, 250; 208, 251; 209, 252; 210, 253; 210, 254; 212, 255; 212, 256; 214, 257; 214, 258; 215, 259; 215, 260; 215, 261; 216, 262; 216, 263; 218, 264; 218, 265; 220, 266; 220, 267; 222, 268; 222, 269; 224, 270; 224, 271; 225, 272; 225, 273; 227, 274; 227, 275; 228, 276; 228, 277; 229, 278; 229, 279; 229, 280; 230, 281; 230, 282; 231, 283; 231, 284; 232, 285; 232, 286; 233, 287; 233, 288; 234, 289; 234, 290; 235, 291; 235, 292; 236, 293; 236, 294; 237, 295; 237, 296; 240, 297; 245, 298; 245, 299; 247, 300; 250, 301; 250, 302; 251, 303; 251, 304; 252, 305; 252, 306; 256, 307; 259, 308; 259, 309; 260, 310; 260, 311; 261, 312; 261, 313; 263, 314; 265, 315; 267, 316; 269, 317; 273, 318; 278, 319; 278, 320; 279, 321; 279, 322; 280, 323; 280, 324; 283, 325; 283, 326; 284, 327; 285, 328; 285, 329; 286, 330; 287, 331; 287, 332; 288, 333; 289, 334; 289, 335; 290, 336; 290, 337; 295, 338; 295, 339; 298, 340; 298, 341; 304, 342; 304, 343; 305, 344; 305, 345; 306, 346; 313, 347; 324, 348; 327, 349; 327, 350; 333, 351; 338, 352; 338, 353; 341, 354; 343, 355; 344, 356; 344, 357; 349, 358; 349, 359; 355, 360; 355, 361; 359, 362 | def set_residual(self, pores=[], overwrite=False):
r"""
Method to start invasion in a network w. residual saturation.
Called after inlets are set.
Parameters
----------
pores : array_like
The pores locations that are to be filled with invader at the
beginning of the simulation.
overwrite : boolean
If ``True`` then all existing inlet locations will be removed and
then the supplied locations will be added. If ``False``, then
supplied locations are added to any already existing locations.
Notes
-----
Currently works for pores only and treats inner throats, i.e.
those that connect two pores in the cluster as invaded and outer ones
as uninvaded. Uninvaded throats are added to a new residual cluster
queue but do not start invading independently if not connected to an
inlet.
Step 1. Identify clusters in the phase occupancy.
Step 2. Look for clusters that are connected or contain an inlet
Step 3. For those that are merge into inlet cluster. May be connected
to more than one - run should sort this out
Step 4. For those that are isolated set the queue to not invading.
Step 5. (in run) When isolated cluster is met my invading cluster it
merges in and starts invading
"""
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:
# There was at least one inlet cluster connected to this
# residual cluster, pick the first one.
cluster_num = existing[0]
else:
# Make a new cluster queue
cluster_num = len(self.queue)
self.queue.append([])
queue = self.queue[cluster_num]
# Set the residual pores and inner throats as part of cluster
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
# Add all the outer throats to the queue
Ts = net.find_neighbor_throats(pores=rPs,
flatten=True,
mode='exclusive_or')
for T in Ts:
data = []
# Pc
data.append(self['throat.entry_pressure'][T])
# Element Index
data.append(T)
# Element Type (Pore of Throat)
data.append('throat')
hq.heappush(queue, data)
self.invasion_running = [True]*len(self.queue)
# we have added new clusters that are currently isolated and we
# need to stop them invading until they merge into an invading
# cluster
for c_num in range(len(self.queue)):
if c_num > initial_num:
self.invasion_running[c_num] = False |
0, module; 1, function_definition; 2, function_name:results; 3, parameters; 4, block; 5, identifier:self; 6, identifier:Pc; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, return_statement; 14, comment:r"""
This method determines which pores and throats are filled with invading
phase at the specified capillary pressure, and creates several arrays
indicating the occupancy status of each pore and throat for the given
pressure.
Parameters
----------
Pc : scalar
The capillary pressure for which an invading phase configuration
is desired.
Returns
-------
A dictionary containing an assortment of data about distribution
of the invading phase at the specified capillary pressure. The data
include:
**'pore.occupancy'** : A value between 0 and 1 indicating the
fractional volume of each pore that is invaded. If no late pore
filling model was applied, then this will only be integer values
(either filled or not).
**'throat.occupancy'** : The same as 'pore.occupancy' but for throats.
This dictionary can be passed directly to the ``update`` method of
the *Phase* object. These values can then be accessed by models
or algorithms.
"""; 15, assignment; 16, assignment; 17, assignment; 18, assignment; 19, assignment; 20, identifier:inv_phase; 21, identifier:Psatn; 22, comparison_operator:self['pore.invasion_pressure'] <= Pc; 23, identifier:Tsatn; 24, comparison_operator:self['throat.invasion_pressure'] <= Pc; 25, identifier:inv_phase; 26, dictionary; 27, subscript; 28, call; 29, subscript; 30, call; 31, subscript; 32, identifier:Pc; 33, subscript; 34, identifier:Pc; 35, identifier:inv_phase; 36, string; 37, attribute; 38, argument_list; 39, identifier:inv_phase; 40, string; 41, attribute; 42, argument_list; 43, identifier:self; 44, string; 45, identifier:self; 46, string; 47, string_content:pore.occupancy; 48, identifier:sp; 49, identifier:array; 50, identifier:Psatn; 51, keyword_argument; 52, string_content:throat.occupancy; 53, identifier:sp; 54, identifier:array; 55, identifier:Tsatn; 56, keyword_argument; 57, string_content:pore.invasion_pressure; 58, string_content:throat.invasion_pressure; 59, identifier:dtype; 60, identifier:float; 61, identifier:dtype; 62, identifier:float | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 8, 15; 9, 16; 10, 17; 11, 18; 12, 19; 13, 20; 15, 21; 15, 22; 16, 23; 16, 24; 17, 25; 17, 26; 18, 27; 18, 28; 19, 29; 19, 30; 22, 31; 22, 32; 24, 33; 24, 34; 27, 35; 27, 36; 28, 37; 28, 38; 29, 39; 29, 40; 30, 41; 30, 42; 31, 43; 31, 44; 33, 45; 33, 46; 36, 47; 37, 48; 37, 49; 38, 50; 38, 51; 40, 52; 41, 53; 41, 54; 42, 55; 42, 56; 44, 57; 46, 58; 51, 59; 51, 60; 56, 61; 56, 62 | def results(self, Pc):
r"""
This method determines which pores and throats are filled with invading
phase at the specified capillary pressure, and creates several arrays
indicating the occupancy status of each pore and throat for the given
pressure.
Parameters
----------
Pc : scalar
The capillary pressure for which an invading phase configuration
is desired.
Returns
-------
A dictionary containing an assortment of data about distribution
of the invading phase at the specified capillary pressure. The data
include:
**'pore.occupancy'** : A value between 0 and 1 indicating the
fractional volume of each pore that is invaded. If no late pore
filling model was applied, then this will only be integer values
(either filled or not).
**'throat.occupancy'** : The same as 'pore.occupancy' but for throats.
This dictionary can be passed directly to the ``update`` method of
the *Phase* object. These values can then be accessed by models
or algorithms.
"""
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; 1, function_definition; 2, function_name:folderitems; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, comment:# Fill empty positions from the layout with fake rows. The worksheet; 9, comment:# can be generated by making use of a WorksheetTemplate, so there is; 10, comment:# the chance that some slots of this worksheet being empty. We need to; 11, comment:# render a row still, at lest to display the slot number (Pos); 12, expression_statement; 13, comment:# Sort the items in accordance with the layout; 14, expression_statement; 15, comment:# Fill the slot header cells (first cell of each row). Each slot; 16, comment:# contains the analyses that belong to the same parent; 17, comment:# (AnalysisRequest, ReferenceSample), so the information about the; 18, comment:# parent must be displayed in the first cell of each slot.; 19, expression_statement; 20, return_statement; 21, comment:"""Returns an array of dictionaries, each dictionary represents an
analysis row to be rendered in the list. The array returned is sorted
in accordance with the layout positions set for the analyses this
worksheet contains when the analyses were added in the worksheet.
:returns: list of dicts with the items to be rendered in the list
"""; 22, assignment; 23, call; 24, assignment; 25, call; 26, identifier:items; 27, identifier:items; 28, call; 29, attribute; 30, argument_list; 31, identifier:items; 32, call; 33, attribute; 34, argument_list; 35, attribute; 36, argument_list; 37, identifier:self; 38, identifier:fill_empty_slots; 39, identifier:items; 40, identifier:sorted; 41, argument_list; 42, identifier:self; 43, identifier:fill_slots_headers; 44, identifier:items; 45, identifier:BaseView; 46, identifier:folderitems; 47, identifier:self; 48, identifier:items; 49, keyword_argument; 50, identifier:key; 51, call; 52, identifier:itemgetter; 53, argument_list; 54, string:"pos_sortkey" | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 6, 21; 7, 22; 12, 23; 14, 24; 19, 25; 20, 26; 22, 27; 22, 28; 23, 29; 23, 30; 24, 31; 24, 32; 25, 33; 25, 34; 28, 35; 28, 36; 29, 37; 29, 38; 30, 39; 32, 40; 32, 41; 33, 42; 33, 43; 34, 44; 35, 45; 35, 46; 36, 47; 41, 48; 41, 49; 49, 50; 49, 51; 51, 52; 51, 53; 53, 54 | def folderitems(self):
"""Returns an array of dictionaries, each dictionary represents an
analysis row to be rendered in the list. The array returned is sorted
in accordance with the layout positions set for the analyses this
worksheet contains when the analyses were added in the worksheet.
:returns: list of dicts with the items to be rendered in the list
"""
items = BaseView.folderitems(self)
# Fill empty positions from the layout with fake rows. The worksheet
# can be generated by making use of a WorksheetTemplate, so there is
# the chance that some slots of this worksheet being empty. We need to
# render a row still, at lest to display the slot number (Pos)
self.fill_empty_slots(items)
# Sort the items in accordance with the layout
items = sorted(items, key=itemgetter("pos_sortkey"))
# Fill the slot header cells (first cell of each row). Each slot
# contains the analyses that belong to the same parent
# (AnalysisRequest, ReferenceSample), so the information about the
# parent must be displayed in the first cell of each slot.
self.fill_slots_headers(items)
return items |
0, module; 1, function_definition; 2, function_name:resort_client_actions; 3, parameters; 4, block; 5, identifier:portal; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, comment:# Sort the actions; 12, expression_statement; 13, if_statement; 14, comment:# Reset the actions to type info; 15, expression_statement; 16, comment:"""Resorts client action views
"""; 17, assignment; 18, assignment; 19, assignment; 20, assignment; 21, assignment; 22, identifier:missing; 23, comment:# Move the actions not explicitily sorted to the end; 24, block; 25, assignment; 26, identifier:sorted_actions; 27, list; 28, identifier:type_info; 29, call; 30, identifier:actions; 31, call; 32, identifier:missing; 33, call; 34, identifier:actions; 35, call; 36, expression_statement; 37, attribute; 38, identifier:actions; 39, string:"edit"; 40, string:"contacts"; 41, string:"view"; 42, comment:# this redirects to analysisrequests; 43, string:"analysisrequests"; 44, string:"batches"; 45, string:"samplepoints"; 46, string:"profiles"; 47, string:"templates"; 48, string:"specs"; 49, string:"orders"; 50, string:"reports_listing"; 51, attribute; 52, argument_list; 53, identifier:filter; 54, argument_list; 55, identifier:filter; 56, argument_list; 57, identifier:sorted; 58, argument_list; 59, call; 60, identifier:type_info; 61, identifier:_actions; 62, attribute; 63, identifier:getTypeInfo; 64, string:"Client"; 65, lambda; 66, attribute; 67, lambda; 68, attribute; 69, identifier:actions; 70, keyword_argument; 71, attribute; 72, argument_list; 73, identifier:portal; 74, identifier:portal_types; 75, lambda_parameters; 76, comparison_operator:act.id in sorted_actions; 77, identifier:type_info; 78, identifier:_actions; 79, lambda_parameters; 80, comparison_operator:act.id not in sorted_actions; 81, identifier:type_info; 82, identifier:_actions; 83, identifier:key; 84, lambda; 85, identifier:actions; 86, identifier:extend; 87, identifier:missing; 88, identifier:act; 89, attribute; 90, identifier:sorted_actions; 91, identifier:act; 92, attribute; 93, identifier:sorted_actions; 94, lambda_parameters; 95, call; 96, identifier:act; 97, identifier:id; 98, identifier:act; 99, identifier:id; 100, identifier:act; 101, attribute; 102, argument_list; 103, identifier:sorted_actions; 104, identifier:index; 105, attribute; 106, identifier:act; 107, identifier:id | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 6, 16; 7, 17; 8, 18; 9, 19; 10, 20; 12, 21; 13, 22; 13, 23; 13, 24; 15, 25; 17, 26; 17, 27; 18, 28; 18, 29; 19, 30; 19, 31; 20, 32; 20, 33; 21, 34; 21, 35; 24, 36; 25, 37; 25, 38; 27, 39; 27, 40; 27, 41; 27, 42; 27, 43; 27, 44; 27, 45; 27, 46; 27, 47; 27, 48; 27, 49; 27, 50; 29, 51; 29, 52; 31, 53; 31, 54; 33, 55; 33, 56; 35, 57; 35, 58; 36, 59; 37, 60; 37, 61; 51, 62; 51, 63; 52, 64; 54, 65; 54, 66; 56, 67; 56, 68; 58, 69; 58, 70; 59, 71; 59, 72; 62, 73; 62, 74; 65, 75; 65, 76; 66, 77; 66, 78; 67, 79; 67, 80; 68, 81; 68, 82; 70, 83; 70, 84; 71, 85; 71, 86; 72, 87; 75, 88; 76, 89; 76, 90; 79, 91; 80, 92; 80, 93; 84, 94; 84, 95; 89, 96; 89, 97; 92, 98; 92, 99; 94, 100; 95, 101; 95, 102; 101, 103; 101, 104; 102, 105; 105, 106; 105, 107 | def resort_client_actions(portal):
"""Resorts client action views
"""
sorted_actions = [
"edit",
"contacts",
"view", # this redirects to analysisrequests
"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)
# Sort the actions
actions = sorted(actions, key=lambda act: sorted_actions.index(act.id))
if missing:
# Move the actions not explicitily sorted to the end
actions.extend(missing)
# Reset the actions to type info
type_info._actions = actions |
0, module; 1, function_definition; 2, function_name:reindex_sortable_title; 3, parameters; 4, block; 5, identifier:portal; 6, expression_statement; 7, expression_statement; 8, for_statement; 9, comment:"""Reindex sortable_title from some catalogs
"""; 10, assignment; 11, identifier:catalog_name; 12, identifier:catalogs; 13, block; 14, identifier:catalogs; 15, list; 16, expression_statement; 17, expression_statement; 18, expression_statement; 19, expression_statement; 20, expression_statement; 21, string:"bika_catalog"; 22, string:"bika_setup_catalog"; 23, string:"portal_catalog"; 24, call; 25, assignment; 26, assignment; 27, call; 28, call; 29, attribute; 30, argument_list; 31, identifier:handler; 32, call; 33, identifier:catalog; 34, call; 35, attribute; 36, argument_list; 37, identifier:commit_transaction; 38, argument_list; 39, identifier:logger; 40, identifier:info; 41, call; 42, identifier:ZLogHandler; 43, argument_list; 44, attribute; 45, argument_list; 46, identifier:catalog; 47, identifier:reindexIndex; 48, string:"sortable_title"; 49, None; 50, keyword_argument; 51, identifier:portal; 52, attribute; 53, argument_list; 54, keyword_argument; 55, identifier:api; 56, identifier:get_tool; 57, identifier:catalog_name; 58, identifier:pghandler; 59, identifier:handler; 60, string:"Reindexing sortable_title for {} ..."; 61, identifier:format; 62, identifier:catalog_name; 63, identifier:steps; 64, integer:100 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 6, 9; 7, 10; 8, 11; 8, 12; 8, 13; 10, 14; 10, 15; 13, 16; 13, 17; 13, 18; 13, 19; 13, 20; 15, 21; 15, 22; 15, 23; 16, 24; 17, 25; 18, 26; 19, 27; 20, 28; 24, 29; 24, 30; 25, 31; 25, 32; 26, 33; 26, 34; 27, 35; 27, 36; 28, 37; 28, 38; 29, 39; 29, 40; 30, 41; 32, 42; 32, 43; 34, 44; 34, 45; 35, 46; 35, 47; 36, 48; 36, 49; 36, 50; 38, 51; 41, 52; 41, 53; 43, 54; 44, 55; 44, 56; 45, 57; 50, 58; 50, 59; 52, 60; 52, 61; 53, 62; 54, 63; 54, 64 | def reindex_sortable_title(portal):
"""Reindex sortable_title from some catalogs
"""
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; 1, function_definition; 2, function_name:folderitems; 3, parameters; 4, block; 5, identifier:self; 6, default_parameter; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, if_statement; 14, return_statement; 15, identifier:full_objects; 16, False; 17, identifier:classic; 18, True; 19, comment:"""Sort by Categories
"""; 20, assignment; 21, assignment; 22, assignment; 23, assignment; 24, attribute; 25, block; 26, else_clause; 27, identifier:items; 28, identifier:bsc; 29, call; 30, attribute; 31, call; 32, attribute; 33, call; 34, identifier:items; 35, call; 36, identifier:self; 37, identifier:do_cats; 38, expression_statement; 39, block; 40, identifier:getToolByName; 41, argument_list; 42, identifier:self; 43, identifier:an_cats; 44, identifier:bsc; 45, argument_list; 46, identifier:self; 47, identifier:an_cats_order; 48, identifier:dict; 49, argument_list; 50, attribute; 51, argument_list; 52, assignment; 53, expression_statement; 54, attribute; 55, string:"bika_setup_catalog"; 56, keyword_argument; 57, keyword_argument; 58, list_comprehension; 59, call; 60, identifier:folderitems; 61, attribute; 62, call; 63, call; 64, identifier:self; 65, identifier:context; 66, identifier:portal_type; 67, string:"AnalysisCategory"; 68, identifier:sort_on; 69, string:"sortable_title"; 70, tuple; 71, for_in_clause; 72, identifier:super; 73, argument_list; 74, identifier:self; 75, identifier:categories; 76, identifier:map; 77, argument_list; 78, attribute; 79, argument_list; 80, attribute; 81, call; 82, pattern_list; 83, call; 84, identifier:AnalysisServicesView; 85, identifier:self; 86, lambda; 87, call; 88, attribute; 89, identifier:sort; 90, identifier:b; 91, identifier:Title; 92, attribute; 93, argument_list; 94, identifier:a; 95, identifier:b; 96, identifier:enumerate; 97, argument_list; 98, lambda_parameters; 99, subscript; 100, identifier:sorted; 101, argument_list; 102, identifier:self; 103, identifier:categories; 104, string:"{:04}"; 105, identifier:format; 106, identifier:a; 107, attribute; 108, identifier:x; 109, identifier:x; 110, integer:0; 111, attribute; 112, keyword_argument; 113, identifier:self; 114, identifier:an_cats; 115, identifier:self; 116, identifier:categories; 117, identifier:key; 118, lambda; 119, lambda_parameters; 120, subscript; 121, identifier:x; 122, identifier:x; 123, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 6, 15; 6, 16; 7, 17; 7, 18; 8, 19; 9, 20; 10, 21; 11, 22; 12, 23; 13, 24; 13, 25; 13, 26; 14, 27; 20, 28; 20, 29; 21, 30; 21, 31; 22, 32; 22, 33; 23, 34; 23, 35; 24, 36; 24, 37; 25, 38; 26, 39; 29, 40; 29, 41; 30, 42; 30, 43; 31, 44; 31, 45; 32, 46; 32, 47; 33, 48; 33, 49; 35, 50; 35, 51; 38, 52; 39, 53; 41, 54; 41, 55; 45, 56; 45, 57; 49, 58; 50, 59; 50, 60; 52, 61; 52, 62; 53, 63; 54, 64; 54, 65; 56, 66; 56, 67; 57, 68; 57, 69; 58, 70; 58, 71; 59, 72; 59, 73; 61, 74; 61, 75; 62, 76; 62, 77; 63, 78; 63, 79; 70, 80; 70, 81; 71, 82; 71, 83; 73, 84; 73, 85; 77, 86; 77, 87; 78, 88; 78, 89; 80, 90; 80, 91; 81, 92; 81, 93; 82, 94; 82, 95; 83, 96; 83, 97; 86, 98; 86, 99; 87, 100; 87, 101; 88, 102; 88, 103; 92, 104; 92, 105; 93, 106; 97, 107; 98, 108; 99, 109; 99, 110; 101, 111; 101, 112; 107, 113; 107, 114; 111, 115; 111, 116; 112, 117; 112, 118; 118, 119; 118, 120; 119, 121; 120, 122; 120, 123 | def folderitems(self, full_objects=False, classic=True):
"""Sort by Categories
"""
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; 1, function_definition; 2, function_name:to_display_list; 3, parameters; 4, block; 5, identifier:pairs; 6, default_parameter; 7, default_parameter; 8, expression_statement; 9, expression_statement; 10, if_statement; 11, for_statement; 12, comment:# add the empty option; 13, if_statement; 14, comment:# sort by key/value; 15, if_statement; 16, return_statement; 17, identifier:sort_by; 18, string:"key"; 19, identifier:allow_empty; 20, True; 21, comment:"""Create a Plone DisplayList from list items
:param pairs: list of key, value pairs
:param sort_by: Sort the items either by key or value
:param allow_empty: Allow to select an empty value
:returns: Plone DisplayList
"""; 22, assignment; 23, call; 24, block; 25, identifier:pair; 26, identifier:pairs; 27, comment:# pairs is a list of lists -> add each pair; 28, block; 29, identifier:allow_empty; 30, block; 31, comparison_operator:sort_by == "key"; 32, block; 33, elif_clause; 34, identifier:dl; 35, identifier:dl; 36, call; 37, identifier:isinstance; 38, argument_list; 39, expression_statement; 40, if_statement; 41, comment:# pairs is just a single pair -> add it and stop; 42, if_statement; 43, expression_statement; 44, identifier:sort_by; 45, string:"key"; 46, expression_statement; 47, comparison_operator:sort_by == "value"; 48, block; 49, identifier:DisplayList; 50, argument_list; 51, identifier:pairs; 52, identifier:basestring; 53, assignment; 54, call; 55, block; 56, call; 57, block; 58, call; 59, assignment; 60, identifier:sort_by; 61, string:"value"; 62, expression_statement; 63, identifier:pairs; 64, list; 65, identifier:isinstance; 66, argument_list; 67, expression_statement; 68, identifier:isinstance; 69, argument_list; 70, expression_statement; 71, break_statement; 72, attribute; 73, argument_list; 74, identifier:dl; 75, call; 76, assignment; 77, identifier:pairs; 78, identifier:pairs; 79, identifier:pair; 80, tuple; 81, call; 82, identifier:pair; 83, identifier:basestring; 84, call; 85, identifier:dl; 86, identifier:add; 87, string:""; 88, string:""; 89, attribute; 90, argument_list; 91, identifier:dl; 92, call; 93, identifier:tuple; 94, identifier:list; 95, attribute; 96, argument_list; 97, attribute; 98, argument_list; 99, identifier:dl; 100, identifier:sortedByKey; 101, attribute; 102, argument_list; 103, identifier:dl; 104, identifier:add; 105, list_splat; 106, identifier:dl; 107, identifier:add; 108, list_splat; 109, identifier:dl; 110, identifier:sortedByValue; 111, identifier:pair; 112, identifier:pairs | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 6, 17; 6, 18; 7, 19; 7, 20; 8, 21; 9, 22; 10, 23; 10, 24; 11, 25; 11, 26; 11, 27; 11, 28; 13, 29; 13, 30; 15, 31; 15, 32; 15, 33; 16, 34; 22, 35; 22, 36; 23, 37; 23, 38; 24, 39; 28, 40; 28, 41; 28, 42; 30, 43; 31, 44; 31, 45; 32, 46; 33, 47; 33, 48; 36, 49; 36, 50; 38, 51; 38, 52; 39, 53; 40, 54; 40, 55; 42, 56; 42, 57; 43, 58; 46, 59; 47, 60; 47, 61; 48, 62; 53, 63; 53, 64; 54, 65; 54, 66; 55, 67; 56, 68; 56, 69; 57, 70; 57, 71; 58, 72; 58, 73; 59, 74; 59, 75; 62, 76; 64, 77; 64, 78; 66, 79; 66, 80; 67, 81; 69, 82; 69, 83; 70, 84; 72, 85; 72, 86; 73, 87; 73, 88; 75, 89; 75, 90; 76, 91; 76, 92; 80, 93; 80, 94; 81, 95; 81, 96; 84, 97; 84, 98; 89, 99; 89, 100; 92, 101; 92, 102; 95, 103; 95, 104; 96, 105; 97, 106; 97, 107; 98, 108; 101, 109; 101, 110; 105, 111; 108, 112 | def to_display_list(pairs, sort_by="key", allow_empty=True):
"""Create a Plone DisplayList from list items
:param pairs: list of key, value pairs
:param sort_by: Sort the items either by key or value
:param allow_empty: Allow to select an empty value
:returns: Plone DisplayList
"""
dl = DisplayList()
if isinstance(pairs, basestring):
pairs = [pairs, pairs]
for pair in pairs:
# pairs is a list of lists -> add each pair
if isinstance(pair, (tuple, list)):
dl.add(*pair)
# pairs is just a single pair -> add it and stop
if isinstance(pair, basestring):
dl.add(*pairs)
break
# add the empty option
if allow_empty:
dl.add("", "")
# sort by key/value
if sort_by == "key":
dl = dl.sortedByKey()
elif sort_by == "value":
dl = dl.sortedByValue()
return dl |
0, module; 1, function_definition; 2, function_name:sortable_title; 3, parameters; 4, block; 5, identifier:instance; 6, expression_statement; 7, expression_statement; 8, if_statement; 9, return_statement; 10, comment:"""Uses the default Plone sortable_text index lower-case
"""; 11, assignment; 12, call; 13, block; 14, call; 15, identifier:title; 16, call; 17, identifier:safe_callable; 18, argument_list; 19, expression_statement; 20, attribute; 21, argument_list; 22, identifier:plone_sortable_title; 23, argument_list; 24, identifier:title; 25, assignment; 26, identifier:title; 27, identifier:lower; 28, identifier:instance; 29, identifier:title; 30, call; 31, identifier:title; 32, argument_list | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 6, 10; 7, 11; 8, 12; 8, 13; 9, 14; 11, 15; 11, 16; 12, 17; 12, 18; 13, 19; 14, 20; 14, 21; 16, 22; 16, 23; 18, 24; 19, 25; 20, 26; 20, 27; 23, 28; 25, 29; 25, 30; 30, 31; 30, 32 | def sortable_title(instance):
"""Uses the default Plone sortable_text index lower-case
"""
title = plone_sortable_title(instance)
if safe_callable(title):
title = title()
return title.lower() |
0, module; 1, function_definition; 2, function_name:sortable_sortkey_title; 3, parameters; 4, block; 5, identifier:instance; 6, expression_statement; 7, expression_statement; 8, if_statement; 9, expression_statement; 10, if_statement; 11, return_statement; 12, comment:"""Returns a sortable title as a mxin of sortkey + lowercase sortable_title
"""; 13, assignment; 14, call; 15, block; 16, assignment; 17, comparison_operator:sort_key is None; 18, block; 19, call; 20, identifier:title; 21, call; 22, identifier:safe_callable; 23, argument_list; 24, expression_statement; 25, identifier:sort_key; 26, call; 27, identifier:sort_key; 28, None; 29, expression_statement; 30, attribute; 31, argument_list; 32, identifier:sortable_title; 33, argument_list; 34, identifier:title; 35, assignment; 36, attribute; 37, argument_list; 38, assignment; 39, string:"{:010.3f}{}"; 40, identifier:format; 41, identifier:sort_key; 42, identifier:title; 43, identifier:instance; 44, identifier:title; 45, call; 46, identifier:instance; 47, identifier:getSortKey; 48, identifier:sort_key; 49, integer:999999; 50, identifier:title; 51, argument_list | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 6, 12; 7, 13; 8, 14; 8, 15; 9, 16; 10, 17; 10, 18; 11, 19; 13, 20; 13, 21; 14, 22; 14, 23; 15, 24; 16, 25; 16, 26; 17, 27; 17, 28; 18, 29; 19, 30; 19, 31; 21, 32; 21, 33; 23, 34; 24, 35; 26, 36; 26, 37; 29, 38; 30, 39; 30, 40; 31, 41; 31, 42; 33, 43; 35, 44; 35, 45; 36, 46; 36, 47; 38, 48; 38, 49; 45, 50; 45, 51 | def sortable_sortkey_title(instance):
"""Returns a sortable title as a mxin of sortkey + lowercase sortable_title
"""
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; 1, function_definition; 2, function_name:sorted_analyses; 3, parameters; 4, block; 5, identifier:self; 6, identifier:analyses; 7, expression_statement; 8, expression_statement; 9, function_definition; 10, comment:# Now, we need the analyses within a request ID to be sorted by; 11, comment:# sortkey (sortable_title index), so it will appear in the same; 12, comment:# order as they appear in Analyses list from AR view; 13, expression_statement; 14, expression_statement; 15, expression_statement; 16, for_statement; 17, comment:# Sort the last set of brains we've collected; 18, expression_statement; 19, expression_statement; 20, return_statement; 21, comment:"""Sort the analyses by AR ID ascending and subsorted by priority
sortkey within the AR they belong to
"""; 22, assignment; 23, function_name:sorted_by_sortkey; 24, parameters; 25, block; 26, assignment; 27, assignment; 28, assignment; 29, identifier:analysis; 30, identifier:analyses; 31, block; 32, assignment; 33, call; 34, identifier:sorted_analyses; 35, identifier:analyses; 36, call; 37, identifier:objs; 38, return_statement; 39, identifier:current_sample_id; 40, None; 41, identifier:current_analyses; 42, list; 43, identifier:sorted_analyses; 44, list; 45, expression_statement; 46, if_statement; 47, comment:# Now we are inside the same AR; 48, expression_statement; 49, continue_statement; 50, identifier:current_analyses; 51, call; 52, attribute; 53, argument_list; 54, identifier:sorted; 55, argument_list; 56, call; 57, assignment; 58, boolean_operator; 59, comment:# Sort the brains we've collected until now, that; 60, comment:# belong to the same Analysis Request; 61, block; 62, call; 63, identifier:sorted_by_sortkey; 64, argument_list; 65, identifier:sorted_analyses; 66, identifier:extend; 67, identifier:current_analyses; 68, identifier:analyses; 69, keyword_argument; 70, identifier:sorted; 71, argument_list; 72, identifier:sample_id; 73, call; 74, identifier:sample_id; 75, comparison_operator:current_sample_id != sample_id; 76, expression_statement; 77, expression_statement; 78, expression_statement; 79, expression_statement; 80, attribute; 81, argument_list; 82, identifier:current_analyses; 83, identifier:key; 84, lambda; 85, identifier:objs; 86, keyword_argument; 87, attribute; 88, argument_list; 89, identifier:current_sample_id; 90, identifier:sample_id; 91, assignment; 92, call; 93, assignment; 94, assignment; 95, identifier:current_analyses; 96, identifier:append; 97, identifier:analysis; 98, lambda_parameters; 99, call; 100, identifier:key; 101, lambda; 102, identifier:analysis; 103, identifier:getRequestID; 104, identifier:current_analyses; 105, call; 106, attribute; 107, argument_list; 108, identifier:current_sample_id; 109, identifier:sample_id; 110, identifier:current_analyses; 111, list; 112, identifier:an; 113, attribute; 114, argument_list; 115, lambda_parameters; 116, call; 117, identifier:sorted_by_sortkey; 118, argument_list; 119, identifier:sorted_analyses; 120, identifier:extend; 121, identifier:current_analyses; 122, identifier:an; 123, identifier:getRequestID; 124, identifier:an; 125, attribute; 126, argument_list; 127, identifier:current_analyses; 128, identifier:an; 129, identifier:getPrioritySortkey | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 7, 21; 8, 22; 9, 23; 9, 24; 9, 25; 13, 26; 14, 27; 15, 28; 16, 29; 16, 30; 16, 31; 18, 32; 19, 33; 20, 34; 22, 35; 22, 36; 24, 37; 25, 38; 26, 39; 26, 40; 27, 41; 27, 42; 28, 43; 28, 44; 31, 45; 31, 46; 31, 47; 31, 48; 31, 49; 32, 50; 32, 51; 33, 52; 33, 53; 36, 54; 36, 55; 38, 56; 45, 57; 46, 58; 46, 59; 46, 60; 46, 61; 48, 62; 51, 63; 51, 64; 52, 65; 52, 66; 53, 67; 55, 68; 55, 69; 56, 70; 56, 71; 57, 72; 57, 73; 58, 74; 58, 75; 61, 76; 61, 77; 61, 78; 61, 79; 62, 80; 62, 81; 64, 82; 69, 83; 69, 84; 71, 85; 71, 86; 73, 87; 73, 88; 75, 89; 75, 90; 76, 91; 77, 92; 78, 93; 79, 94; 80, 95; 80, 96; 81, 97; 84, 98; 84, 99; 86, 100; 86, 101; 87, 102; 87, 103; 91, 104; 91, 105; 92, 106; 92, 107; 93, 108; 93, 109; 94, 110; 94, 111; 98, 112; 99, 113; 99, 114; 101, 115; 101, 116; 105, 117; 105, 118; 106, 119; 106, 120; 107, 121; 113, 122; 113, 123; 115, 124; 116, 125; 116, 126; 118, 127; 125, 128; 125, 129 | def sorted_analyses(self, analyses):
"""Sort the analyses by AR ID ascending and subsorted by priority
sortkey within the AR they belong to
"""
analyses = sorted(analyses, key=lambda an: an.getRequestID())
def sorted_by_sortkey(objs):
return sorted(objs, key=lambda an: an.getPrioritySortkey())
# Now, we need the analyses within a request ID to be sorted by
# sortkey (sortable_title index), so it will appear in the same
# order as they appear in Analyses list from AR view
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:
# Sort the brains we've collected until now, that
# belong to the same Analysis Request
current_analyses = sorted_by_sortkey(current_analyses)
sorted_analyses.extend(current_analyses)
current_sample_id = sample_id
current_analyses = []
# Now we are inside the same AR
current_analyses.append(analysis)
continue
# Sort the last set of brains we've collected
current_analyses = sorted_by_sortkey(current_analyses)
sorted_analyses.extend(current_analyses)
return sorted_analyses |
0, module; 1, function_definition; 2, function_name:get_sorted_attachments; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, function_definition; 11, expression_statement; 12, return_statement; 13, comment:"""Returns a sorted list of analysis info dictionaries
"""; 14, assignment; 15, assignment; 16, assignment; 17, function_name:att_cmp; 18, parameters; 19, block; 20, assignment; 21, identifier:sorted_attachments; 22, identifier:inf; 23, call; 24, identifier:order; 25, call; 26, identifier:attachments; 27, call; 28, identifier:att1; 29, identifier:att2; 30, expression_statement; 31, expression_statement; 32, expression_statement; 33, expression_statement; 34, return_statement; 35, identifier:sorted_attachments; 36, call; 37, identifier:float; 38, argument_list; 39, attribute; 40, argument_list; 41, attribute; 42, argument_list; 43, assignment; 44, assignment; 45, assignment; 46, assignment; 47, call; 48, identifier:sorted; 49, argument_list; 50, string:"inf"; 51, identifier:self; 52, identifier:get_attachments_order; 53, identifier:self; 54, identifier:get_attachments; 55, identifier:_n1; 56, call; 57, identifier:_n2; 58, call; 59, identifier:_i1; 60, boolean_operator; 61, identifier:_i2; 62, boolean_operator; 63, identifier:cmp; 64, argument_list; 65, identifier:attachments; 66, keyword_argument; 67, attribute; 68, argument_list; 69, attribute; 70, argument_list; 71, boolean_operator; 72, identifier:inf; 73, boolean_operator; 74, identifier:inf; 75, identifier:_i1; 76, identifier:_i2; 77, identifier:cmp; 78, identifier:att_cmp; 79, identifier:att1; 80, identifier:get; 81, string; 82, identifier:att2; 83, identifier:get; 84, string; 85, comparison_operator:_n1 in order; 86, binary_operator:order.index(_n1) + 1; 87, comparison_operator:_n2 in order; 88, binary_operator:order.index(_n2) + 1; 89, string_content:UID; 90, string_content:UID; 91, identifier:_n1; 92, identifier:order; 93, call; 94, integer:1; 95, identifier:_n2; 96, identifier:order; 97, call; 98, integer:1; 99, attribute; 100, argument_list; 101, attribute; 102, argument_list; 103, identifier:order; 104, identifier:index; 105, identifier:_n1; 106, identifier:order; 107, identifier:index; 108, identifier:_n2 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 6, 13; 7, 14; 8, 15; 9, 16; 10, 17; 10, 18; 10, 19; 11, 20; 12, 21; 14, 22; 14, 23; 15, 24; 15, 25; 16, 26; 16, 27; 18, 28; 18, 29; 19, 30; 19, 31; 19, 32; 19, 33; 19, 34; 20, 35; 20, 36; 23, 37; 23, 38; 25, 39; 25, 40; 27, 41; 27, 42; 30, 43; 31, 44; 32, 45; 33, 46; 34, 47; 36, 48; 36, 49; 38, 50; 39, 51; 39, 52; 41, 53; 41, 54; 43, 55; 43, 56; 44, 57; 44, 58; 45, 59; 45, 60; 46, 61; 46, 62; 47, 63; 47, 64; 49, 65; 49, 66; 56, 67; 56, 68; 58, 69; 58, 70; 60, 71; 60, 72; 62, 73; 62, 74; 64, 75; 64, 76; 66, 77; 66, 78; 67, 79; 67, 80; 68, 81; 69, 82; 69, 83; 70, 84; 71, 85; 71, 86; 73, 87; 73, 88; 81, 89; 84, 90; 85, 91; 85, 92; 86, 93; 86, 94; 87, 95; 87, 96; 88, 97; 88, 98; 93, 99; 93, 100; 97, 101; 97, 102; 99, 103; 99, 104; 100, 105; 101, 106; 101, 107; 102, 108 | def get_sorted_attachments(self):
"""Returns a sorted list of analysis info dictionaries
"""
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; 1, function_definition; 2, function_name:get_analyses_at; 3, parameters; 4, block; 5, identifier:self; 6, identifier:slot; 7, expression_statement; 8, comment:# ensure we have an integer; 9, expression_statement; 10, if_statement; 11, expression_statement; 12, expression_statement; 13, for_statement; 14, return_statement; 15, comment:"""Returns the list of analyses assigned to the slot passed in, sorted by
the positions they have within the slot.
:param slot: the slot where the analyses are located
:type slot: int
:return: a list of analyses
"""; 16, assignment; 17, comparison_operator:slot < 1; 18, block; 19, assignment; 20, assignment; 21, identifier:pos; 22, identifier:layout; 23, block; 24, identifier:analyses; 25, identifier:slot; 26, call; 27, identifier:slot; 28, integer:1; 29, return_statement; 30, identifier:analyses; 31, call; 32, identifier:layout; 33, call; 34, expression_statement; 35, expression_statement; 36, if_statement; 37, expression_statement; 38, identifier:to_int; 39, argument_list; 40, call; 41, identifier:list; 42, argument_list; 43, attribute; 44, argument_list; 45, assignment; 46, assignment; 47, boolean_operator; 48, block; 49, call; 50, identifier:slot; 51, identifier:list; 52, argument_list; 53, identifier:self; 54, identifier:getLayout; 55, identifier:layout_slot; 56, call; 57, identifier:uid; 58, subscript; 59, comparison_operator:layout_slot != slot; 60, not_operator; 61, continue_statement; 62, attribute; 63, argument_list; 64, identifier:to_int; 65, argument_list; 66, identifier:pos; 67, string; 68, identifier:layout_slot; 69, identifier:slot; 70, identifier:uid; 71, identifier:analyses; 72, identifier:append; 73, call; 74, subscript; 75, string_content:analysis_uid; 76, attribute; 77, argument_list; 78, identifier:pos; 79, string; 80, identifier:api; 81, identifier:get_object_by_uid; 82, identifier:uid; 83, string_content:position | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 7, 15; 9, 16; 10, 17; 10, 18; 11, 19; 12, 20; 13, 21; 13, 22; 13, 23; 14, 24; 16, 25; 16, 26; 17, 27; 17, 28; 18, 29; 19, 30; 19, 31; 20, 32; 20, 33; 23, 34; 23, 35; 23, 36; 23, 37; 26, 38; 26, 39; 29, 40; 31, 41; 31, 42; 33, 43; 33, 44; 34, 45; 35, 46; 36, 47; 36, 48; 37, 49; 39, 50; 40, 51; 40, 52; 43, 53; 43, 54; 45, 55; 45, 56; 46, 57; 46, 58; 47, 59; 47, 60; 48, 61; 49, 62; 49, 63; 56, 64; 56, 65; 58, 66; 58, 67; 59, 68; 59, 69; 60, 70; 62, 71; 62, 72; 63, 73; 65, 74; 67, 75; 73, 76; 73, 77; 74, 78; 74, 79; 76, 80; 76, 81; 77, 82; 79, 83 | def get_analyses_at(self, slot):
"""Returns the list of analyses assigned to the slot passed in, sorted by
the positions they have within the slot.
:param slot: the slot where the analyses are located
:type slot: int
:return: a list of analyses
"""
# ensure we have an integer
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; 1, function_definition; 2, function_name:rejectionOptionsList; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, comment:# RejectionReasons will return something like:; 10, comment:# [{'checkbox': u'on', 'textfield-2': u'b', 'textfield-1': u'c', 'textfield-0': u'a'}]; 11, if_statement; 12, expression_statement; 13, if_statement; 14, comment:# Building the list with the values only because the keys are not needed any more; 15, expression_statement; 16, for_statement; 17, return_statement; 18, string:"Return a sorted list with the options defined in bikasetup"; 19, assignment; 20, assignment; 21, comparison_operator:len(settings.RejectionReasons) > 0; 22, block; 23, else_clause; 24, assignment; 25, comparison_operator:'checkbox' in sorted_keys; 26, block; 27, assignment; 28, identifier:key; 29, identifier:sorted_keys; 30, block; 31, identifier:items; 32, identifier:plone; 33, call; 34, identifier:settings; 35, attribute; 36, call; 37, integer:0; 38, expression_statement; 39, block; 40, identifier:sorted_keys; 41, call; 42, string; 43, identifier:sorted_keys; 44, expression_statement; 45, identifier:items; 46, list; 47, expression_statement; 48, identifier:getSite; 49, argument_list; 50, identifier:plone; 51, identifier:bika_setup; 52, identifier:len; 53, argument_list; 54, assignment; 55, return_statement; 56, identifier:sorted; 57, argument_list; 58, string_content:checkbox; 59, call; 60, call; 61, attribute; 62, identifier:reject_reasons; 63, subscript; 64, list; 65, call; 66, attribute; 67, argument_list; 68, attribute; 69, argument_list; 70, identifier:settings; 71, identifier:RejectionReasons; 72, attribute; 73, integer:0; 74, attribute; 75, argument_list; 76, identifier:sorted_keys; 77, identifier:remove; 78, string; 79, identifier:items; 80, identifier:append; 81, call; 82, identifier:settings; 83, identifier:RejectionReasons; 84, identifier:reject_reasons; 85, identifier:keys; 86, string_content:checkbox; 87, attribute; 88, argument_list; 89, subscript; 90, identifier:strip; 91, identifier:reject_reasons; 92, identifier:key | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 6, 18; 7, 19; 8, 20; 11, 21; 11, 22; 11, 23; 12, 24; 13, 25; 13, 26; 15, 27; 16, 28; 16, 29; 16, 30; 17, 31; 19, 32; 19, 33; 20, 34; 20, 35; 21, 36; 21, 37; 22, 38; 23, 39; 24, 40; 24, 41; 25, 42; 25, 43; 26, 44; 27, 45; 27, 46; 30, 47; 33, 48; 33, 49; 35, 50; 35, 51; 36, 52; 36, 53; 38, 54; 39, 55; 41, 56; 41, 57; 42, 58; 44, 59; 47, 60; 53, 61; 54, 62; 54, 63; 55, 64; 57, 65; 59, 66; 59, 67; 60, 68; 60, 69; 61, 70; 61, 71; 63, 72; 63, 73; 65, 74; 65, 75; 66, 76; 66, 77; 67, 78; 68, 79; 68, 80; 69, 81; 72, 82; 72, 83; 74, 84; 74, 85; 78, 86; 81, 87; 81, 88; 87, 89; 87, 90; 89, 91; 89, 92 | def rejectionOptionsList(self):
"Return a sorted list with the options defined in bikasetup"
plone = getSite()
settings = plone.bika_setup
# RejectionReasons will return something like:
# [{'checkbox': u'on', 'textfield-2': u'b', 'textfield-1': u'c', 'textfield-0': u'a'}]
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')
# Building the list with the values only because the keys are not needed any more
items = []
for key in sorted_keys:
items.append(reject_reasons[key].strip())
return items |
0, module; 1, function_definition; 2, function_name:_get_sorted_cond_keys; 3, parameters; 4, block; 5, identifier:self; 6, identifier:keys_list; 7, expression_statement; 8, comment:# The names can be found in reflexrulewidget.pt inside the; 9, comment:# conditionscontainer div.; 10, expression_statement; 11, for_statement; 12, expression_statement; 13, return_statement; 14, comment:"""
This function returns only the elements starting with
'analysisservice-' in 'keys_list'. The returned list is sorted by the
index appended to the end of each element
"""; 15, assignment; 16, identifier:key; 17, identifier:keys_list; 18, block; 19, call; 20, identifier:cond_list; 21, identifier:cond_list; 22, list; 23, if_statement; 24, attribute; 25, argument_list; 26, call; 27, block; 28, identifier:cond_list; 29, identifier:sort; 30, attribute; 31, argument_list; 32, expression_statement; 33, identifier:key; 34, identifier:startswith; 35, string; 36, call; 37, string_content:analysisservice-; 38, attribute; 39, argument_list; 40, identifier:cond_list; 41, identifier:append; 42, identifier:key | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 10, 15; 11, 16; 11, 17; 11, 18; 12, 19; 13, 20; 15, 21; 15, 22; 18, 23; 19, 24; 19, 25; 23, 26; 23, 27; 24, 28; 24, 29; 26, 30; 26, 31; 27, 32; 30, 33; 30, 34; 31, 35; 32, 36; 35, 37; 36, 38; 36, 39; 38, 40; 38, 41; 39, 42 | def _get_sorted_cond_keys(self, keys_list):
"""
This function returns only the elements starting with
'analysisservice-' in 'keys_list'. The returned list is sorted by the
index appended to the end of each element
"""
# The names can be found in reflexrulewidget.pt inside the
# conditionscontainer div.
cond_list = []
for key in keys_list:
if key.startswith('analysisservice-'):
cond_list.append(key)
cond_list.sort()
return cond_list |
0, module; 1, function_definition; 2, function_name:_get_sorted_action_keys; 3, parameters; 4, block; 5, identifier:self; 6, identifier:keys_list; 7, expression_statement; 8, comment:# The names can be found in reflexrulewidget.pt inside the; 9, comment:# Reflex action rules list section.; 10, expression_statement; 11, for_statement; 12, expression_statement; 13, return_statement; 14, comment:"""
This function returns only the elements starting with 'action-' in
'keys_list'. The returned list is sorted by the index appended to
the end of each element
"""; 15, assignment; 16, identifier:key; 17, identifier:keys_list; 18, block; 19, call; 20, identifier:action_list; 21, identifier:action_list; 22, list; 23, if_statement; 24, attribute; 25, argument_list; 26, call; 27, block; 28, identifier:action_list; 29, identifier:sort; 30, attribute; 31, argument_list; 32, expression_statement; 33, identifier:key; 34, identifier:startswith; 35, string; 36, call; 37, string_content:action-; 38, attribute; 39, argument_list; 40, identifier:action_list; 41, identifier:append; 42, identifier:key | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 10, 15; 11, 16; 11, 17; 11, 18; 12, 19; 13, 20; 15, 21; 15, 22; 18, 23; 19, 24; 19, 25; 23, 26; 23, 27; 24, 28; 24, 29; 26, 30; 26, 31; 27, 32; 30, 33; 30, 34; 31, 35; 32, 36; 35, 37; 36, 38; 36, 39; 38, 40; 38, 41; 39, 42 | def _get_sorted_action_keys(self, keys_list):
"""
This function returns only the elements starting with 'action-' in
'keys_list'. The returned list is sorted by the index appended to
the end of each element
"""
# The names can be found in reflexrulewidget.pt inside the
# Reflex action rules list section.
action_list = []
for key in keys_list:
if key.startswith('action-'):
action_list.append(key)
action_list.sort()
return action_list |
0, module; 1, function_definition; 2, function_name:getLinkedRequests; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, comment:# fetch the objects by UID and handle nonexisting UIDs gracefully; 10, expression_statement; 11, comment:# filter out None values (nonexisting UIDs); 12, expression_statement; 13, comment:# sort by physical path, so that attachments coming from an AR with a; 14, comment:# higher "-Rn" suffix get sorted correctly.; 15, comment:# N.B. the created date is the same, hence we can not use it; 16, return_statement; 17, comment:"""Lookup linked Analysis Requests
:returns: sorted list of ARs, where the latest AR comes first
"""; 18, assignment; 19, assignment; 20, assignment; 21, assignment; 22, call; 23, identifier:rc; 24, call; 25, identifier:refs; 26, call; 27, identifier:ars; 28, call; 29, identifier:ars; 30, call; 31, identifier:sorted; 32, argument_list; 33, attribute; 34, argument_list; 35, attribute; 36, argument_list; 37, identifier:map; 38, argument_list; 39, identifier:filter; 40, argument_list; 41, identifier:ars; 42, keyword_argument; 43, keyword_argument; 44, identifier:api; 45, identifier:get_tool; 46, string:"reference_catalog"; 47, identifier:rc; 48, identifier:getBackReferences; 49, identifier:self; 50, string:"AnalysisRequestAttachment"; 51, lambda; 52, identifier:refs; 53, None; 54, identifier:ars; 55, identifier:key; 56, attribute; 57, identifier:reverse; 58, True; 59, lambda_parameters; 60, call; 61, identifier:api; 62, identifier:get_path; 63, identifier:ref; 64, attribute; 65, argument_list; 66, identifier:api; 67, identifier:get_object_by_uid; 68, attribute; 69, None; 70, identifier:ref; 71, identifier:sourceUID | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 6, 17; 7, 18; 8, 19; 10, 20; 12, 21; 16, 22; 18, 23; 18, 24; 19, 25; 19, 26; 20, 27; 20, 28; 21, 29; 21, 30; 22, 31; 22, 32; 24, 33; 24, 34; 26, 35; 26, 36; 28, 37; 28, 38; 30, 39; 30, 40; 32, 41; 32, 42; 32, 43; 33, 44; 33, 45; 34, 46; 35, 47; 35, 48; 36, 49; 36, 50; 38, 51; 38, 52; 40, 53; 40, 54; 42, 55; 42, 56; 43, 57; 43, 58; 51, 59; 51, 60; 56, 61; 56, 62; 59, 63; 60, 64; 60, 65; 64, 66; 64, 67; 65, 68; 65, 69; 68, 70; 68, 71 | def getLinkedRequests(self):
"""Lookup linked Analysis Requests
:returns: sorted list of ARs, where the latest AR comes first
"""
rc = api.get_tool("reference_catalog")
refs = rc.getBackReferences(self, "AnalysisRequestAttachment")
# fetch the objects by UID and handle nonexisting UIDs gracefully
ars = map(lambda ref: api.get_object_by_uid(ref.sourceUID, None), refs)
# filter out None values (nonexisting UIDs)
ars = filter(None, ars)
# sort by physical path, so that attachments coming from an AR with a
# higher "-Rn" suffix get sorted correctly.
# N.B. the created date is the same, hence we can not use it
return sorted(ars, key=api.get_path, reverse=True) |
0, module; 1, function_definition; 2, function_name:getLinkedAnalyses; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, comment:# Fetch the linked Analyses UIDs; 8, expression_statement; 9, comment:# fetch the objects by UID and handle nonexisting UIDs gracefully; 10, expression_statement; 11, comment:# filter out None values (nonexisting UIDs); 12, expression_statement; 13, comment:# sort by physical path, so that attachments coming from an AR with a; 14, comment:# higher "-Rn" suffix get sorted correctly.; 15, comment:# N.B. the created date is the same, hence we can not use it; 16, return_statement; 17, comment:"""Lookup linked Analyses
:returns: sorted list of ANs, where the latest AN comes first
"""; 18, assignment; 19, assignment; 20, assignment; 21, call; 22, identifier:refs; 23, call; 24, identifier:ans; 25, call; 26, identifier:ans; 27, call; 28, identifier:sorted; 29, argument_list; 30, identifier:get_backreferences; 31, argument_list; 32, identifier:map; 33, argument_list; 34, identifier:filter; 35, argument_list; 36, identifier:ans; 37, keyword_argument; 38, keyword_argument; 39, identifier:self; 40, string:"AnalysisAttachment"; 41, lambda; 42, identifier:refs; 43, None; 44, identifier:ans; 45, identifier:key; 46, attribute; 47, identifier:reverse; 48, True; 49, lambda_parameters; 50, call; 51, identifier:api; 52, identifier:get_path; 53, identifier:uid; 54, attribute; 55, argument_list; 56, identifier:api; 57, identifier:get_object_by_uid; 58, identifier:uid; 59, None | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 6, 17; 8, 18; 10, 19; 12, 20; 16, 21; 18, 22; 18, 23; 19, 24; 19, 25; 20, 26; 20, 27; 21, 28; 21, 29; 23, 30; 23, 31; 25, 32; 25, 33; 27, 34; 27, 35; 29, 36; 29, 37; 29, 38; 31, 39; 31, 40; 33, 41; 33, 42; 35, 43; 35, 44; 37, 45; 37, 46; 38, 47; 38, 48; 41, 49; 41, 50; 46, 51; 46, 52; 49, 53; 50, 54; 50, 55; 54, 56; 54, 57; 55, 58; 55, 59 | def getLinkedAnalyses(self):
"""Lookup linked Analyses
:returns: sorted list of ANs, where the latest AN comes first
"""
# Fetch the linked Analyses UIDs
refs = get_backreferences(self, "AnalysisAttachment")
# fetch the objects by UID and handle nonexisting UIDs gracefully
ans = map(lambda uid: api.get_object_by_uid(uid, None), refs)
# filter out None values (nonexisting UIDs)
ans = filter(None, ans)
# sort by physical path, so that attachments coming from an AR with a
# higher "-Rn" suffix get sorted correctly.
# N.B. the created date is the same, hence we can not use it
return sorted(ans, key=api.get_path, reverse=True) |
0, module; 1, function_definition; 2, function_name:get_sorted_fields; 3, parameters; 4, block; 5, identifier:self; 6, expression_statement; 7, expression_statement; 8, expression_statement; 9, function_definition; 10, return_statement; 11, comment:"""Return the sorted fields
"""; 12, assignment; 13, assignment; 14, function_name:field_cmp; 15, parameters; 16, block; 17, call; 18, identifier:inf; 19, call; 20, identifier:order; 21, call; 22, identifier:field1; 23, identifier:field2; 24, expression_statement; 25, expression_statement; 26, expression_statement; 27, expression_statement; 28, return_statement; 29, identifier:sorted; 30, argument_list; 31, identifier:float; 32, argument_list; 33, attribute; 34, argument_list; 35, assignment; 36, assignment; 37, assignment; 38, assignment; 39, call; 40, call; 41, keyword_argument; 42, string:"inf"; 43, identifier:self; 44, identifier:get_field_order; 45, identifier:_n1; 46, call; 47, identifier:_n2; 48, call; 49, identifier:_i1; 50, boolean_operator; 51, identifier:_i2; 52, boolean_operator; 53, identifier:cmp; 54, argument_list; 55, attribute; 56, argument_list; 57, identifier:cmp; 58, identifier:field_cmp; 59, attribute; 60, argument_list; 61, attribute; 62, argument_list; 63, boolean_operator; 64, identifier:inf; 65, boolean_operator; 66, identifier:inf; 67, identifier:_i1; 68, identifier:_i2; 69, identifier:self; 70, identifier:get_fields; 71, identifier:field1; 72, identifier:getName; 73, identifier:field2; 74, identifier:getName; 75, comparison_operator:_n1 in order; 76, binary_operator:order.index(_n1) + 1; 77, comparison_operator:_n2 in order; 78, binary_operator:order.index(_n2) + 1; 79, identifier:_n1; 80, identifier:order; 81, call; 82, integer:1; 83, identifier:_n2; 84, identifier:order; 85, call; 86, integer:1; 87, attribute; 88, argument_list; 89, attribute; 90, argument_list; 91, identifier:order; 92, identifier:index; 93, identifier:_n1; 94, identifier:order; 95, identifier:index; 96, identifier:_n2 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 4, 6; 4, 7; 4, 8; 4, 9; 4, 10; 6, 11; 7, 12; 8, 13; 9, 14; 9, 15; 9, 16; 10, 17; 12, 18; 12, 19; 13, 20; 13, 21; 15, 22; 15, 23; 16, 24; 16, 25; 16, 26; 16, 27; 16, 28; 17, 29; 17, 30; 19, 31; 19, 32; 21, 33; 21, 34; 24, 35; 25, 36; 26, 37; 27, 38; 28, 39; 30, 40; 30, 41; 32, 42; 33, 43; 33, 44; 35, 45; 35, 46; 36, 47; 36, 48; 37, 49; 37, 50; 38, 51; 38, 52; 39, 53; 39, 54; 40, 55; 40, 56; 41, 57; 41, 58; 46, 59; 46, 60; 48, 61; 48, 62; 50, 63; 50, 64; 52, 65; 52, 66; 54, 67; 54, 68; 55, 69; 55, 70; 59, 71; 59, 72; 61, 73; 61, 74; 63, 75; 63, 76; 65, 77; 65, 78; 75, 79; 75, 80; 76, 81; 76, 82; 77, 83; 77, 84; 78, 85; 78, 86; 81, 87; 81, 88; 85, 89; 85, 90; 87, 91; 87, 92; 88, 93; 89, 94; 89, 95; 90, 96 | def get_sorted_fields(self):
"""Return the sorted fields
"""
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; 1, function_definition; 2, function_name:resolve_sorting; 3, parameters; 4, block; 5, identifier:self; 6, identifier:query; 7, expression_statement; 8, expression_statement; 9, comment:# Sort on; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, if_statement; 14, return_statement; 15, comment:"""Resolves the sorting criteria for the given query
"""; 16, assignment; 17, assignment; 18, assignment; 19, assignment; 20, identifier:sort_on; 21, block; 22, identifier:sorting; 23, identifier:sorting; 24, dictionary; 25, identifier:sort_on; 26, call; 27, identifier:sort_on; 28, boolean_operator; 29, identifier:sort_on; 30, boolean_operator; 31, expression_statement; 32, comment:# Sort order; 33, expression_statement; 34, expression_statement; 35, if_statement; 36, comment:# Sort limit; 37, expression_statement; 38, if_statement; 39, attribute; 40, argument_list; 41, identifier:sort_on; 42, call; 43, boolean_operator; 44, identifier:sort_on; 45, assignment; 46, assignment; 47, assignment; 48, comparison_operator:sort_order in ["desc", "reverse", "rev", "descending"]; 49, block; 50, else_clause; 51, assignment; 52, identifier:sort_limit; 53, block; 54, identifier:query; 55, identifier:get; 56, string:"sidx"; 57, None; 58, attribute; 59, argument_list; 60, comparison_operator:sort_on == "Title"; 61, string:"sortable_title"; 62, subscript; 63, identifier:sort_on; 64, identifier:sort_order; 65, call; 66, identifier:sort_order; 67, boolean_operator; 68, identifier:sort_order; 69, list; 70, expression_statement; 71, block; 72, identifier:sort_limit; 73, call; 74, expression_statement; 75, identifier:query; 76, identifier:get; 77, string:"sort_on"; 78, None; 79, identifier:sort_on; 80, string:"Title"; 81, identifier:sorting; 82, string:"sort_on"; 83, attribute; 84, argument_list; 85, identifier:sort_order; 86, call; 87, string:"desc"; 88, string:"reverse"; 89, string:"rev"; 90, string:"descending"; 91, assignment; 92, expression_statement; 93, attribute; 94, argument_list; 95, assignment; 96, identifier:query; 97, identifier:get; 98, string:"sord"; 99, None; 100, attribute; 101, argument_list; 102, subscript; 103, string:"descending"; 104, assignment; 105, identifier:api; 106, identifier:to_int; 107, call; 108, keyword_argument; 109, subscript; 110, identifier:sort_limit; 111, identifier:query; 112, identifier:get; 113, string:"sort_order"; 114, None; 115, identifier:sorting; 116, string:"sort_order"; 117, subscript; 118, string:"ascending"; 119, attribute; 120, argument_list; 121, identifier:default; 122, integer:30; 123, identifier:sorting; 124, string:"sort_limit"; 125, identifier:sorting; 126, string:"sort_order"; 127, identifier:query; 128, identifier:get; 129, string:"limit"; 130, integer:30 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 7, 15; 8, 16; 10, 17; 11, 18; 12, 19; 13, 20; 13, 21; 14, 22; 16, 23; 16, 24; 17, 25; 17, 26; 18, 27; 18, 28; 19, 29; 19, 30; 21, 31; 21, 32; 21, 33; 21, 34; 21, 35; 21, 36; 21, 37; 21, 38; 26, 39; 26, 40; 28, 41; 28, 42; 30, 43; 30, 44; 31, 45; 33, 46; 34, 47; 35, 48; 35, 49; 35, 50; 37, 51; 38, 52; 38, 53; 39, 54; 39, 55; 40, 56; 40, 57; 42, 58; 42, 59; 43, 60; 43, 61; 45, 62; 45, 63; 46, 64; 46, 65; 47, 66; 47, 67; 48, 68; 48, 69; 49, 70; 50, 71; 51, 72; 51, 73; 53, 74; 58, 75; 58, 76; 59, 77; 59, 78; 60, 79; 60, 80; 62, 81; 62, 82; 65, 83; 65, 84; 67, 85; 67, 86; 69, 87; 69, 88; 69, 89; 69, 90; 70, 91; 71, 92; 73, 93; 73, 94; 74, 95; 83, 96; 83, 97; 84, 98; 84, 99; 86, 100; 86, 101; 91, 102; 91, 103; 92, 104; 93, 105; 93, 106; 94, 107; 94, 108; 95, 109; 95, 110; 100, 111; 100, 112; 101, 113; 101, 114; 102, 115; 102, 116; 104, 117; 104, 118; 107, 119; 107, 120; 108, 121; 108, 122; 109, 123; 109, 124; 117, 125; 117, 126; 119, 127; 119, 128; 120, 129; 120, 130 | def resolve_sorting(self, query):
"""Resolves the sorting criteria for the given query
"""
sorting = {}
# Sort on
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
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
sort_limit = api.to_int(query.get("limit", 30), default=30)
if sort_limit:
sorting["sort_limit"] = sort_limit
return sorting |
0, module; 1, function_definition; 2, function_name:is_sortable_index; 3, parameters; 4, block; 5, identifier:self; 6, identifier:index_name; 7, identifier:catalog; 8, expression_statement; 9, expression_statement; 10, if_statement; 11, return_statement; 12, comment:"""Returns whether the index is sortable
"""; 13, assignment; 14, not_operator; 15, block; 16, comparison_operator:index.meta_type in ["FieldIndex", "DateIndex"]; 17, identifier:index; 18, call; 19, identifier:index; 20, return_statement; 21, attribute; 22, list; 23, attribute; 24, argument_list; 25, False; 26, identifier:index; 27, identifier:meta_type; 28, string:"FieldIndex"; 29, string:"DateIndex"; 30, identifier:self; 31, identifier:get_index; 32, identifier:index_name; 33, identifier:catalog | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 8, 12; 9, 13; 10, 14; 10, 15; 11, 16; 13, 17; 13, 18; 14, 19; 15, 20; 16, 21; 16, 22; 18, 23; 18, 24; 20, 25; 21, 26; 21, 27; 22, 28; 22, 29; 23, 30; 23, 31; 24, 32; 24, 33 | def is_sortable_index(self, index_name, catalog):
"""Returns whether the index is sortable
"""
index = self.get_index(index_name, catalog)
if not index:
return False
return index.meta_type in ["FieldIndex", "DateIndex"] |
0, module; 1, function_definition; 2, function_name:sortable_title; 3, parameters; 4, block; 5, identifier:portal; 6, identifier:title; 7, expression_statement; 8, if_statement; 9, expression_statement; 10, expression_statement; 11, comment:# Replace numbers with zero filled numbers; 12, expression_statement; 13, comment:# Truncate to prevent bloat; 14, for_statement; 15, return_statement; 16, comment:"""Convert title to sortable title
"""; 17, not_operator; 18, block; 19, assignment; 20, assignment; 21, assignment; 22, identifier:charset; 23, list; 24, block; 25, identifier:sortabletitle; 26, identifier:title; 27, return_statement; 28, identifier:def_charset; 29, call; 30, identifier:sortabletitle; 31, call; 32, identifier:sortabletitle; 33, call; 34, identifier:def_charset; 35, string; 36, string; 37, try_statement; 38, string; 39, attribute; 40, argument_list; 41, identifier:str; 42, argument_list; 43, attribute; 44, argument_list; 45, string_content:latin-1; 46, string_content:utf-8; 47, block; 48, except_clause; 49, except_clause; 50, attribute; 51, identifier:getSiteEncoding; 52, call; 53, identifier:num_sort_regex; 54, identifier:sub; 55, identifier:zero_fill; 56, identifier:sortabletitle; 57, expression_statement; 58, expression_statement; 59, break_statement; 60, identifier:UnicodeError; 61, block; 62, identifier:TypeError; 63, comment:# If we get a TypeError if we already have a unicode string; 64, block; 65, identifier:portal; 66, identifier:plone_utils; 67, attribute; 68, argument_list; 69, assignment; 70, assignment; 71, pass_statement; 72, expression_statement; 73, break_statement; 74, call; 75, identifier:strip; 76, identifier:sortabletitle; 77, subscript; 78, identifier:sortabletitle; 79, call; 80, assignment; 81, attribute; 82, argument_list; 83, call; 84, slice; 85, attribute; 86, argument_list; 87, identifier:sortabletitle; 88, subscript; 89, identifier:title; 90, identifier:lower; 91, identifier:safe_unicode; 92, argument_list; 93, integer:30; 94, identifier:sortabletitle; 95, identifier:encode; 96, boolean_operator; 97, identifier:sortabletitle; 98, slice; 99, identifier:sortabletitle; 100, identifier:charset; 101, identifier:def_charset; 102, string; 103, integer:30; 104, string_content:utf-8 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 7, 16; 8, 17; 8, 18; 9, 19; 10, 20; 12, 21; 14, 22; 14, 23; 14, 24; 15, 25; 17, 26; 18, 27; 19, 28; 19, 29; 20, 30; 20, 31; 21, 32; 21, 33; 23, 34; 23, 35; 23, 36; 24, 37; 27, 38; 29, 39; 29, 40; 31, 41; 31, 42; 33, 43; 33, 44; 35, 45; 36, 46; 37, 47; 37, 48; 37, 49; 39, 50; 39, 51; 42, 52; 43, 53; 43, 54; 44, 55; 44, 56; 47, 57; 47, 58; 47, 59; 48, 60; 48, 61; 49, 62; 49, 63; 49, 64; 50, 65; 50, 66; 52, 67; 52, 68; 57, 69; 58, 70; 61, 71; 64, 72; 64, 73; 67, 74; 67, 75; 69, 76; 69, 77; 70, 78; 70, 79; 72, 80; 74, 81; 74, 82; 77, 83; 77, 84; 79, 85; 79, 86; 80, 87; 80, 88; 81, 89; 81, 90; 83, 91; 83, 92; 84, 93; 85, 94; 85, 95; 86, 96; 88, 97; 88, 98; 92, 99; 92, 100; 96, 101; 96, 102; 98, 103; 102, 104 | def sortable_title(portal, title):
"""Convert title to sortable title
"""
if not title:
return ''
def_charset = portal.plone_utils.getSiteEncoding()
sortabletitle = str(title.lower().strip())
# Replace numbers with zero filled numbers
sortabletitle = num_sort_regex.sub(zero_fill, sortabletitle)
# Truncate to prevent bloat
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:
# If we get a TypeError if we already have a unicode string
sortabletitle = sortabletitle[:30]
break
return sortabletitle |
0, module; 1, function_definition; 2, function_name:_sort_column; 3, parameters; 4, block; 5, identifier:self; 6, identifier:column; 7, identifier:reverse; 8, expression_statement; 9, if_statement; 10, comment:# get list of (value, item) tuple where value is the value in column for the item; 11, expression_statement; 12, comment:# sort list using the column type; 13, expression_statement; 14, comment:# reorder items; 15, for_statement; 16, comment:# reverse sorting direction for the next time; 17, expression_statement; 18, comment:"""Sort a column by its values"""; 19, comparison_operator:tk.DISABLED in self.state(); 20, block; 21, assignment; 22, call; 23, pattern_list; 24, call; 25, block; 26, call; 27, attribute; 28, call; 29, return_statement; 30, identifier:l; 31, list_comprehension; 32, attribute; 33, argument_list; 34, identifier:index; 35, tuple_pattern; 36, identifier:enumerate; 37, argument_list; 38, expression_statement; 39, attribute; 40, argument_list; 41, identifier:tk; 42, identifier:DISABLED; 43, attribute; 44, argument_list; 45, tuple; 46, for_in_clause; 47, identifier:l; 48, identifier:sort; 49, keyword_argument; 50, keyword_argument; 51, identifier:val; 52, identifier:child; 53, identifier:l; 54, call; 55, identifier:self; 56, identifier:heading; 57, identifier:column; 58, keyword_argument; 59, identifier:self; 60, identifier:state; 61, call; 62, identifier:child; 63, identifier:child; 64, call; 65, identifier:reverse; 66, identifier:reverse; 67, identifier:key; 68, lambda; 69, attribute; 70, argument_list; 71, identifier:command; 72, lambda; 73, attribute; 74, argument_list; 75, attribute; 76, argument_list; 77, lambda_parameters; 78, call; 79, identifier:self; 80, identifier:move; 81, identifier:child; 82, string:""; 83, identifier:index; 84, call; 85, identifier:self; 86, identifier:set; 87, identifier:child; 88, identifier:column; 89, identifier:self; 90, identifier:get_children; 91, string; 92, identifier:x; 93, subscript; 94, argument_list; 95, attribute; 96, argument_list; 97, attribute; 98, identifier:column; 99, subscript; 100, identifier:self; 101, identifier:_sort_column; 102, identifier:column; 103, not_operator; 104, identifier:self; 105, identifier:_column_types; 106, identifier:x; 107, integer:0; 108, identifier:reverse | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 8, 18; 9, 19; 9, 20; 11, 21; 13, 22; 15, 23; 15, 24; 15, 25; 17, 26; 19, 27; 19, 28; 20, 29; 21, 30; 21, 31; 22, 32; 22, 33; 23, 34; 23, 35; 24, 36; 24, 37; 25, 38; 26, 39; 26, 40; 27, 41; 27, 42; 28, 43; 28, 44; 31, 45; 31, 46; 32, 47; 32, 48; 33, 49; 33, 50; 35, 51; 35, 52; 37, 53; 38, 54; 39, 55; 39, 56; 40, 57; 40, 58; 43, 59; 43, 60; 45, 61; 45, 62; 46, 63; 46, 64; 49, 65; 49, 66; 50, 67; 50, 68; 54, 69; 54, 70; 58, 71; 58, 72; 61, 73; 61, 74; 64, 75; 64, 76; 68, 77; 68, 78; 69, 79; 69, 80; 70, 81; 70, 82; 70, 83; 72, 84; 73, 85; 73, 86; 74, 87; 74, 88; 75, 89; 75, 90; 76, 91; 77, 92; 78, 93; 78, 94; 84, 95; 84, 96; 93, 97; 93, 98; 94, 99; 95, 100; 95, 101; 96, 102; 96, 103; 97, 104; 97, 105; 99, 106; 99, 107; 103, 108 | def _sort_column(self, column, reverse):
"""Sort a column by its values"""
if tk.DISABLED in self.state():
return
# get list of (value, item) tuple where value is the value in column for the item
l = [(self.set(child, column), child) for child in self.get_children('')]
# sort list using the column type
l.sort(reverse=reverse, key=lambda x: self._column_types[column](x[0]))
# reorder items
for index, (val, child) in enumerate(l):
self.move(child, "", index)
# reverse sorting direction for the next time
self.heading(column, command=lambda: self._sort_column(column, not reverse)) |
0, module; 1, function_definition; 2, function_name:column; 3, parameters; 4, block; 5, identifier:self; 6, identifier:column; 7, default_parameter; 8, dictionary_splat_pattern; 9, expression_statement; 10, expression_statement; 11, if_statement; 12, if_statement; 13, if_statement; 14, identifier:option; 15, None; 16, identifier:kw; 17, comment:"""
Query or modify the options for the specified column.
If `kw` is not given, returns a dict of the column option values. If
`option` is specified then the value for that option is returned.
Otherwise, sets the options to the corresponding values.
:param id: the column's identifier (read-only option)
:param anchor: "n", "ne", "e", "se", "s", "sw", "w", "nw", or "center":
alignment of the text in this column with respect to the cell
:param minwidth: minimum width of the column in pixels
:type minwidth: int
:param stretch: whether the column's width should be adjusted when the widget is resized
:type stretch: bool
:param width: width of the column in pixels
:type width: int
:param type: column's content type (for sorting), default type is `str`
:type type: type
"""; 18, assignment; 19, comparison_operator:option == 'type'; 20, block; 21, elif_clause; 22, identifier:kw; 23, block; 24, boolean_operator; 25, block; 26, elif_clause; 27, identifier:config; 28, False; 29, identifier:option; 30, string; 31, return_statement; 32, comparison_operator:'type' in kw; 33, block; 34, expression_statement; 35, identifier:kw; 36, identifier:option; 37, return_statement; 38, not_operator; 39, block; 40, string_content:type; 41, subscript; 42, string; 43, identifier:kw; 44, expression_statement; 45, expression_statement; 46, call; 47, call; 48, identifier:config; 49, expression_statement; 50, expression_statement; 51, return_statement; 52, attribute; 53, identifier:column; 54, string_content:type; 55, assignment; 56, assignment; 57, attribute; 58, argument_list; 59, attribute; 60, argument_list; 61, assignment; 62, assignment; 63, identifier:res; 64, identifier:self; 65, identifier:_column_types; 66, identifier:config; 67, True; 68, subscript; 69, call; 70, attribute; 71, identifier:column; 72, call; 73, identifier:option; 74, dictionary_splat; 75, attribute; 76, identifier:column; 77, identifier:self; 78, identifier:column; 79, identifier:option; 80, dictionary_splat; 81, identifier:res; 82, call; 83, subscript; 84, subscript; 85, attribute; 86, identifier:column; 87, attribute; 88, argument_list; 89, identifier:self; 90, identifier:_visual_drag; 91, attribute; 92, argument_list; 93, identifier:kw; 94, identifier:ttk; 95, identifier:Treeview; 96, identifier:kw; 97, attribute; 98, argument_list; 99, identifier:res; 100, string; 101, attribute; 102, identifier:column; 103, identifier:self; 104, identifier:_column_types; 105, identifier:kw; 106, identifier:pop; 107, string; 108, attribute; 109, identifier:column; 110, identifier:self; 111, identifier:column; 112, string; 113, attribute; 114, identifier:column; 115, identifier:self; 116, identifier:column; 117, identifier:option; 118, dictionary_splat; 119, string_content:type; 120, identifier:self; 121, identifier:_column_types; 122, string_content:type; 123, identifier:ttk; 124, identifier:Treeview; 125, string_content:id; 126, identifier:ttk; 127, identifier:Treeview; 128, identifier:kw | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 7, 14; 7, 15; 8, 16; 9, 17; 10, 18; 11, 19; 11, 20; 11, 21; 12, 22; 12, 23; 13, 24; 13, 25; 13, 26; 18, 27; 18, 28; 19, 29; 19, 30; 20, 31; 21, 32; 21, 33; 23, 34; 24, 35; 24, 36; 25, 37; 26, 38; 26, 39; 30, 40; 31, 41; 32, 42; 32, 43; 33, 44; 33, 45; 34, 46; 37, 47; 38, 48; 39, 49; 39, 50; 39, 51; 41, 52; 41, 53; 42, 54; 44, 55; 45, 56; 46, 57; 46, 58; 47, 59; 47, 60; 49, 61; 50, 62; 51, 63; 52, 64; 52, 65; 55, 66; 55, 67; 56, 68; 56, 69; 57, 70; 57, 71; 58, 72; 58, 73; 58, 74; 59, 75; 59, 76; 60, 77; 60, 78; 60, 79; 60, 80; 61, 81; 61, 82; 62, 83; 62, 84; 68, 85; 68, 86; 69, 87; 69, 88; 70, 89; 70, 90; 72, 91; 72, 92; 74, 93; 75, 94; 75, 95; 80, 96; 82, 97; 82, 98; 83, 99; 83, 100; 84, 101; 84, 102; 85, 103; 85, 104; 87, 105; 87, 106; 88, 107; 91, 108; 91, 109; 92, 110; 92, 111; 92, 112; 97, 113; 97, 114; 98, 115; 98, 116; 98, 117; 98, 118; 100, 119; 101, 120; 101, 121; 107, 122; 108, 123; 108, 124; 112, 125; 113, 126; 113, 127; 118, 128 | def column(self, column, option=None, **kw):
"""
Query or modify the options for the specified column.
If `kw` is not given, returns a dict of the column option values. If
`option` is specified then the value for that option is returned.
Otherwise, sets the options to the corresponding values.
:param id: the column's identifier (read-only option)
:param anchor: "n", "ne", "e", "se", "s", "sw", "w", "nw", or "center":
alignment of the text in this column with respect to the cell
:param minwidth: minimum width of the column in pixels
:type minwidth: int
:param stretch: whether the column's width should be adjusted when the widget is resized
:type stretch: bool
:param width: width of the column in pixels
:type width: int
:param type: column's content type (for sorting), default type is `str`
:type type: type
"""
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; 1, function_definition; 2, function_name:_config_sortable; 3, parameters; 4, block; 5, identifier:self; 6, identifier:sortable; 7, expression_statement; 8, for_statement; 9, expression_statement; 10, comment:"""Configure a new sortable state"""; 11, identifier:col; 12, subscript; 13, block; 14, assignment; 15, identifier:self; 16, string:"columns"; 17, expression_statement; 18, expression_statement; 19, attribute; 20, identifier:sortable; 21, assignment; 22, call; 23, identifier:self; 24, identifier:_sortable; 25, identifier:command; 26, conditional_expression:(lambda c=col: self._sort_column(c, True)) if sortable else ""; 27, attribute; 28, argument_list; 29, parenthesized_expression; 30, identifier:sortable; 31, string:""; 32, identifier:self; 33, identifier:heading; 34, identifier:col; 35, keyword_argument; 36, lambda; 37, identifier:command; 38, identifier:command; 39, lambda_parameters; 40, call; 41, default_parameter; 42, attribute; 43, argument_list; 44, identifier:c; 45, identifier:col; 46, identifier:self; 47, identifier:_sort_column; 48, identifier:c; 49, True | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 4, 7; 4, 8; 4, 9; 7, 10; 8, 11; 8, 12; 8, 13; 9, 14; 12, 15; 12, 16; 13, 17; 13, 18; 14, 19; 14, 20; 17, 21; 18, 22; 19, 23; 19, 24; 21, 25; 21, 26; 22, 27; 22, 28; 26, 29; 26, 30; 26, 31; 27, 32; 27, 33; 28, 34; 28, 35; 29, 36; 35, 37; 35, 38; 36, 39; 36, 40; 39, 41; 40, 42; 40, 43; 41, 44; 41, 45; 42, 46; 42, 47; 43, 48; 43, 49 | def _config_sortable(self, sortable):
"""Configure a new sortable state"""
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; 1, function_definition; 2, function_name:iter_items; 3, parameters; 4, block; 5, identifier:cls; 6, identifier:repo; 7, default_parameter; 8, expression_statement; 9, return_statement; 10, identifier:common_path; 11, None; 12, comment:"""Find all refs in the repository
:param repo: is the Repo
:param common_path:
Optional keyword argument to the path which is to be shared by all
returned Ref objects.
Defaults to class specific portion if None assuring that only
refs suitable for the actual class are returned.
:return:
git.SymbolicReference[], each of them is guaranteed to be a symbolic
ref which is not detached and pointing to a valid ref
List is lexicographically sorted
The returned objects represent actual subclasses, such as Head or TagReference"""; 13, generator_expression; 14, identifier:r; 15, for_in_clause; 16, if_clause; 17, identifier:r; 18, call; 19, boolean_operator; 20, attribute; 21, argument_list; 22, comparison_operator:r.__class__ == SymbolicReference; 23, not_operator; 24, identifier:cls; 25, identifier:_iter_items; 26, identifier:repo; 27, identifier:common_path; 28, attribute; 29, identifier:SymbolicReference; 30, attribute; 31, identifier:r; 32, identifier:__class__; 33, identifier:r; 34, identifier:is_detached | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 4, 8; 4, 9; 7, 10; 7, 11; 8, 12; 9, 13; 13, 14; 13, 15; 13, 16; 15, 17; 15, 18; 16, 19; 18, 20; 18, 21; 19, 22; 19, 23; 20, 24; 20, 25; 21, 26; 21, 27; 22, 28; 22, 29; 23, 30; 28, 31; 28, 32; 30, 33; 30, 34 | def iter_items(cls, repo, common_path=None):
"""Find all refs in the repository
:param repo: is the Repo
:param common_path:
Optional keyword argument to the path which is to be shared by all
returned Ref objects.
Defaults to class specific portion if None assuring that only
refs suitable for the actual class are returned.
:return:
git.SymbolicReference[], each of them is guaranteed to be a symbolic
ref which is not detached and pointing to a valid ref
List is lexicographically sorted
The returned objects represent actual subclasses, such as Head or TagReference"""
return (r for r in cls._iter_items(repo, common_path) if r.__class__ == SymbolicReference or not r.is_detached) |
0, module; 1, function_definition; 2, function_name:write_cache; 3, parameters; 4, block; 5, identifier:entries; 6, identifier:stream; 7, default_parameter; 8, default_parameter; 9, expression_statement; 10, comment:# wrap the stream into a compatible writer; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, comment:# header; 15, expression_statement; 16, expression_statement; 17, expression_statement; 18, comment:# body; 19, for_statement; 20, comment:# END for each entry; 21, comment:# write previously cached extensions data; 22, if_statement; 23, comment:# write the sha over the content; 24, expression_statement; 25, identifier:extension_data; 26, None; 27, identifier:ShaStreamCls; 28, identifier:IndexFileSHA1Writer; 29, comment:"""Write the cache represented by entries to a stream
:param entries: **sorted** list of entries
:param stream: stream to wrap into the AdapterStreamCls - it is used for
final output.
:param ShaStreamCls: Type to use when writing to the stream. It produces a sha
while writing to it, before the data is passed on to the wrapped stream
:param extension_data: any kind of data to write as a trailer, it must begin
a 4 byte identifier, followed by its size ( 4 bytes )"""; 30, assignment; 31, assignment; 32, assignment; 33, assignment; 34, call; 35, call; 36, identifier:entry; 37, identifier:entries; 38, block; 39, comparison_operator:extension_data is not None; 40, block; 41, call; 42, identifier:stream; 43, call; 44, identifier:tell; 45, attribute; 46, identifier:write; 47, attribute; 48, identifier:version; 49, integer:2; 50, identifier:write; 51, argument_list; 52, identifier:write; 53, argument_list; 54, expression_statement; 55, expression_statement; 56, comment:# ctime; 57, expression_statement; 58, comment:# mtime; 59, expression_statement; 60, expression_statement; 61, expression_statement; 62, comment:# path length; 63, assert_statement; 64, expression_statement; 65, comment:# clear possible previous values; 66, expression_statement; 67, expression_statement; 68, expression_statement; 69, expression_statement; 70, identifier:extension_data; 71, None; 72, expression_statement; 73, attribute; 74, argument_list; 75, identifier:ShaStreamCls; 76, argument_list; 77, identifier:stream; 78, identifier:tell; 79, identifier:stream; 80, identifier:write; 81, string:b"DIRC"; 82, call; 83, assignment; 84, call; 85, call; 86, assignment; 87, assignment; 88, assignment; 89, comparison_operator:plen == len(path); 90, binary_operator:"Path %s too long to fit into index" % entry[3]; 91, assignment; 92, call; 93, call; 94, assignment; 95, call; 96, call; 97, identifier:stream; 98, identifier:write_sha; 99, identifier:stream; 100, identifier:pack; 101, argument_list; 102, identifier:beginoffset; 103, call; 104, identifier:write; 105, argument_list; 106, identifier:write; 107, argument_list; 108, identifier:path; 109, subscript; 110, identifier:path; 111, call; 112, identifier:plen; 113, binary_operator:len(path) & CE_NAMEMASK; 114, identifier:plen; 115, call; 116, string:"Path %s too long to fit into index"; 117, subscript; 118, identifier:flags; 119, binary_operator:plen | (entry[2] & CE_NAMEMASK_INV); 120, identifier:write; 121, argument_list; 122, identifier:write; 123, argument_list; 124, identifier:real_size; 125, parenthesized_expression; 126, identifier:write; 127, argument_list; 128, attribute; 129, argument_list; 130, string:">LL"; 131, identifier:version; 132, call; 133, identifier:tell; 134, argument_list; 135, subscript; 136, subscript; 137, identifier:entry; 138, integer:3; 139, identifier:force_bytes; 140, argument_list; 141, call; 142, identifier:CE_NAMEMASK; 143, identifier:len; 144, argument_list; 145, identifier:entry; 146, integer:3; 147, identifier:plen; 148, parenthesized_expression; 149, call; 150, identifier:path; 151, binary_operator:(tell() - beginoffset + 8) & ~7; 152, binary_operator:b"\0" * ((beginoffset + real_size) - tell()); 153, identifier:stream; 154, identifier:write; 155, identifier:extension_data; 156, identifier:len; 157, argument_list; 158, identifier:entry; 159, integer:4; 160, identifier:entry; 161, integer:5; 162, identifier:path; 163, keyword_argument; 164, identifier:len; 165, argument_list; 166, identifier:path; 167, binary_operator:entry[2] & CE_NAMEMASK_INV; 168, identifier:pack; 169, argument_list; 170, parenthesized_expression; 171, unary_operator; 172, string:b"\0"; 173, parenthesized_expression; 174, identifier:entries; 175, identifier:encoding; 176, identifier:defenc; 177, identifier:path; 178, subscript; 179, identifier:CE_NAMEMASK_INV; 180, string:">LLLLLL20sH"; 181, subscript; 182, subscript; 183, subscript; 184, subscript; 185, subscript; 186, subscript; 187, subscript; 188, identifier:flags; 189, binary_operator:tell() - beginoffset + 8; 190, integer:7; 191, binary_operator:(beginoffset + real_size) - tell(); 192, identifier:entry; 193, integer:2; 194, identifier:entry; 195, integer:6; 196, identifier:entry; 197, integer:7; 198, identifier:entry; 199, integer:0; 200, identifier:entry; 201, integer:8; 202, identifier:entry; 203, integer:9; 204, identifier:entry; 205, integer:10; 206, identifier:entry; 207, integer:1; 208, binary_operator:tell() - beginoffset; 209, integer:8; 210, parenthesized_expression; 211, call; 212, call; 213, identifier:beginoffset; 214, binary_operator:beginoffset + real_size; 215, identifier:tell; 216, argument_list; 217, identifier:tell; 218, argument_list; 219, identifier:beginoffset; 220, identifier:real_size | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 4, 22; 4, 23; 4, 24; 7, 25; 7, 26; 8, 27; 8, 28; 9, 29; 11, 30; 12, 31; 13, 32; 15, 33; 16, 34; 17, 35; 19, 36; 19, 37; 19, 38; 22, 39; 22, 40; 24, 41; 30, 42; 30, 43; 31, 44; 31, 45; 32, 46; 32, 47; 33, 48; 33, 49; 34, 50; 34, 51; 35, 52; 35, 53; 38, 54; 38, 55; 38, 56; 38, 57; 38, 58; 38, 59; 38, 60; 38, 61; 38, 62; 38, 63; 38, 64; 38, 65; 38, 66; 38, 67; 38, 68; 38, 69; 39, 70; 39, 71; 40, 72; 41, 73; 41, 74; 43, 75; 43, 76; 45, 77; 45, 78; 47, 79; 47, 80; 51, 81; 53, 82; 54, 83; 55, 84; 57, 85; 59, 86; 60, 87; 61, 88; 63, 89; 63, 90; 64, 91; 66, 92; 67, 93; 68, 94; 69, 95; 72, 96; 73, 97; 73, 98; 76, 99; 82, 100; 82, 101; 83, 102; 83, 103; 84, 104; 84, 105; 85, 106; 85, 107; 86, 108; 86, 109; 87, 110; 87, 111; 88, 112; 88, 113; 89, 114; 89, 115; 90, 116; 90, 117; 91, 118; 91, 119; 92, 120; 92, 121; 93, 122; 93, 123; 94, 124; 94, 125; 95, 126; 95, 127; 96, 128; 96, 129; 101, 130; 101, 131; 101, 132; 103, 133; 103, 134; 105, 135; 107, 136; 109, 137; 109, 138; 111, 139; 111, 140; 113, 141; 113, 142; 115, 143; 115, 144; 117, 145; 117, 146; 119, 147; 119, 148; 121, 149; 123, 150; 125, 151; 127, 152; 128, 153; 128, 154; 129, 155; 132, 156; 132, 157; 135, 158; 135, 159; 136, 160; 136, 161; 140, 162; 140, 163; 141, 164; 141, 165; 144, 166; 148, 167; 149, 168; 149, 169; 151, 170; 151, 171; 152, 172; 152, 173; 157, 174; 163, 175; 163, 176; 165, 177; 167, 178; 167, 179; 169, 180; 169, 181; 169, 182; 169, 183; 169, 184; 169, 185; 169, 186; 169, 187; 169, 188; 170, 189; 171, 190; 173, 191; 178, 192; 178, 193; 181, 194; 181, 195; 182, 196; 182, 197; 183, 198; 183, 199; 184, 200; 184, 201; 185, 202; 185, 203; 186, 204; 186, 205; 187, 206; 187, 207; 189, 208; 189, 209; 191, 210; 191, 211; 208, 212; 208, 213; 210, 214; 211, 215; 211, 216; 212, 217; 212, 218; 214, 219; 214, 220 | def write_cache(entries, stream, extension_data=None, ShaStreamCls=IndexFileSHA1Writer):
"""Write the cache represented by entries to a stream
:param entries: **sorted** list of entries
:param stream: stream to wrap into the AdapterStreamCls - it is used for
final output.
:param ShaStreamCls: Type to use when writing to the stream. It produces a sha
while writing to it, before the data is passed on to the wrapped stream
:param extension_data: any kind of data to write as a trailer, it must begin
a 4 byte identifier, followed by its size ( 4 bytes )"""
# wrap the stream into a compatible writer
stream = ShaStreamCls(stream)
tell = stream.tell
write = stream.write
# header
version = 2
write(b"DIRC")
write(pack(">LL", version, len(entries)))
# body
for entry in entries:
beginoffset = tell()
write(entry[4]) # ctime
write(entry[5]) # mtime
path = entry[3]
path = force_bytes(path, encoding=defenc)
plen = len(path) & CE_NAMEMASK # path length
assert plen == len(path), "Path %s too long to fit into index" % entry[3]
flags = plen | (entry[2] & CE_NAMEMASK_INV) # clear possible previous values
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()))
# END for each entry
# write previously cached extensions data
if extension_data is not None:
stream.write(extension_data)
# write the sha over the content
stream.write_sha() |
0, module; 1, function_definition; 2, function_name:write_tree_from_cache; 3, parameters; 4, block; 5, identifier:entries; 6, identifier:odb; 7, identifier:sl; 8, default_parameter; 9, expression_statement; 10, expression_statement; 11, expression_statement; 12, expression_statement; 13, expression_statement; 14, while_statement; 15, comment:# END for each entry; 16, comment:# finally create the tree; 17, expression_statement; 18, expression_statement; 19, expression_statement; 20, expression_statement; 21, return_statement; 22, identifier:si; 23, integer:0; 24, comment:"""Create a tree from the given sorted list of entries and put the respective
trees into the given object database
:param entries: **sorted** list of IndexEntries
:param odb: object database to store the trees in
:param si: start index at which we should start creating subtrees
:param sl: slice indicating the range we should process on the entries list
:return: tuple(binsha, list(tree_entry, ...)) a tuple of a sha and a list of
tree entries being a tuple of hexsha, mode, name"""; 25, assignment; 26, assignment; 27, assignment; 28, assignment; 29, comparison_operator:ci < end; 30, block; 31, assignment; 32, call; 33, call; 34, assignment; 35, tuple; 36, identifier:tree_items; 37, list; 38, identifier:tree_items_append; 39, attribute; 40, identifier:ci; 41, attribute; 42, identifier:end; 43, attribute; 44, identifier:ci; 45, identifier:end; 46, expression_statement; 47, if_statement; 48, comment:# END abort on unmerged; 49, expression_statement; 50, expression_statement; 51, if_statement; 52, comment:# END handle bounds; 53, identifier:sio; 54, call; 55, identifier:tree_to_stream; 56, argument_list; 57, attribute; 58, argument_list; 59, identifier:istream; 60, call; 61, attribute; 62, identifier:tree_items; 63, identifier:tree_items; 64, identifier:append; 65, identifier:sl; 66, identifier:start; 67, identifier:sl; 68, identifier:stop; 69, assignment; 70, comparison_operator:entry.stage != 0; 71, block; 72, augmented_assignment; 73, assignment; 74, comparison_operator:rbound == -1; 75, comment:# its not a tree; 76, block; 77, else_clause; 78, identifier:BytesIO; 79, argument_list; 80, identifier:tree_items; 81, attribute; 82, identifier:sio; 83, identifier:seek; 84, integer:0; 85, attribute; 86, argument_list; 87, identifier:istream; 88, identifier:binsha; 89, identifier:entry; 90, subscript; 91, attribute; 92, integer:0; 93, raise_statement; 94, identifier:ci; 95, integer:1; 96, identifier:rbound; 97, call; 98, identifier:rbound; 99, unary_operator; 100, expression_statement; 101, comment:# find common base range; 102, block; 103, identifier:sio; 104, identifier:write; 105, identifier:odb; 106, identifier:store; 107, call; 108, identifier:entries; 109, identifier:ci; 110, identifier:entry; 111, identifier:stage; 112, call; 113, attribute; 114, argument_list; 115, integer:1; 116, call; 117, expression_statement; 118, expression_statement; 119, while_statement; 120, comment:# END find common base; 121, comment:# enter recursion; 122, comment:# ci - 1 as we want to count our current item as well; 123, expression_statement; 124, comment:# @UnusedVariable; 125, expression_statement; 126, comment:# skip ahead; 127, expression_statement; 128, identifier:IStream; 129, argument_list; 130, identifier:UnmergedEntriesError; 131, argument_list; 132, attribute; 133, identifier:find; 134, string; 135, identifier:si; 136, identifier:tree_items_append; 137, argument_list; 138, assignment; 139, assignment; 140, comparison_operator:xi < end; 141, block; 142, assignment; 143, call; 144, assignment; 145, identifier:str_tree_type; 146, call; 147, identifier:sio; 148, identifier:entry; 149, identifier:entry; 150, identifier:path; 151, string_content:/; 152, tuple; 153, identifier:base; 154, subscript; 155, identifier:xi; 156, identifier:ci; 157, identifier:xi; 158, identifier:end; 159, expression_statement; 160, expression_statement; 161, if_statement; 162, comment:# END abort on base mismatch; 163, expression_statement; 164, pattern_list; 165, call; 166, identifier:tree_items_append; 167, argument_list; 168, identifier:ci; 169, identifier:xi; 170, identifier:len; 171, argument_list; 172, attribute; 173, attribute; 174, subscript; 175, attribute; 176, slice; 177, assignment; 178, assignment; 179, boolean_operator; 180, block; 181, augmented_assignment; 182, identifier:sha; 183, identifier:tree_entry_list; 184, identifier:write_tree_from_cache; 185, argument_list; 186, tuple; 187, call; 188, identifier:entry; 189, identifier:binsha; 190, identifier:entry; 191, identifier:mode; 192, attribute; 193, slice; 194, identifier:entry; 195, identifier:path; 196, identifier:si; 197, identifier:rbound; 198, identifier:oentry; 199, subscript; 200, identifier:orbound; 201, call; 202, comparison_operator:orbound == -1; 203, comparison_operator:oentry.path[si:orbound] != base; 204, break_statement; 205, identifier:xi; 206, integer:1; 207, identifier:entries; 208, identifier:odb; 209, call; 210, binary_operator:rbound + 1; 211, identifier:sha; 212, identifier:S_IFDIR; 213, identifier:base; 214, attribute; 215, argument_list; 216, identifier:entry; 217, identifier:path; 218, identifier:si; 219, identifier:entries; 220, identifier:xi; 221, attribute; 222, argument_list; 223, identifier:orbound; 224, unary_operator; 225, subscript; 226, identifier:base; 227, identifier:slice; 228, argument_list; 229, identifier:rbound; 230, integer:1; 231, identifier:sio; 232, identifier:getvalue; 233, attribute; 234, identifier:find; 235, string; 236, identifier:si; 237, integer:1; 238, attribute; 239, slice; 240, binary_operator:ci - 1; 241, identifier:xi; 242, identifier:oentry; 243, identifier:path; 244, string_content:/; 245, identifier:oentry; 246, identifier:path; 247, identifier:si; 248, identifier:orbound; 249, identifier:ci; 250, integer:1 | 0, 1; 1, 2; 1, 3; 1, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, 9; 4, 10; 4, 11; 4, 12; 4, 13; 4, 14; 4, 15; 4, 16; 4, 17; 4, 18; 4, 19; 4, 20; 4, 21; 8, 22; 8, 23; 9, 24; 10, 25; 11, 26; 12, 27; 13, 28; 14, 29; 14, 30; 17, 31; 18, 32; 19, 33; 20, 34; 21, 35; 25, 36; 25, 37; 26, 38; 26, 39; 27, 40; 27, 41; 28, 42; 28, 43; 29, 44; 29, 45; 30, 46; 30, 47; 30, 48; 30, 49; 30, 50; 30, 51; 30, 52; 31, 53; 31, 54; 32, 55; 32, 56; 33, 57; 33, 58; 34, 59; 34, 60; 35, 61; 35, 62; 39, 63; 39, 64; 41, 65; 41, 66; 43, 67; 43, 68; 46, 69; 47, 70; 47, 71; 49, 72; 50, 73; 51, 74; 51, 75; 51, 76; 51, 77; 54, 78; 54, 79; 56, 80; 56, 81; 57, 82; 57, 83; 58, 84; 60, 85; 60, 86; 61, 87; 61, 88; 69, 89; 69, 90; 70, 91; 70, 92; 71, 93; 72, 94; 72, 95; 73, 96; 73, 97; 74, 98; 74, 99; 76, 100; 77, 101; 77, 102; 81, 103; 81, 104; 85, 105; 85, 106; 86, 107; 90, 108; 90, 109; 91, 110; 91, 111; 93, 112; 97, 113; 97, 114; 99, 115; 100, 116; 102, 117; 102, 118; 102, 119; 102, 120; 102, 121; 102, 122; 102, 123; 102, 124; 102, 125; 102, 126; 102, 127; 107, 128; 107, 129; 112, 130; 112, 131; 113, 132; 113, 133; 114, 134; 114, 135; 116, 136; 116, 137; 117, 138; 118, 139; 119, 140; 119, 141; 123, 142; 125, 143; 127, 144; 129, 145; 129, 146; 129, 147; 131, 148; 132, 149; 132, 150; 134, 151; 137, 152; 138, 153; 138, 154; 139, 155; 139, 156; 140, 157; 140, 158; 141, 159; 141, 160; 141, 161; 141, 162; 141, 163; 142, 164; 142, 165; 143, 166; 143, 167; 144, 168; 144, 169; 146, 170; 146, 171; 152, 172; 152, 173; 152, 174; 154, 175; 154, 176; 159, 177; 160, 178; 161, 179; 161, 180; 163, 181; 164, 182; 164, 183; 165, 184; 165, 185; 167, 186; 171, 187; 172, 188; 172, 189; 173, 190; 173, 191; 174, 192; 174, 193; 175, 194; 175, 195; 176, 196; 176, 197; 177, 198; 177, 199; 178, 200; 178, 201; 179, 202; 179, 203; 180, 204; 181, 205; 181, 206; 185, 207; 185, 208; 185, 209; 185, 210; 186, 211; 186, 212; 186, 213; 187, 214; 187, 215; 192, 216; 192, 217; 193, 218; 199, 219; 199, 220; 201, 221; 201, 222; 202, 223; 202, 224; 203, 225; 203, 226; 209, 227; 209, 228; 210, 229; 210, 230; 214, 231; 214, 232; 221, 233; 221, 234; 222, 235; 222, 236; 224, 237; 225, 238; 225, 239; 228, 240; 228, 241; 233, 242; 233, 243; 235, 244; 238, 245; 238, 246; 239, 247; 239, 248; 240, 249; 240, 250 | def write_tree_from_cache(entries, odb, sl, si=0):
"""Create a tree from the given sorted list of entries and put the respective
trees into the given object database
:param entries: **sorted** list of IndexEntries
:param odb: object database to store the trees in
:param si: start index at which we should start creating subtrees
:param sl: slice indicating the range we should process on the entries list
:return: tuple(binsha, list(tree_entry, ...)) a tuple of a sha and a list of
tree entries being a tuple of hexsha, mode, name"""
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)
# END abort on unmerged
ci += 1
rbound = entry.path.find('/', si)
if rbound == -1:
# its not a tree
tree_items_append((entry.binsha, entry.mode, entry.path[si:]))
else:
# find common base range
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
# END abort on base mismatch
xi += 1
# END find common base
# enter recursion
# ci - 1 as we want to count our current item as well
sha, tree_entry_list = write_tree_from_cache(entries, odb, slice(ci - 1, xi), rbound + 1) # @UnusedVariable
tree_items_append((sha, S_IFDIR, base))
# skip ahead
ci = xi
# END handle bounds
# END for each entry
# finally create the tree
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