Datasets:

kejian

/

codesearchnet-python-raw

like 1

[ "def", "define_laser_variables", "(", "Nl", ",", "real_amplitudes", "=", "False", ",", "variables", "=", "None", ")", ":", "if", "variables", "is", "None", ":", "E0", "=", "[", "Symbol", "(", "r\"E_0^\"", "+", "str", "(", "l", "+", "1", ")", ",", "real", "=", "real_amplitudes", ")", "for", "l", "in", "range", "(", "Nl", ")", "]", "else", ":", "E0", "=", "[", "Function", "(", "r\"E_0^\"", "+", "str", "(", "l", "+", "1", ")", ",", "real", "=", "real_amplitudes", ")", "(", "*", "variables", ")", "for", "l", "in", "range", "(", "Nl", ")", "]", "omega_laser", "=", "[", "Symbol", "(", "r\"varpi_\"", "+", "str", "(", "l", "+", "1", ")", ",", "positive", "=", "True", ")", "for", "l", "in", "range", "(", "Nl", ")", "]", "return", "E0", ",", "omega_laser" ]

[ "r", "Return", "the", "amplitudes", "and", "frequencies", "of", "Nl", "fields", "." ]

[ "def", "register", "(", "self", ")", ":", "if", "self", ".", "register_method", "==", "\"twine\"", ":", "self", ".", "register_by_twine", "(", ")", "if", "self", ".", "register_method", "==", "\"setup\"", ":", "self", ".", "register_by_setup", "(", ")", "if", "self", ".", "register_method", "==", "\"upload\"", ":", "self", ".", "upload", "(", ")" ]

[ "Register", "via", "the", "method", "configured", ":", "return", ":" ]

[ "def", "delta", "(", "data", ",", "width", "=", "9", ",", "order", "=", "1", ",", "axis", "=", "-", "1", ",", "mode", "=", "'interp'", ",", "*", "*", "kwargs", ")", ":", "data", "=", "np", ".", "atleast_1d", "(", "data", ")", "if", "mode", "==", "'interp'", "and", "width", ">", "data", ".", "shape", "[", "axis", "]", ":", "raise", "ParameterError", "(", "\"when mode='interp', width={} \"", "\"cannot exceed data.shape[axis]={}\"", ".", "format", "(", "width", ",", "data", ".", "shape", "[", "axis", "]", ")", ")", "if", "width", "<", "3", "or", "np", ".", "mod", "(", "width", ",", "2", ")", "!=", "1", ":", "raise", "ParameterError", "(", "'width must be an odd integer >= 3'", ")", "if", "order", "<=", "0", "or", "not", "isinstance", "(", "order", ",", "int", ")", ":", "raise", "ParameterError", "(", "'order must be a positive integer'", ")", "kwargs", ".", "pop", "(", "'deriv'", ",", "None", ")", "kwargs", ".", "setdefault", "(", "'polyorder'", ",", "order", ")", "return", "scipy", ".", "signal", ".", "savgol_filter", "(", "data", ",", "width", ",", "deriv", "=", "order", ",", "axis", "=", "axis", ",", "mode", "=", "mode", ",", "*", "*", "kwargs", ")" ]

[ "r", "Compute", "delta", "features", ":", "local", "estimate", "of", "the", "derivative", "of", "the", "input", "data", "along", "the", "selected", "axis", "." ]

[ "def", "update_command", "(", "self", ",", "resource_group_name", ",", "node_name", ",", "session", ",", "pssession", ",", "custom_headers", "=", "None", ",", "raw", "=", "False", ",", "polling", "=", "True", ",", "*", "*", "operation_config", ")", ":", "raw_result", "=", "self", ".", "_update_command_initial", "(", "resource_group_name", "=", "resource_group_name", ",", "node_name", "=", "node_name", ",", "session", "=", "session", ",", "pssession", "=", "pssession", ",", "custom_headers", "=", "custom_headers", ",", "raw", "=", "True", ",", "*", "*", "operation_config", ")", "def", "get_long_running_output", "(", "response", ")", ":", "deserialized", "=", "self", ".", "_deserialize", "(", "'PowerShellCommandResults'", ",", "response", ")", "if", "raw", ":", "client_raw_response", "=", "ClientRawResponse", "(", "deserialized", ",", "response", ")", "return", "client_raw_response", "return", "deserialized", "lro_delay", "=", "operation_config", ".", "get", "(", "'long_running_operation_timeout'", ",", "self", ".", "config", ".", "long_running_operation_timeout", ")", "if", "polling", "is", "True", ":", "polling_method", "=", "ARMPolling", "(", "lro_delay", ",", "*", "*", "operation_config", ")", "elif", "polling", "is", "False", ":", "polling_method", "=", "NoPolling", "(", ")", "else", ":", "polling_method", "=", "polling", "return", "LROPoller", "(", "self", ".", "_client", ",", "raw_result", ",", "get_long_running_output", ",", "polling_method", ")" ]

[ "Updates", "a", "running", "PowerShell", "command", "with", "more", "data", "." ]

[ "def", "_xml_escape", "(", "data", ")", ":", "# ampersand must be replaced first", "from_symbols", "=", "'&><\"\\''", "to_symbols", "=", "(", "'&'", "+", "s", "+", "';'", "for", "s", "in", "\"amp gt lt quot apos\"", ".", "split", "(", ")", ")", "for", "from_", ",", "to_", "in", "zip", "(", "from_symbols", ",", "to_symbols", ")", ":", "data", "=", "data", ".", "replace", "(", "from_", ",", "to_", ")", "return", "data" ]

[ "Escape", "&", "<", ">", "etc", ".", "in", "a", "string", "of", "data", "." ]

[ "def", "import_task_to_graph", "(", "diagram_graph", ",", "process_id", ",", "process_attributes", ",", "task_element", ")", ":", "BpmnDiagramGraphImport", ".", "import_activity_to_graph", "(", "diagram_graph", ",", "process_id", ",", "process_attributes", ",", "task_element", ")" ]

[ "Adds", "to", "graph", "the", "new", "element", "that", "represents", "BPMN", "task", ".", "In", "our", "representation", "tasks", "have", "only", "basic", "attributes", "and", "elements", "inherited", "from", "Activity", "type", "so", "this", "method", "only", "needs", "to", "call", "add_flownode_to_graph", "." ]

[ "def", "dispatch_hook", "(", "key", ",", "hooks", ",", "hook_data", ")", ":", "hooks", "=", "hooks", "or", "dict", "(", ")", "if", "key", "in", "hooks", ":", "try", ":", "return", "hooks", ".", "get", "(", "key", ")", ".", "__call__", "(", "hook_data", ")", "or", "hook_data", "except", "Exception", ",", "why", ":", "warnings", ".", "warn", "(", "str", "(", "why", ")", ")", "return", "hook_data" ]

[ "Dispatches", "a", "hook", "dictionary", "on", "a", "given", "piece", "of", "data", "." ]

[ "def", "_catch_errors", "(", "a_func", ",", "to_catch", ")", ":", "def", "inner", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "\"\"\"Wraps specified exceptions\"\"\"", "try", ":", "return", "a_func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "# pylint: disable=catching-non-exception", "except", "tuple", "(", "to_catch", ")", "as", "exception", ":", "utils", ".", "raise_with_traceback", "(", "gax", ".", "errors", ".", "create_error", "(", "'RPC failed'", ",", "cause", "=", "exception", ")", ")", "return", "inner" ]

[ "Updates", "a_func", "to", "wrap", "exceptions", "with", "GaxError" ]

[ "def", "get_datasource", "(", "name", ",", "orgname", "=", "None", ",", "profile", "=", "'grafana'", ")", ":", "data", "=", "get_datasources", "(", "orgname", "=", "orgname", ",", "profile", "=", "profile", ")", "for", "datasource", "in", "data", ":", "if", "datasource", "[", "'name'", "]", "==", "name", ":", "return", "datasource", "return", "None" ]

[ "Show", "a", "single", "datasource", "in", "an", "organisation", "." ]

[ "def", "_update_dprx", "(", "self", ")", ":", "if", "'beta'", "in", "self", ".", "freeparams", ":", "for", "r", "in", "range", "(", "self", ".", "nsites", ")", ":", "self", ".", "dprx", "[", "'beta'", "]", "[", "r", "]", "=", "self", ".", "prx", "[", "r", "]", "*", "(", "self", ".", "ln_pi_codon", "[", "r", "]", "-", "scipy", ".", "dot", "(", "self", ".", "ln_pi_codon", "[", "r", "]", ",", "self", ".", "prx", "[", "r", "]", ")", ")", "if", "'eta'", "in", "self", ".", "freeparams", ":", "boolterm", "=", "scipy", ".", "ndarray", "(", "N_CODON", ",", "dtype", "=", "'float'", ")", "with", "scipy", ".", "errstate", "(", "divide", "=", "'raise'", ",", "under", "=", "'raise'", ",", "over", "=", "'raise'", ",", "invalid", "=", "'raise'", ")", ":", "for", "i", "in", "range", "(", "N_NT", "-", "1", ")", ":", "boolterm", ".", "fill", "(", "0", ")", "for", "j", "in", "range", "(", "3", ")", ":", "boolterm", "+=", "(", "(", "i", "<=", "CODON_NT_INDEX", "[", "j", "]", ")", ".", "astype", "(", "'float'", ")", "/", "(", "self", ".", "eta", "[", "i", "]", "-", "(", "i", "==", "CODON_NT_INDEX", "[", "j", "]", ")", ".", "astype", "(", "'float'", ")", ")", ")", "for", "r", "in", "range", "(", "self", ".", "nsites", ")", ":", "self", ".", "dprx", "[", "'eta'", "]", "[", "i", "]", "[", "r", "]", "=", "self", ".", "prx", "[", "r", "]", "*", "(", "boolterm", "-", "scipy", ".", "dot", "(", "boolterm", ",", "self", ".", "prx", "[", "r", "]", ")", "/", "self", ".", "prx", "[", "r", "]", ".", "sum", "(", ")", ")" ]

[ "Update", "dprx", "." ]

[ "def", "_normalize_apis", "(", "apis", ")", ":", "result", "=", "list", "(", ")", "for", "api", "in", "apis", ":", "for", "normalized_method", "in", "SamApiProvider", ".", "_normalize_http_methods", "(", "api", ".", "method", ")", ":", "# _replace returns a copy of the namedtuple. This is the official way of creating copies of namedtuple", "result", ".", "append", "(", "api", ".", "_replace", "(", "method", "=", "normalized_method", ")", ")", "return", "result" ]

[ "Normalize", "the", "APIs", "to", "use", "standard", "method", "name" ]

[ "def", "build_compare_func", "(", "err_logger", "=", "None", ")", ":", "def", "compare_func", "(", "filename", ")", ":", "try", ":", "return", "os", ".", "path", ".", "getmtime", "(", "filename", ")", "except", "OSError", ":", "if", "err_logger", "is", "not", "None", ":", "err_logger", "(", "filename", ")", "return", "-", "1", "return", "compare_func" ]

[ "Returns", "a", "compare_func", "that", "can", "be", "passed", "to", "MTimeComparator", "." ]

[ "def", "_get_tr", "(", "cls", ",", "df", ")", ":", "prev_close", "=", "df", "[", "'close_-1_s'", "]", "high", "=", "df", "[", "'high'", "]", "low", "=", "df", "[", "'low'", "]", "c1", "=", "high", "-", "low", "c2", "=", "np", ".", "abs", "(", "high", "-", "prev_close", ")", "c3", "=", "np", ".", "abs", "(", "low", "-", "prev_close", ")", "df", "[", "'tr'", "]", "=", "np", ".", "max", "(", "(", "c1", ",", "c2", ",", "c3", ")", ",", "axis", "=", "0", ")" ]

[ "True", "Range", "of", "the", "trading", "tr", "=", "max", "[", "(", "high", "-", "low", ")", "abs", "(", "high", "-", "close_prev", ")", "abs", "(", "low", "-", "close_prev", ")", "]", ":", "param", "df", ":", "data", ":", "return", ":", "None" ]

[ "def", "gb_from_parameters", "(", "self", ",", "rotation_axis", ",", "rotation_angle", ",", "expand_times", "=", "4", ",", "vacuum_thickness", "=", "0.0", ",", "ab_shift", "=", "[", "0", ",", "0", "]", ",", "normal", "=", "False", ",", "ratio", "=", "None", ",", "plane", "=", "None", ",", "max_search", "=", "20", ",", "tol_coi", "=", "1.e-8", ",", "rm_ratio", "=", "0.7", ",", "quick_gen", "=", "False", ")", ":", "lat_type", "=", "self", ".", "lat_type", "# if the initial structure is primitive cell in cubic system,", "# calculate the transformation matrix from its conventional cell", "# to primitive cell, basically for bcc and fcc systems.", "trans_cry", "=", "np", ".", "eye", "(", "3", ")", "if", "lat_type", "==", "'c'", ":", "analyzer", "=", "SpacegroupAnalyzer", "(", "self", ".", "initial_structure", ")", "convention_cell", "=", "analyzer", ".", "get_conventional_standard_structure", "(", ")", "vol_ratio", "=", "self", ".", "initial_structure", ".", "volume", "/", "convention_cell", ".", "volume", "# bcc primitive cell, belong to cubic system", "if", "abs", "(", "vol_ratio", "-", "0.5", ")", "<", "1.e-3", ":", "trans_cry", "=", "np", ".", "array", "(", "[", "[", "0.5", ",", "0.5", ",", "-", "0.5", "]", ",", "[", "-", "0.5", ",", "0.5", ",", "0.5", "]", ",", "[", "0.5", ",", "-", "0.5", ",", "0.5", "]", "]", ")", "logger", ".", "info", "(", "\"Make sure this is for cubic with bcc primitive cell\"", ")", "# fcc primitive cell, belong to cubic system", "elif", "abs", "(", "vol_ratio", "-", "0.25", ")", "<", "1.e-3", ":", "trans_cry", "=", "np", ".", "array", "(", "[", "[", "0.5", ",", "0.5", ",", "0", "]", ",", "[", "0", ",", "0.5", ",", "0.5", "]", ",", "[", "0.5", ",", "0", ",", "0.5", "]", "]", ")", "logger", ".", "info", "(", "\"Make sure this is for cubic with fcc primitive cell\"", ")", "else", ":", "logger", ".", "info", "(", "\"Make sure this is for cubic with conventional cell\"", ")", "elif", "lat_type", "==", "'t'", ":", "logger", ".", "info", "(", "\"Make sure this is for tetragonal system\"", ")", "if", "ratio", "is", "None", ":", "logger", ".", "info", "(", "'Make sure this is for irrational c2/a2'", ")", "elif", "len", "(", "ratio", ")", "!=", "2", ":", "raise", "RuntimeError", "(", "'Tetragonal system needs correct c2/a2 ratio'", ")", "elif", "lat_type", "==", "'o'", ":", "logger", ".", "info", "(", "'Make sure this is for orthorhombic system'", ")", "if", "ratio", "is", "None", ":", "raise", "RuntimeError", "(", "'CSL does not exist if all axial ratios are irrational '", "'for an orthorhombic system'", ")", "elif", "len", "(", "ratio", ")", "!=", "3", ":", "raise", "RuntimeError", "(", "'Orthorhombic system needs correct c2:b2:a2 ratio'", ")", "elif", "lat_type", "==", "'h'", ":", "logger", ".", "info", "(", "'Make sure this is for hexagonal system'", ")", "if", "ratio", "is", "None", ":", "logger", ".", "info", "(", "'Make sure this is for irrational c2/a2'", ")", "elif", "len", "(", "ratio", ")", "!=", "2", ":", "raise", "RuntimeError", "(", "'Hexagonal system needs correct c2/a2 ratio'", ")", "elif", "lat_type", "==", "'r'", ":", "logger", ".", "info", "(", "'Make sure this is for rhombohedral system'", ")", "if", "ratio", "is", "None", ":", "logger", ".", "info", "(", "'Make sure this is for irrational (1+2*cos(alpha)/cos(alpha) ratio'", ")", "elif", "len", "(", "ratio", ")", "!=", "2", ":", "raise", "RuntimeError", "(", "'Rhombohedral system needs correct '", "'(1+2*cos(alpha)/cos(alpha) ratio'", ")", "else", ":", "raise", "RuntimeError", "(", "'Lattice type not implemented. This code works for cubic, '", "'tetragonal, orthorhombic, rhombehedral, hexagonal systems'", ")", "# transform four index notation to three index notation for hexagonal and rhombohedral", "if", "len", "(", "rotation_axis", ")", "==", "4", ":", "u1", "=", "rotation_axis", "[", "0", "]", "v1", "=", "rotation_axis", "[", "1", "]", "w1", "=", "rotation_axis", "[", "3", "]", "if", "lat_type", ".", "lower", "(", ")", "==", "'h'", ":", "u", "=", "2", "*", "u1", "+", "v1", "v", "=", "2", "*", "v1", "+", "u1", "w", "=", "w1", "rotation_axis", "=", "[", "u", ",", "v", ",", "w", "]", "elif", "lat_type", ".", "lower", "(", ")", "==", "'r'", ":", "u", "=", "2", "*", "u1", "+", "v1", "+", "w1", "v", "=", "v1", "+", "w1", "-", "u1", "w", "=", "w1", "-", "2", "*", "v1", "-", "u1", "rotation_axis", "=", "[", "u", ",", "v", ",", "w", "]", "# make sure gcd(rotation_axis)==1", "if", "reduce", "(", "gcd", ",", "rotation_axis", ")", "!=", "1", ":", "rotation_axis", "=", "[", "int", "(", "round", "(", "x", "/", "reduce", "(", "gcd", ",", "rotation_axis", ")", ")", ")", "for", "x", "in", "rotation_axis", "]", "# transform four index notation to three index notation for plane", "if", "plane", "is", "not", "None", ":", "if", "len", "(", "plane", ")", "==", "4", ":", "u1", "=", "plane", "[", "0", "]", "v1", "=", "plane", "[", "1", "]", "w1", "=", "plane", "[", "3", "]", "plane", "=", "[", "u1", ",", "v1", ",", "w1", "]", "# set the plane for grain boundary when plane is None.", "if", "plane", "is", "None", ":", "if", "lat_type", ".", "lower", "(", ")", "==", "'c'", ":", "plane", "=", "rotation_axis", "else", ":", "if", "lat_type", ".", "lower", "(", ")", "==", "'h'", ":", "if", "ratio", "is", "None", ":", "c2_a2_ratio", "=", "1", "else", ":", "c2_a2_ratio", "=", "ratio", "[", "0", "]", "/", "ratio", "[", "1", "]", "metric", "=", "np", ".", "array", "(", "[", "[", "1", ",", "-", "0.5", ",", "0", "]", ",", "[", "-", "0.5", ",", "1", ",", "0", "]", ",", "[", "0", ",", "0", ",", "c2_a2_ratio", "]", "]", ")", "elif", "lat_type", ".", "lower", "(", ")", "==", "'r'", ":", "if", "ratio", "is", "None", ":", "cos_alpha", "=", "0.5", "else", ":", "cos_alpha", "=", "1.0", "/", "(", "ratio", "[", "0", "]", "/", "ratio", "[", "1", "]", "-", "2", ")", "metric", "=", "np", ".", "array", "(", "[", "[", "1", ",", "cos_alpha", ",", "cos_alpha", "]", ",", "[", "cos_alpha", ",", "1", ",", "cos_alpha", "]", ",", "[", "cos_alpha", ",", "cos_alpha", ",", "1", "]", "]", ")", "elif", "lat_type", ".", "lower", "(", ")", "==", "'t'", ":", "if", "ratio", "is", "None", ":", "c2_a2_ratio", "=", "1", "else", ":", "c2_a2_ratio", "=", "ratio", "[", "0", "]", "/", "ratio", "[", "1", "]", "metric", "=", "np", ".", "array", "(", "[", "[", "1", ",", "0", ",", "0", "]", ",", "[", "0", ",", "1", ",", "0", "]", ",", "[", "0", ",", "0", ",", "c2_a2_ratio", "]", "]", ")", "elif", "lat_type", ".", "lower", "(", ")", "==", "'o'", ":", "for", "i", "in", "range", "(", "3", ")", ":", "if", "ratio", "[", "i", "]", "is", "None", ":", "ratio", "[", "i", "]", "=", "1", "metric", "=", "np", ".", "array", "(", "[", "[", "1", ",", "0", ",", "0", "]", ",", "[", "0", ",", "ratio", "[", "1", "]", "/", "ratio", "[", "2", "]", ",", "0", "]", ",", "[", "0", ",", "0", ",", "ratio", "[", "0", "]", "/", "ratio", "[", "2", "]", "]", "]", ")", "else", ":", "raise", "RuntimeError", "(", "'Lattice type has not implemented.'", ")", "plane", "=", "np", ".", "matmul", "(", "rotation_axis", ",", "metric", ")", "fractions", "=", "[", "Fraction", "(", "x", ")", ".", "limit_denominator", "(", ")", "for", "x", "in", "plane", "]", "least_mul", "=", "reduce", "(", "lcm", ",", "[", "f", ".", "denominator", "for", "f", "in", "fractions", "]", ")", "plane", "=", "[", "int", "(", "round", "(", "x", "*", "least_mul", ")", ")", "for", "x", "in", "plane", "]", "if", "reduce", "(", "gcd", ",", "plane", ")", "!=", "1", ":", "index", "=", "reduce", "(", "gcd", ",", "plane", ")", "plane", "=", "[", "int", "(", "round", "(", "x", "/", "index", ")", ")", "for", "x", "in", "plane", "]", "t1", ",", "t2", "=", "self", ".", "get_trans_mat", "(", "r_axis", "=", "rotation_axis", ",", "angle", "=", "rotation_angle", ",", "normal", "=", "normal", ",", "trans_cry", "=", "trans_cry", ",", "lat_type", "=", "lat_type", ",", "ratio", "=", "ratio", ",", "surface", "=", "plane", ",", "max_search", "=", "max_search", ",", "quick_gen", "=", "quick_gen", ")", "# find the join_plane", "if", "lat_type", ".", "lower", "(", ")", "!=", "'c'", ":", "if", "lat_type", ".", "lower", "(", ")", "==", "'h'", ":", "if", "ratio", "is", "None", ":", "mu", ",", "mv", "=", "[", "1", ",", "1", "]", "else", ":", "mu", ",", "mv", "=", "ratio", "trans_cry1", "=", "np", ".", "array", "(", "[", "[", "1", ",", "0", ",", "0", "]", ",", "[", "-", "0.5", ",", "np", ".", "sqrt", "(", "3.0", ")", "/", "2.0", ",", "0", "]", ",", "[", "0", ",", "0", ",", "np", ".", "sqrt", "(", "mu", "/", "mv", ")", "]", "]", ")", "elif", "lat_type", ".", "lower", "(", ")", "==", "'r'", ":", "if", "ratio", "is", "None", ":", "c2_a2_ratio", "=", "1", "else", ":", "mu", ",", "mv", "=", "ratio", "c2_a2_ratio", "=", "3.0", "/", "(", "2", "-", "6", "*", "mv", "/", "mu", ")", "trans_cry1", "=", "np", ".", "array", "(", "[", "[", "0.5", ",", "np", ".", "sqrt", "(", "3.0", ")", "/", "6.0", ",", "1.0", "/", "3", "*", "np", ".", "sqrt", "(", "c2_a2_ratio", ")", "]", ",", "[", "-", "0.5", ",", "np", ".", "sqrt", "(", "3.0", ")", "/", "6.0", ",", "1.0", "/", "3", "*", "np", ".", "sqrt", "(", "c2_a2_ratio", ")", "]", ",", "[", "0", ",", "-", "1", "*", "np", ".", "sqrt", "(", "3.0", ")", "/", "3.0", ",", "1.0", "/", "3", "*", "np", ".", "sqrt", "(", "c2_a2_ratio", ")", "]", "]", ")", "else", ":", "if", "lat_type", ".", "lower", "(", ")", "==", "'t'", ":", "if", "ratio", "is", "None", ":", "mu", ",", "mv", "=", "[", "1", ",", "1", "]", "else", ":", "mu", ",", "mv", "=", "ratio", "lam", "=", "mv", "elif", "lat_type", ".", "lower", "(", ")", "==", "'o'", ":", "new_ratio", "=", "[", "1", "if", "v", "is", "None", "else", "v", "for", "v", "in", "ratio", "]", "mu", ",", "lam", ",", "mv", "=", "new_ratio", "trans_cry1", "=", "np", ".", "array", "(", "[", "[", "1", ",", "0", ",", "0", "]", ",", "[", "0", ",", "np", ".", "sqrt", "(", "lam", "/", "mv", ")", ",", "0", "]", ",", "[", "0", ",", "0", ",", "np", ".", "sqrt", "(", "mu", "/", "mv", ")", "]", "]", ")", "else", ":", "trans_cry1", "=", "trans_cry", "grain_matrix", "=", "np", ".", "dot", "(", "t2", ",", "trans_cry1", ")", "plane_init", "=", "np", ".", "cross", "(", "grain_matrix", "[", "0", "]", ",", "grain_matrix", "[", "1", "]", ")", "if", "lat_type", ".", "lower", "(", ")", "!=", "'c'", ":", "plane_init", "=", "np", ".", "dot", "(", "plane_init", ",", "trans_cry1", ".", "T", ")", "join_plane", "=", "self", ".", "vec_to_surface", "(", "plane_init", ")", "parent_structure", "=", "self", ".", "initial_structure", ".", "copy", "(", ")", "# calculate the bond_length in bulk system.", "if", "len", "(", "parent_structure", ")", "==", "1", ":", "temp_str", "=", "parent_structure", ".", "copy", "(", ")", "temp_str", ".", "make_supercell", "(", "[", "1", ",", "1", ",", "2", "]", ")", "distance", "=", "temp_str", ".", "distance_matrix", "else", ":", "distance", "=", "parent_structure", ".", "distance_matrix", "bond_length", "=", "np", ".", "min", "(", "distance", "[", "np", ".", "nonzero", "(", "distance", ")", "]", ")", "# top grain", "top_grain", "=", "fix_pbc", "(", "parent_structure", "*", "t1", ")", "# obtain the smallest oriended cell", "if", "normal", "and", "not", "quick_gen", ":", "t_temp", "=", "self", ".", "get_trans_mat", "(", "r_axis", "=", "rotation_axis", ",", "angle", "=", "rotation_angle", ",", "normal", "=", "False", ",", "trans_cry", "=", "trans_cry", ",", "lat_type", "=", "lat_type", ",", "ratio", "=", "ratio", ",", "surface", "=", "plane", ",", "max_search", "=", "max_search", ")", "oriended_unit_cell", "=", "fix_pbc", "(", "parent_structure", "*", "t_temp", "[", "0", "]", ")", "t_matrix", "=", "oriended_unit_cell", ".", "lattice", ".", "matrix", "normal_v_plane", "=", "np", ".", "cross", "(", "t_matrix", "[", "0", "]", ",", "t_matrix", "[", "1", "]", ")", "unit_normal_v", "=", "normal_v_plane", "/", "np", ".", "linalg", ".", "norm", "(", "normal_v_plane", ")", "unit_ab_adjust", "=", "(", "t_matrix", "[", "2", "]", "-", "np", ".", "dot", "(", "unit_normal_v", ",", "t_matrix", "[", "2", "]", ")", "*", "unit_normal_v", ")", "/", "np", ".", "dot", "(", "unit_normal_v", ",", "t_matrix", "[", "2", "]", ")", "else", ":", "oriended_unit_cell", "=", "top_grain", ".", "copy", "(", ")", "unit_ab_adjust", "=", "0.0", "# bottom grain, using top grain's lattice matrix", "bottom_grain", "=", "fix_pbc", "(", "parent_structure", "*", "t2", ",", "top_grain", ".", "lattice", ".", "matrix", ")", "# label both grains with 'top','bottom','top_incident','bottom_incident'", "n_sites", "=", "top_grain", ".", "num_sites", "t_and_b", "=", "Structure", "(", "top_grain", ".", "lattice", ",", "top_grain", ".", "species", "+", "bottom_grain", ".", "species", ",", "list", "(", "top_grain", ".", "frac_coords", ")", "+", "list", "(", "bottom_grain", ".", "frac_coords", ")", ")", "t_and_b_dis", "=", "t_and_b", ".", "lattice", ".", "get_all_distances", "(", "t_and_b", ".", "frac_coords", "[", "0", ":", "n_sites", "]", ",", "t_and_b", ".", "frac_coords", "[", "n_sites", ":", "n_sites", "*", "2", "]", ")", "index_incident", "=", "np", ".", "nonzero", "(", "t_and_b_dis", "<", "np", ".", "min", "(", "t_and_b_dis", ")", "+", "tol_coi", ")", "top_labels", "=", "[", "]", "for", "i", "in", "range", "(", "n_sites", ")", ":", "if", "i", "in", "index_incident", "[", "0", "]", ":", "top_labels", ".", "append", "(", "'top_incident'", ")", "else", ":", "top_labels", ".", "append", "(", "'top'", ")", "bottom_labels", "=", "[", "]", "for", "i", "in", "range", "(", "n_sites", ")", ":", "if", "i", "in", "index_incident", "[", "1", "]", ":", "bottom_labels", ".", "append", "(", "'bottom_incident'", ")", "else", ":", "bottom_labels", ".", "append", "(", "'bottom'", ")", "top_grain", "=", "Structure", "(", "Lattice", "(", "top_grain", ".", "lattice", ".", "matrix", ")", ",", "top_grain", ".", "species", ",", "top_grain", ".", "frac_coords", ",", "site_properties", "=", "{", "'grain_label'", ":", "top_labels", "}", ")", "bottom_grain", "=", "Structure", "(", "Lattice", "(", "bottom_grain", ".", "lattice", ".", "matrix", ")", ",", "bottom_grain", ".", "species", ",", "bottom_grain", ".", "frac_coords", ",", "site_properties", "=", "{", "'grain_label'", ":", "bottom_labels", "}", ")", "# expand both grains", "top_grain", ".", "make_supercell", "(", "[", "1", ",", "1", ",", "expand_times", "]", ")", "bottom_grain", ".", "make_supercell", "(", "[", "1", ",", "1", ",", "expand_times", "]", ")", "top_grain", "=", "fix_pbc", "(", "top_grain", ")", "bottom_grain", "=", "fix_pbc", "(", "bottom_grain", ")", "# determine the top-grain location.", "edge_b", "=", "1.0", "-", "max", "(", "bottom_grain", ".", "frac_coords", "[", ":", ",", "2", "]", ")", "edge_t", "=", "1.0", "-", "max", "(", "top_grain", ".", "frac_coords", "[", ":", ",", "2", "]", ")", "c_adjust", "=", "(", "edge_t", "-", "edge_b", ")", "/", "2.0", "# construct all species", "all_species", "=", "[", "]", "all_species", ".", "extend", "(", "[", "site", ".", "specie", "for", "site", "in", "bottom_grain", "]", ")", "all_species", ".", "extend", "(", "[", "site", ".", "specie", "for", "site", "in", "top_grain", "]", ")", "half_lattice", "=", "top_grain", ".", "lattice", "# calculate translation vector, perpendicular to the plane", "normal_v_plane", "=", "np", ".", "cross", "(", "half_lattice", ".", "matrix", "[", "0", "]", ",", "half_lattice", ".", "matrix", "[", "1", "]", ")", "unit_normal_v", "=", "normal_v_plane", "/", "np", ".", "linalg", ".", "norm", "(", "normal_v_plane", ")", "translation_v", "=", "unit_normal_v", "*", "vacuum_thickness", "# construct the final lattice", "whole_matrix_no_vac", "=", "np", ".", "array", "(", "half_lattice", ".", "matrix", ")", "whole_matrix_no_vac", "[", "2", "]", "=", "half_lattice", ".", "matrix", "[", "2", "]", "*", "2", "whole_matrix_with_vac", "=", "whole_matrix_no_vac", ".", "copy", "(", ")", "whole_matrix_with_vac", "[", "2", "]", "=", "whole_matrix_no_vac", "[", "2", "]", "+", "translation_v", "*", "2", "whole_lat", "=", "Lattice", "(", "whole_matrix_with_vac", ")", "# construct the coords, move top grain with translation_v", "all_coords", "=", "[", "]", "grain_labels", "=", "bottom_grain", ".", "site_properties", "[", "'grain_label'", "]", "+", "top_grain", ".", "site_properties", "[", "'grain_label'", "]", "for", "site", "in", "bottom_grain", ":", "all_coords", ".", "append", "(", "site", ".", "coords", ")", "for", "site", "in", "top_grain", ":", "all_coords", ".", "append", "(", "site", ".", "coords", "+", "half_lattice", ".", "matrix", "[", "2", "]", "*", "(", "1", "+", "c_adjust", ")", "+", "unit_ab_adjust", "*", "np", ".", "linalg", ".", "norm", "(", "half_lattice", ".", "matrix", "[", "2", "]", "*", "(", "1", "+", "c_adjust", ")", ")", "+", "translation_v", "+", "ab_shift", "[", "0", "]", "*", "whole_matrix_with_vac", "[", "0", "]", "+", "ab_shift", "[", "1", "]", "*", "whole_matrix_with_vac", "[", "1", "]", ")", "gb_with_vac", "=", "Structure", "(", "whole_lat", ",", "all_species", ",", "all_coords", ",", "coords_are_cartesian", "=", "True", ",", "site_properties", "=", "{", "'grain_label'", ":", "grain_labels", "}", ")", "# merge closer atoms. extract near gb atoms.", "cos_c_norm_plane", "=", "np", ".", "dot", "(", "unit_normal_v", ",", "whole_matrix_with_vac", "[", "2", "]", ")", "/", "whole_lat", ".", "c", "range_c_len", "=", "abs", "(", "bond_length", "/", "cos_c_norm_plane", "/", "whole_lat", ".", "c", ")", "sites_near_gb", "=", "[", "]", "sites_away_gb", "=", "[", "]", "for", "site", "in", "gb_with_vac", ".", "sites", ":", "if", "site", ".", "frac_coords", "[", "2", "]", "<", "range_c_len", "or", "site", ".", "frac_coords", "[", "2", "]", ">", "1", "-", "range_c_len", "or", "(", "site", ".", "frac_coords", "[", "2", "]", ">", "0.5", "-", "range_c_len", "and", "site", ".", "frac_coords", "[", "2", "]", "<", "0.5", "+", "range_c_len", ")", ":", "sites_near_gb", ".", "append", "(", "site", ")", "else", ":", "sites_away_gb", ".", "append", "(", "site", ")", "if", "len", "(", "sites_near_gb", ")", ">=", "1", ":", "s_near_gb", "=", "Structure", ".", "from_sites", "(", "sites_near_gb", ")", "s_near_gb", ".", "merge_sites", "(", "tol", "=", "bond_length", "*", "rm_ratio", ",", "mode", "=", "'d'", ")", "all_sites", "=", "sites_away_gb", "+", "s_near_gb", ".", "sites", "gb_with_vac", "=", "Structure", ".", "from_sites", "(", "all_sites", ")", "return", "GrainBoundary", "(", "whole_lat", ",", "gb_with_vac", ".", "species", ",", "gb_with_vac", ".", "cart_coords", ",", "rotation_axis", ",", "rotation_angle", ",", "plane", ",", "join_plane", ",", "self", ".", "initial_structure", ",", "vacuum_thickness", ",", "ab_shift", ",", "site_properties", "=", "gb_with_vac", ".", "site_properties", ",", "oriented_unit_cell", "=", "oriended_unit_cell", ",", "coords_are_cartesian", "=", "True", ")" ]

[ "Args", ":", "rotation_axis", "(", "list", ")", ":", "Rotation", "axis", "of", "GB", "in", "the", "form", "of", "a", "list", "of", "integer", "e", ".", "g", ".", ":", "[", "1", "1", "0", "]", "rotation_angle", "(", "float", "in", "unit", "of", "degree", ")", ":", "rotation", "angle", "used", "to", "generate", "GB", ".", "Make", "sure", "the", "angle", "is", "accurate", "enough", ".", "You", "can", "use", "the", "enum", "*", "functions", "in", "this", "class", "to", "extract", "the", "accurate", "angle", ".", "e", ".", "g", ".", ":", "The", "rotation", "angle", "of", "sigma", "3", "twist", "GB", "with", "the", "rotation", "axis", "[", "1", "1", "1", "]", "and", "GB", "plane", "(", "1", "1", "1", ")", "can", "be", "60", ".", "000000000", "degree", ".", "If", "you", "do", "not", "know", "the", "rotation", "angle", "but", "know", "the", "sigma", "value", "we", "have", "provide", "the", "function", "get_rotation_angle_from_sigma", "which", "is", "able", "to", "return", "all", "the", "rotation", "angles", "of", "sigma", "value", "you", "provided", ".", "expand_times", "(", "int", ")", ":", "The", "multiple", "times", "used", "to", "expand", "one", "unit", "grain", "to", "larger", "grain", ".", "This", "is", "used", "to", "tune", "the", "grain", "length", "of", "GB", "to", "warrant", "that", "the", "two", "GBs", "in", "one", "cell", "do", "not", "interact", "with", "each", "other", ".", "Default", "set", "to", "4", ".", "vacuum_thickness", "(", "float", "in", "angstrom", ")", ":", "The", "thickness", "of", "vacuum", "that", "you", "want", "to", "insert", "between", "two", "grains", "of", "the", "GB", ".", "Default", "to", "0", ".", "ab_shift", "(", "list", "of", "float", "in", "unit", "of", "a", "b", "vectors", "of", "Gb", ")", ":", "in", "plane", "shift", "of", "two", "grains", "normal", "(", "logic", ")", ":", "determine", "if", "need", "to", "require", "the", "c", "axis", "of", "top", "grain", "(", "first", "transformation", "matrix", ")", "perperdicular", "to", "the", "surface", "or", "not", ".", "default", "to", "false", ".", "ratio", "(", "list", "of", "integers", ")", ":", "lattice", "axial", "ratio", ".", "For", "cubic", "system", "ratio", "is", "not", "needed", ".", "For", "tetragonal", "system", "ratio", "=", "[", "mu", "mv", "]", "list", "of", "two", "integers", "that", "is", "mu", "/", "mv", "=", "c2", "/", "a2", ".", "If", "it", "is", "irrational", "set", "it", "to", "none", ".", "For", "orthorhombic", "system", "ratio", "=", "[", "mu", "lam", "mv", "]", "list", "of", "three", "integers", "that", "is", "mu", ":", "lam", ":", "mv", "=", "c2", ":", "b2", ":", "a2", ".", "If", "irrational", "for", "one", "axis", "set", "it", "to", "None", ".", "e", ".", "g", ".", "mu", ":", "lam", ":", "mv", "=", "c2", "None", "a2", "means", "b2", "is", "irrational", ".", "For", "rhombohedral", "system", "ratio", "=", "[", "mu", "mv", "]", "list", "of", "two", "integers", "that", "is", "mu", "/", "mv", "is", "the", "ratio", "of", "(", "1", "+", "2", "*", "cos", "(", "alpha", "))", "/", "cos", "(", "alpha", ")", ".", "If", "irrational", "set", "it", "to", "None", ".", "For", "hexagonal", "system", "ratio", "=", "[", "mu", "mv", "]", "list", "of", "two", "integers", "that", "is", "mu", "/", "mv", "=", "c2", "/", "a2", ".", "If", "it", "is", "irrational", "set", "it", "to", "none", ".", "This", "code", "also", "supplies", "a", "class", "method", "to", "generate", "the", "ratio", "from", "the", "structure", "(", "get_ratio", ")", ".", "User", "can", "also", "make", "their", "own", "approximation", "and", "input", "the", "ratio", "directly", ".", "plane", "(", "list", ")", ":", "Grain", "boundary", "plane", "in", "the", "form", "of", "a", "list", "of", "integers", "e", ".", "g", ".", ":", "[", "1", "2", "3", "]", ".", "If", "none", "we", "set", "it", "as", "twist", "GB", ".", "The", "plane", "will", "be", "perpendicular", "to", "the", "rotation", "axis", ".", "max_search", "(", "int", ")", ":", "max", "search", "for", "the", "GB", "lattice", "vectors", "that", "give", "the", "smallest", "GB", "lattice", ".", "If", "normal", "is", "true", "also", "max", "search", "the", "GB", "c", "vector", "that", "perpendicular", "to", "the", "plane", ".", "For", "complex", "GB", "if", "you", "want", "to", "speed", "up", "you", "can", "reduce", "this", "value", ".", "But", "too", "small", "of", "this", "value", "may", "lead", "to", "error", ".", "tol_coi", "(", "float", ")", ":", "tolerance", "to", "find", "the", "coincidence", "sites", ".", "When", "making", "approximations", "to", "the", "ratio", "needed", "to", "generate", "the", "GB", "you", "probably", "need", "to", "increase", "this", "tolerance", "to", "obtain", "the", "correct", "number", "of", "coincidence", "sites", ".", "To", "check", "the", "number", "of", "coincidence", "sites", "are", "correct", "or", "not", "you", "can", "compare", "the", "generated", "Gb", "object", "s", "sigma_from_site_prop", "with", "enum", "*", "sigma", "values", "(", "what", "user", "expected", "by", "input", ")", ".", "rm_ratio", "(", "float", ")", ":", "the", "criteria", "to", "remove", "the", "atoms", "which", "are", "too", "close", "with", "each", "other", ".", "rm_ratio", "*", "bond_length", "of", "bulk", "system", "is", "the", "criteria", "of", "bond", "length", "below", "which", "the", "atom", "will", "be", "removed", ".", "Default", "to", "0", ".", "7", ".", "quick_gen", "(", "bool", ")", ":", "whether", "to", "quickly", "generate", "a", "supercell", "if", "set", "to", "true", "no", "need", "to", "find", "the", "smallest", "cell", "." ]

[ "def", "clear", "(", "self", ")", ":", "self", ".", "services", ".", "clear", "(", ")", "self", ".", "services", "=", "None", "self", ".", "_future_value", "=", "None", "super", "(", "AggregateDependency", ",", "self", ")", ".", "clear", "(", ")" ]

[ "Cleans", "up", "the", "manager", ".", "The", "manager", "can", "t", "be", "used", "after", "this", "method", "has", "been", "called" ]

[ "def", "LogBinomialCoef", "(", "n", ",", "k", ")", ":", "return", "n", "*", "log", "(", "n", ")", "-", "k", "*", "log", "(", "k", ")", "-", "(", "n", "-", "k", ")", "*", "log", "(", "n", "-", "k", ")" ]

[ "Computes", "the", "log", "of", "the", "binomial", "coefficient", "." ]

[ "def", "_create_graph", "(", "self", ",", "return_target_sources", "=", "None", ")", ":", "if", "return_target_sources", "is", "None", ":", "# We set it to a defaultdict in order to be consistent with the", "# actual parameter.", "return_target_sources", "=", "defaultdict", "(", "list", ")", "cfg", "=", "networkx", ".", "DiGraph", "(", ")", "# The corner case: add a node to the graph if there is only one block", "if", "len", "(", "self", ".", "_nodes", ")", "==", "1", ":", "cfg", ".", "add_node", "(", "self", ".", "_nodes", "[", "next", "(", "iter", "(", "self", ".", "_nodes", ".", "keys", "(", ")", ")", ")", "]", ")", "# Adding edges", "for", "tpl", ",", "targets", "in", "self", ".", "_exit_targets", ".", "items", "(", ")", ":", "basic_block", "=", "self", ".", "_nodes", "[", "tpl", "]", "# Cannot fail :)", "for", "ex", ",", "jumpkind", "in", "targets", ":", "if", "ex", "in", "self", ".", "_nodes", ":", "target_bbl", "=", "self", ".", "_nodes", "[", "ex", "]", "cfg", ".", "add_edge", "(", "basic_block", ",", "target_bbl", ",", "jumpkind", "=", "jumpkind", ")", "# Add edges for possibly missing returns", "if", "basic_block", ".", "addr", "in", "return_target_sources", ":", "for", "src_irsb_key", "in", "return_target_sources", "[", "basic_block", ".", "addr", "]", ":", "cfg", ".", "add_edge", "(", "self", ".", "_nodes", "[", "src_irsb_key", "]", ",", "basic_block", ",", "jumpkind", "=", "\"Ijk_Ret\"", ")", "else", ":", "# Debugging output", "def", "addr_formalize", "(", "addr", ")", ":", "if", "addr", "is", "None", ":", "return", "\"None\"", "else", ":", "return", "\"%#08x\"", "%", "addr", "s", "=", "\"([\"", "for", "addr", "in", "ex", "[", ":", "-", "1", "]", ":", "s", "+=", "addr_formalize", "(", "addr", ")", "+", "\", \"", "s", "+=", "\"] %s)\"", "%", "addr_formalize", "(", "ex", "[", "-", "1", "]", ")", "l", ".", "warning", "(", "\"Key %s does not exist.\"", ",", "s", ")", "return", "cfg" ]

[ "Create", "a", "DiGraph", "out", "of", "the", "existing", "edge", "map", ".", ":", "param", "return_target_sources", ":", "Used", "for", "making", "up", "those", "missing", "returns", ":", "returns", ":", "A", "networkx", ".", "DiGraph", "()", "object" ]

[ "def", "_Cobject", "(", "cls", ",", "ctype", ")", ":", "o", "=", "object", ".", "__new__", "(", "cls", ")", "o", ".", "_as_parameter_", "=", "ctype", "return", "o" ]

[ "(", "INTERNAL", ")", "New", "instance", "from", "ctypes", "." ]

[ "def", "_cast_values_for_fillna", "(", "values", ",", "dtype", ")", ":", "# TODO: for int-dtypes we make a copy, but for everything else this", "# alters the values in-place. Is this intentional?", "if", "(", "is_datetime64_dtype", "(", "dtype", ")", "or", "is_datetime64tz_dtype", "(", "dtype", ")", "or", "is_timedelta64_dtype", "(", "dtype", ")", ")", ":", "values", "=", "values", ".", "view", "(", "np", ".", "int64", ")", "elif", "is_integer_dtype", "(", "values", ")", ":", "# NB: this check needs to come after the datetime64 check above", "values", "=", "ensure_float64", "(", "values", ")", "return", "values" ]

[ "Cast", "values", "to", "a", "dtype", "that", "algos", ".", "pad", "and", "algos", ".", "backfill", "can", "handle", "." ]

[ "def", "_check_completeness_table", "(", "completeness", ",", "catalogue", ")", ":", "if", "isinstance", "(", "completeness", ",", "np", ".", "ndarray", ")", "and", "np", ".", "shape", "(", "completeness", ")", "[", "1", "]", "==", "2", ":", "return", "completeness", "elif", "isinstance", "(", "completeness", ",", "float", ")", ":", "return", "np", ".", "array", "(", "[", "[", "float", "(", "np", ".", "min", "(", "catalogue", ".", "data", "[", "'year'", "]", ")", ")", ",", "completeness", "]", "]", ")", "elif", "completeness", "is", "None", ":", "return", "np", ".", "array", "(", "[", "[", "float", "(", "np", ".", "min", "(", "catalogue", ".", "data", "[", "'year'", "]", ")", ")", ",", "np", ".", "min", "(", "catalogue", ".", "data", "[", "'magnitude'", "]", ")", "]", "]", ")", "else", ":", "raise", "ValueError", "(", "'Completeness representation not recognised'", ")" ]

[ "Generates", "the", "completeness", "table", "according", "to", "different", "instances" ]

[ "def", "_load", "(", "stream", ",", "container", ",", "sep", "=", "_SEP", ",", "dkey", "=", "DEFAULTSECT", ",", "*", "*", "kwargs", ")", ":", "(", "kwargs_1", ",", "psr", ")", "=", "_make_parser", "(", "*", "*", "kwargs", ")", "if", "IS_PYTHON_3", ":", "psr", ".", "read_file", "(", "stream", ",", "*", "*", "kwargs_1", ")", "else", ":", "psr", ".", "readfp", "(", "stream", ",", "*", "*", "kwargs_1", ")", "cnf", "=", "container", "(", ")", "kwargs", "[", "\"sep\"", "]", "=", "sep", "defaults", "=", "psr", ".", "defaults", "(", ")", "if", "defaults", ":", "cnf", "[", "dkey", "]", "=", "container", "(", "_parsed_items", "(", "iteritems", "(", "defaults", ")", ",", "*", "*", "kwargs", ")", ")", "for", "sect", "in", "psr", ".", "sections", "(", ")", ":", "cnf", "[", "sect", "]", "=", "container", "(", "_parsed_items", "(", "psr", ".", "items", "(", "sect", ")", ",", "*", "*", "kwargs", ")", ")", "return", "cnf" ]

[ ":", "param", "stream", ":", "File", "or", "file", "-", "like", "object", "provides", "ini", "-", "style", "conf", ":", "param", "container", ":", "any", "callable", "to", "make", "container", ":", "param", "sep", ":", "Seprator", "string", ":", "param", "dkey", ":", "Default", "section", "name" ]

[ "def", "create_in_project", "(", "self", ",", "project", ",", "params", "=", "{", "}", ",", "*", "*", "options", ")", ":", "path", "=", "\"/projects/%s/sections\"", "%", "(", "project", ")", "return", "self", ".", "client", ".", "post", "(", "path", ",", "params", ",", "*", "*", "options", ")" ]

[ "Creates", "a", "new", "section", "in", "a", "project", ".", "Returns", "the", "full", "record", "of", "the", "newly", "created", "section", "." ]

[ "def", "do_reset", "(", "self", ",", "line", ")", ":", "self", ".", "_split_args", "(", "line", ",", "0", ",", "0", ")", "self", ".", "_command_processor", ".", "get_session", "(", ")", ".", "reset", "(", ")", "self", ".", "_print_info_if_verbose", "(", "\"Successfully reset session variables\"", ")" ]

[ "reset", "Set", "all", "session", "variables", "to", "their", "default", "values", "." ]

[ "def", "remove_node", "(", "self", ",", "node", ")", ":", "pending", "=", "self", ".", "node2pending", ".", "pop", "(", "node", ")", "if", "not", "pending", ":", "return", "# The node crashed, reassing pending items", "crashitem", "=", "self", ".", "collection", "[", "pending", ".", "pop", "(", "0", ")", "]", "self", ".", "pending", ".", "extend", "(", "pending", ")", "for", "node", "in", "self", ".", "node2pending", ":", "self", ".", "check_schedule", "(", "node", ")", "return", "crashitem" ]

[ "Remove", "a", "node", "from", "the", "scheduler" ]

[ "def", "export_sleep_stats", "(", "self", ",", "filename", ",", "lights_off", ",", "lights_on", ")", ":", "epochs", "=", "self", ".", "get_epochs", "(", ")", "ep_starts", "=", "[", "i", "[", "'start'", "]", "for", "i", "in", "epochs", "]", "hypno", "=", "[", "i", "[", "'stage'", "]", "for", "i", "in", "epochs", "]", "n_ep_per_min", "=", "60", "/", "self", ".", "epoch_length", "first", "=", "{", "}", "latency", "=", "{", "}", "for", "stage", "in", "[", "'NREM1'", ",", "'NREM2'", ",", "'NREM3'", ",", "'REM'", "]", ":", "first", "[", "stage", "]", "=", "next", "(", "(", "(", "i", ",", "j", ")", "for", "i", ",", "j", "in", "enumerate", "(", "epochs", ")", "if", "j", "[", "'stage'", "]", "==", "stage", ")", ",", "None", ")", "if", "first", "[", "stage", "]", "is", "not", "None", ":", "latency", "[", "stage", "]", "=", "(", "first", "[", "stage", "]", "[", "1", "]", "[", "'start'", "]", "-", "lights_off", ")", "/", "60", "else", ":", "first", "[", "stage", "]", "=", "nan", "latency", "[", "stage", "]", "=", "nan", "idx_loff", "=", "asarray", "(", "[", "abs", "(", "x", "-", "lights_off", ")", "for", "x", "in", "ep_starts", "]", ")", ".", "argmin", "(", ")", "idx_lon", "=", "asarray", "(", "[", "abs", "(", "x", "-", "lights_on", ")", "for", "x", "in", "ep_starts", "]", ")", ".", "argmin", "(", ")", "duration", "=", "{", "}", "for", "stage", "in", "[", "'NREM1'", ",", "'NREM2'", ",", "'NREM3'", ",", "'REM'", ",", "'Wake'", ",", "'Movement'", ",", "'Artefact'", "]", ":", "duration", "[", "stage", "]", "=", "hypno", "[", "idx_loff", ":", "idx_lon", "]", ".", "count", "(", "stage", ")", "/", "n_ep_per_min", "slp_onset", "=", "sorted", "(", "first", ".", "values", "(", ")", ",", "key", "=", "lambda", "x", ":", "x", "[", "1", "]", "[", "'start'", "]", ")", "[", "0", "]", "wake_up", "=", "next", "(", "(", "len", "(", "epochs", ")", "-", "i", ",", "j", ")", "for", "i", ",", "j", "in", "enumerate", "(", "epochs", "[", ":", ":", "-", "1", "]", ")", "if", "j", "[", "'stage'", "]", "in", "[", "'NREM1'", ",", "'NREM2'", ",", "'NREM3'", ",", "'REM'", "]", ")", "total_dark_time", "=", "(", "lights_on", "-", "lights_off", ")", "/", "60", "#slp_period_time = (wake_up[1]['start'] - slp_onset[1]['start']) / 60", "slp_onset_lat", "=", "(", "slp_onset", "[", "1", "]", "[", "'start'", "]", "-", "lights_off", ")", "/", "60", "waso", "=", "hypno", "[", "slp_onset", "[", "0", "]", ":", "wake_up", "[", "0", "]", "]", ".", "count", "(", "'Wake'", ")", "/", "n_ep_per_min", "wake", "=", "waso", "+", "slp_onset_lat", "total_slp_period", "=", "sum", "(", "(", "waso", ",", "duration", "[", "'NREM1'", "]", ",", "duration", "[", "'NREM2'", "]", ",", "duration", "[", "'NREM3'", "]", ",", "duration", "[", "'REM'", "]", ")", ")", "total_slp_time", "=", "total_slp_period", "-", "waso", "slp_eff", "=", "total_slp_time", "/", "total_dark_time", "switch", "=", "self", ".", "switch", "(", ")", "slp_frag", "=", "self", ".", "slp_frag", "(", ")", "dt_format", "=", "'%d/%m/%Y %H:%M:%S'", "loff_str", "=", "(", "self", ".", "start_time", "+", "timedelta", "(", "seconds", "=", "lights_off", ")", ")", ".", "strftime", "(", "dt_format", ")", "lon_str", "=", "(", "self", ".", "start_time", "+", "timedelta", "(", "seconds", "=", "lights_on", ")", ")", ".", "strftime", "(", "dt_format", ")", "slp_onset_str", "=", "(", "self", ".", "start_time", "+", "timedelta", "(", "seconds", "=", "slp_onset", "[", "1", "]", "[", "'start'", "]", ")", ")", ".", "strftime", "(", "dt_format", ")", "wake_up_str", "=", "(", "self", ".", "start_time", "+", "timedelta", "(", "seconds", "=", "wake_up", "[", "1", "]", "[", "'start'", "]", ")", ")", ".", "strftime", "(", "dt_format", ")", "slcnrem5", "=", "self", ".", "latency_to_consolidated", "(", "lights_off", ",", "duration", "=", "5", ",", "stage", "=", "[", "'NREM2'", ",", "'NREM3'", "]", ")", "slcnrem10", "=", "self", ".", "latency_to_consolidated", "(", "lights_off", ",", "duration", "=", "10", ",", "stage", "=", "[", "'NREM2'", ",", "'NREM3'", "]", ")", "slcn35", "=", "self", ".", "latency_to_consolidated", "(", "lights_off", ",", "duration", "=", "5", ",", "stage", "=", "[", "'NREM3'", "]", ")", "slcn310", "=", "self", ".", "latency_to_consolidated", "(", "lights_off", ",", "duration", "=", "10", ",", "stage", "=", "[", "'NREM3'", "]", ")", "cycles", "=", "self", ".", "get_cycles", "(", ")", "if", "self", ".", "get_cycles", "(", ")", "else", "[", "]", "cyc_stats", "=", "[", "]", "for", "i", ",", "cyc", "in", "enumerate", "(", "cycles", ")", ":", "one_cyc", "=", "{", "}", "cyc_hypno", "=", "[", "x", "[", "'stage'", "]", "for", "x", "in", "self", ".", "get_epochs", "(", "time", "=", "cyc", ")", "]", "one_cyc", "[", "'duration'", "]", "=", "{", "}", "for", "stage", "in", "[", "'NREM1'", ",", "'NREM2'", ",", "'NREM3'", ",", "'REM'", ",", "'Wake'", ",", "'Movement'", ",", "'Artefact'", "]", ":", "one_cyc", "[", "'duration'", "]", "[", "stage", "]", "=", "cyc_hypno", ".", "count", "(", "stage", ")", "# in epochs", "one_cyc", "[", "'tst'", "]", "=", "sum", "(", "[", "one_cyc", "[", "'duration'", "]", "[", "stage", "]", "for", "stage", "in", "[", "'NREM1'", ",", "'NREM2'", ",", "'NREM3'", ",", "'REM'", "]", "]", ")", "one_cyc", "[", "'tsp'", "]", "=", "one_cyc", "[", "'tst'", "]", "+", "one_cyc", "[", "'duration'", "]", "[", "'Wake'", "]", "one_cyc", "[", "'slp_eff'", "]", "=", "one_cyc", "[", "'tst'", "]", "/", "one_cyc", "[", "'tsp'", "]", "one_cyc", "[", "'switch'", "]", "=", "self", ".", "switch", "(", "time", "=", "cyc", ")", "one_cyc", "[", "'slp_frag'", "]", "=", "self", ".", "slp_frag", "(", "time", "=", "cyc", ")", "cyc_stats", ".", "append", "(", "one_cyc", ")", "with", "open", "(", "filename", ",", "'w'", ",", "newline", "=", "''", ")", "as", "f", ":", "lg", ".", "info", "(", "'Writing to '", "+", "str", "(", "filename", ")", ")", "cf", "=", "writer", "(", "f", ")", "cf", ".", "writerow", "(", "[", "'Wonambi v{}'", ".", "format", "(", "__version__", ")", "]", ")", "cf", ".", "writerow", "(", "[", "'Variable'", ",", "'Acronym'", ",", "'Unit 1'", ",", "'Value 1'", ",", "'Unit 2'", ",", "'Value 2'", ",", "'Formula'", "]", ")", "cf", ".", "writerow", "(", "[", "'Lights off'", ",", "'LOFF'", ",", "'dd/mm/yyyy HH:MM:SS'", ",", "loff_str", ",", "'seconds from recording start'", ",", "lights_off", ",", "'marker'", "]", ")", "cf", ".", "writerow", "(", "[", "'Lights on'", ",", "'LON'", ",", "'dd/mm/yyyy HH:MM:SS'", ",", "lon_str", ",", "'seconds from recording start'", ",", "lights_on", ",", "'marker'", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep onset'", ",", "'SO'", ",", "'dd/mm/yyyy HH:MM:SS'", ",", "slp_onset_str", ",", "'seconds from recording start'", ",", "slp_onset", "[", "1", "]", "[", "'start'", "]", ",", "'first sleep epoch (N1 or N2) - LOFF'", "]", ")", "cf", ".", "writerow", "(", "[", "'Time of last awakening'", ",", "''", ",", "'dd/mm/yyyy HH:MM:SS'", ",", "wake_up_str", ",", "'seconds from recording start'", ",", "wake_up", "[", "1", "]", "[", "'start'", "]", ",", "'end time of last epoch of N1, N2, N3 or REM'", "]", ")", "cf", ".", "writerow", "(", "[", "'Total dark time (Time in bed)'", ",", "'TDT (TIB)'", ",", "'Epochs'", ",", "total_dark_time", "*", "n_ep_per_min", ",", "'Minutes'", ",", "total_dark_time", ",", "'LON - LOFF'", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep latency'", ",", "'SL'", ",", "'Epochs'", ",", "slp_onset_lat", "*", "n_ep_per_min", ",", "'Minutes'", ",", "slp_onset_lat", ",", "'LON - SO'", "]", ")", "cf", ".", "writerow", "(", "[", "'Wake'", ",", "'W'", ",", "'Epochs'", ",", "wake", "*", "n_ep_per_min", ",", "'Minutes'", ",", "wake", ",", "'total wake duration between LOFF and LON'", "]", ")", "cf", ".", "writerow", "(", "[", "'Wake after sleep onset'", ",", "'WASO'", ",", "'Epochs'", ",", "waso", "*", "n_ep_per_min", ",", "'Minutes'", ",", "waso", ",", "'W - SL'", "]", ")", "cf", ".", "writerow", "(", "[", "'N1 duration'", ",", "''", ",", "'Epochs'", ",", "duration", "[", "'NREM1'", "]", "*", "n_ep_per_min", ",", "'Minutes'", ",", "duration", "[", "'NREM1'", "]", ",", "'total N1 duration between LOFF and LON'", "]", ")", "cf", ".", "writerow", "(", "[", "'N2 duration'", ",", "''", ",", "'Epochs'", ",", "duration", "[", "'NREM2'", "]", "*", "n_ep_per_min", ",", "'Minutes'", ",", "duration", "[", "'NREM2'", "]", ",", "'total N2 duration between LOFF and LON'", "]", ")", "cf", ".", "writerow", "(", "[", "'N3 duration'", ",", "''", ",", "'Epochs'", ",", "duration", "[", "'NREM3'", "]", "*", "n_ep_per_min", ",", "'Minutes'", ",", "duration", "[", "'NREM3'", "]", ",", "'total N3 duration between LOFF and LON'", "]", ")", "cf", ".", "writerow", "(", "[", "'REM duration'", ",", "''", ",", "'Epochs'", ",", "duration", "[", "'REM'", "]", "*", "n_ep_per_min", ",", "'Minutes'", ",", "duration", "[", "'REM'", "]", ",", "'total REM duration between LOFF and LON'", "]", ")", "cf", ".", "writerow", "(", "[", "'Artefact duration'", ",", "''", ",", "'Epochs'", ",", "duration", "[", "'Artefact'", "]", "*", "n_ep_per_min", ",", "'Minutes'", ",", "duration", "[", "'Artefact'", "]", ",", "'total Artefact duration between LOFF and LON'", "]", ")", "cf", ".", "writerow", "(", "[", "'Movement duration'", ",", "''", ",", "'Epochs'", ",", "duration", "[", "'Movement'", "]", "*", "n_ep_per_min", ",", "'Minutes'", ",", "duration", "[", "'Movement'", "]", ",", "'total Movement duration between LOFF and LON'", "]", ")", "cf", ".", "writerow", "(", "[", "'Total sleep period'", ",", "'TSP'", ",", "'Epochs'", ",", "total_slp_period", "*", "n_ep_per_min", ",", "'Minutes'", ",", "total_slp_period", ",", "'WASO + N1 + N2 + N3 + REM'", "]", ")", "cf", ".", "writerow", "(", "[", "'Total sleep time'", ",", "'TST'", ",", "'Epochs'", ",", "total_slp_time", "*", "n_ep_per_min", ",", "'Minutes'", ",", "total_slp_time", ",", "'N1 + N2 + N3 + REM'", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep efficiency'", ",", "'SE'", ",", "'%'", ",", "slp_eff", "*", "100", ",", "''", ",", "''", ",", "'TST / TDT'", "]", ")", "cf", ".", "writerow", "(", "[", "'W % TSP'", ",", "''", ",", "'%'", ",", "waso", "*", "100", "/", "total_slp_period", ",", "''", ",", "''", ",", "'WASO / TSP'", "]", ")", "cf", ".", "writerow", "(", "[", "'N1 % TSP'", ",", "''", ",", "'%'", ",", "duration", "[", "'NREM1'", "]", "*", "100", "/", "total_slp_period", ",", "''", ",", "''", ",", "'N1 / TSP'", "]", ")", "cf", ".", "writerow", "(", "[", "'N2 % TSP'", ",", "''", ",", "'%'", ",", "duration", "[", "'NREM2'", "]", "*", "100", "/", "total_slp_period", ",", "''", ",", "''", ",", "'N2 / TSP'", "]", ")", "cf", ".", "writerow", "(", "[", "'N3 % TSP'", ",", "''", ",", "'%'", ",", "duration", "[", "'NREM3'", "]", "*", "100", "/", "total_slp_period", ",", "''", ",", "''", ",", "'N3 / TSP'", "]", ")", "cf", ".", "writerow", "(", "[", "'REM % TSP'", ",", "''", ",", "'%'", ",", "duration", "[", "'REM'", "]", "*", "100", "/", "total_slp_period", ",", "''", ",", "''", ",", "'REM / TSP'", "]", ")", "cf", ".", "writerow", "(", "[", "'N1 % TST'", ",", "''", ",", "'%'", ",", "duration", "[", "'NREM1'", "]", "*", "100", "/", "total_slp_time", ",", "''", ",", "''", ",", "'N1 / TST'", "]", ")", "cf", ".", "writerow", "(", "[", "'N2 % TST'", ",", "''", ",", "'%'", ",", "duration", "[", "'NREM2'", "]", "*", "100", "/", "total_slp_time", ",", "''", ",", "''", ",", "'N2 / TST'", "]", ")", "cf", ".", "writerow", "(", "[", "'N3 % TST'", ",", "''", ",", "'%'", ",", "duration", "[", "'NREM3'", "]", "*", "100", "/", "total_slp_time", ",", "''", ",", "''", ",", "'N3 / TST'", "]", ")", "cf", ".", "writerow", "(", "[", "'REM % TST'", ",", "''", ",", "'%'", ",", "duration", "[", "'REM'", "]", "*", "100", "/", "total_slp_time", ",", "''", ",", "''", ",", "'REM / TST'", "]", ")", "cf", ".", "writerow", "(", "[", "'Switch'", ",", "''", ",", "'N'", ",", "switch", ",", "''", ",", "''", ",", "'number of stage shifts'", "]", ")", "cf", ".", "writerow", "(", "[", "'Switch %'", ",", "''", ",", "'% epochs'", ",", "switch", "*", "100", "/", "total_slp_period", "/", "n_ep_per_min", ",", "'% minutes'", ",", "switch", "*", "100", "/", "total_slp_period", ",", "'switch / TSP'", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep fragmentation'", ",", "''", ",", "'N'", ",", "slp_frag", ",", "''", ",", "''", ",", "(", "'number of shifts to a lighter stage '", "'(W > N1 > N2 > N3; W > N1 > REM)'", ")", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep fragmentation index'", ",", "'SFI'", ",", "'% epochs'", ",", "slp_frag", "*", "100", "/", "total_slp_time", "/", "n_ep_per_min", ",", "'% minutes'", ",", "slp_frag", "*", "100", "/", "total_slp_time", ",", "'sleep fragmentation / TST'", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep latency to N1'", ",", "'SLN1'", ",", "'Epochs'", ",", "latency", "[", "'NREM1'", "]", "*", "n_ep_per_min", ",", "'Minutes'", ",", "latency", "[", "'NREM1'", "]", ",", "'first N1 epoch - LOFF'", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep latency to N2'", ",", "'SLN2'", ",", "'Epochs'", ",", "latency", "[", "'NREM2'", "]", "*", "n_ep_per_min", ",", "'Minutes'", ",", "latency", "[", "'NREM2'", "]", ",", "'first N2 epoch - LOFF'", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep latency to N3'", ",", "'SLN3'", ",", "'Epochs'", ",", "latency", "[", "'NREM3'", "]", "*", "n_ep_per_min", ",", "'Minutes'", ",", "latency", "[", "'NREM3'", "]", ",", "'first N3 epoch - LOFF'", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep latency to REM'", ",", "'SLREM'", ",", "'Epochs'", ",", "latency", "[", "'REM'", "]", "*", "n_ep_per_min", ",", "'Minutes'", ",", "latency", "[", "'REM'", "]", ",", "'first REM epoch - LOFF'", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep latency to consolidated NREM, 5 min'", ",", "'SLCNREM5'", ",", "'Epochs'", ",", "slcnrem5", "*", "n_ep_per_min", ",", "'Minutes'", ",", "slcnrem5", ",", "(", "'start of first uninterrupted 5-minute period of '", "'N2 and/or N3 - LOFF'", ")", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep latency to consolidated NREM, 10 min'", ",", "'SLCNREM10'", ",", "'Epochs'", ",", "slcnrem10", "*", "n_ep_per_min", ",", "'Minutes'", ",", "slcnrem10", ",", "(", "'start of first uninterrupted 10-minute period of '", "'N2 and/or N3 - LOFF'", ")", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep latency to consolidated N3, 5 min'", ",", "'SLCN35'", ",", "'Epochs'", ",", "slcn35", "*", "n_ep_per_min", ",", "'Minutes'", ",", "slcn35", ",", "(", "'start of first uninterrupted 5-minute period of '", "'N3 - LOFF'", ")", "]", ")", "cf", ".", "writerow", "(", "[", "'Sleep latency to consolidated N3, 10 min'", ",", "'SLCN310'", ",", "'Epochs'", ",", "slcn310", "*", "n_ep_per_min", ",", "'Minutes'", ",", "slcn310", ",", "(", "'start of first uninterrupted 10-minute period of '", "'N3 - LOFF'", ")", "]", ")", "for", "i", "in", "range", "(", "len", "(", "cycles", ")", ")", ":", "one_cyc", "=", "cyc_stats", "[", "i", "]", "cf", ".", "writerow", "(", "[", "''", "]", ")", "cf", ".", "writerow", "(", "[", "f'Cycle {i + 1}'", "]", ")", "cf", ".", "writerow", "(", "[", "'Cycle % duration'", ",", "''", ",", "'%'", ",", "(", "one_cyc", "[", "'tsp'", "]", "*", "100", "/", "total_slp_period", "/", "n_ep_per_min", ")", ",", "''", ",", "''", ",", "'cycle TSP / night TSP'", "]", ")", "for", "stage", "in", "[", "'Wake'", ",", "'NREM1'", ",", "'NREM2'", ",", "'NREM3'", ",", "'REM'", ",", "'Artefact'", ",", "'Movement'", "]", ":", "cf", ".", "writerow", "(", "[", "f'{stage} (c{i + 1})'", ",", "''", ",", "'Epochs'", ",", "one_cyc", "[", "'duration'", "]", "[", "stage", "]", ",", "'Minutes'", ",", "one_cyc", "[", "'duration'", "]", "[", "stage", "]", "/", "n_ep_per_min", ",", "f'total {stage} duration in cycle {i + 1}'", "]", ")", "cf", ".", "writerow", "(", "[", "f'Total sleep period (c{i + 1})'", ",", "f'TSP (c{i + 1})'", ",", "'Epochs'", ",", "one_cyc", "[", "'tsp'", "]", ",", "'Minutes'", ",", "one_cyc", "[", "'tsp'", "]", "/", "n_ep_per_min", ",", "f'Wake + N1 + N2 + N3 + REM in cycle {i + 1}'", "]", ")", "cf", ".", "writerow", "(", "[", "f'Total sleep time (c{i + 1})'", ",", "f'TST (c{i + 1})'", ",", "'Epochs'", ",", "one_cyc", "[", "'tst'", "]", ",", "'Minutes'", ",", "one_cyc", "[", "'tst'", "]", "/", "n_ep_per_min", ",", "f'N1 + N2 + N3 + REM in cycle {i + 1}'", "]", ")", "cf", ".", "writerow", "(", "[", "f'Sleep efficiency (c{i + 1})'", ",", "f'SE (c{i + 1})'", ",", "'%'", ",", "one_cyc", "[", "'slp_eff'", "]", "*", "100", ",", "''", ",", "''", ",", "f'TST / TSP in cycle {i + 1}'", "]", ")", "for", "denom", "in", "[", "'TSP'", ",", "'TST'", "]", ":", "for", "stage", "in", "[", "'Wake'", ",", "'NREM1'", ",", "'NREM2'", ",", "'NREM3'", ",", "'REM'", "]", ":", "cf", ".", "writerow", "(", "[", "f'{stage} % {denom} (c{i + 1})'", ",", "''", ",", "'%'", ",", "(", "one_cyc", "[", "'duration'", "]", "[", "stage", "]", "/", "one_cyc", "[", "denom", ".", "lower", "(", ")", "]", ")", "*", "100", ",", "''", ",", "''", ",", "f'{stage} / {denom} in cycle {i + 1}'", "]", ")", "cf", ".", "writerow", "(", "[", "f'Switch (c{i + 1})'", ",", "''", ",", "'N'", ",", "one_cyc", "[", "'switch'", "]", ",", "''", ",", "''", ",", "f'number of stage shifts in cycle {i + 1}'", "]", ")", "cf", ".", "writerow", "(", "[", "f'Switch % (c{i + 1})'", ",", "''", ",", "'% epochs'", ",", "(", "one_cyc", "[", "'switch'", "]", "*", "100", "/", "one_cyc", "[", "'tsp'", "]", ")", ",", "'% minutes'", ",", "(", "one_cyc", "[", "'switch'", "]", "*", "100", "*", "n_ep_per_min", "/", "one_cyc", "[", "'tsp'", "]", ")", ",", "f'switch / TSP in cycle {i + 1}'", "]", ")", "cf", ".", "writerow", "(", "[", "f'Sleep fragmentation (c{i + 1})'", ",", "''", ",", "'N'", ",", "one_cyc", "[", "'slp_frag'", "]", ",", "''", ",", "''", ",", "'number of shifts to a lighter stage in cycle '", "f'{i + 1}'", "]", ")", "cf", ".", "writerow", "(", "[", "f'Sleep fragmentation index (c{i + 1})'", ",", "f'SFI (c{i + 1})'", ",", "'% epochs'", ",", "(", "one_cyc", "[", "'slp_frag'", "]", "*", "100", "/", "one_cyc", "[", "'tsp'", "]", ")", ",", "'% minutes'", ",", "(", "one_cyc", "[", "'slp_frag'", "]", "*", "100", "*", "n_ep_per_min", "/", "one_cyc", "[", "'tsp'", "]", ")", ",", "f'sleep fragmentation / TSP in cycle {i + 1}'", "]", ")", "return", "slp_onset_lat", ",", "waso", ",", "total_slp_time" ]

[ "Create", "CSV", "with", "sleep", "statistics", "." ]

[ "def", "dispatch", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "super", "(", "StrainUpdate", ",", "self", ")", ".", "dispatch", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "This", "decorator", "sets", "this", "view", "to", "have", "restricted", "permissions", "." ]

[ "def", "auto_update_attrs_from_kwargs", "(", "method", ")", ":", "def", "wrapped", "(", "self", ",", "*", "*", "kwargs", ")", ":", "# method signature introspection", "argspec", "=", "inspect", ".", "getargspec", "(", "method", ")", "defaults", "=", "argspec", ".", "defaults", "or", "(", ")", "nb_args", ",", "nb_defaults", "=", "len", "(", "argspec", ".", "args", ")", ",", "len", "(", "defaults", ")", "# construct a dict of method's keyword arguments", "options", "=", "dict", "(", "zip", "(", "argspec", ".", "args", "[", "nb_args", "-", "nb_defaults", ":", "]", ",", "defaults", ")", ")", "# update it with actual keyword arguments", "options", ".", "update", "(", "kwargs", ")", "# update attributes of instance", "self", ".", "__dict__", ".", "update", "(", "options", ")", "method", "(", "self", ",", "*", "*", "kwargs", ")", "return", "wrapped" ]

[ "this", "decorator", "will", "update", "the", "attributes", "of", "an", "instance", "object", "with", "all", "the", "kwargs", "of", "the", "decorated", "method", "updated", "with", "the", "kwargs", "of", "the", "actual", "call", ".", "This", "saves", "you", "from", "boring", "typing", ":", "self", ".", "xxxx", "=", "xxxx", "self", ".", "yyyy", "=", "yyyy", "...", "in", "the", "decorated", "method", "(", "typically", "__init__", ")" ]

[ "def", "get_fun", "(", "fun", ")", ":", "conn", ",", "mdb", "=", "_get_conn", "(", "ret", "=", "None", ")", "ret", "=", "{", "}", "rdata", "=", "mdb", ".", "saltReturns", ".", "find_one", "(", "{", "'fun'", ":", "fun", "}", ",", "{", "'_id'", ":", "0", "}", ")", "if", "rdata", ":", "ret", "=", "rdata", "return", "ret" ]

[ "Return", "the", "most", "recent", "jobs", "that", "have", "executed", "the", "named", "function" ]

[ "def", "unload", "(", "self", ",", "core", ")", ":", "params", "=", "{", "'action'", ":", "'UNLOAD'", ",", "'core'", ":", "core", ",", "}", "return", "self", ".", "_get_url", "(", "self", ".", "url", ",", "params", "=", "params", ")" ]

[ "http", ":", "//", "wiki", ".", "apache", ".", "org", "/", "solr", "/", "CoreAdmin#head", "-", "f5055a885932e2c25096a8856de840b06764d143" ]

[ "def", "unassign", "(", "self", ")", ":", "if", "self", ".", "object_uuid", "is", "None", "and", "self", ".", "object_type", "is", "None", ":", "return", "True", "try", ":", "with", "db", ".", "session", ".", "begin_nested", "(", ")", ":", "if", "self", ".", "is_redirected", "(", ")", ":", "db", ".", "session", ".", "delete", "(", "Redirect", ".", "query", ".", "get", "(", "self", ".", "object_uuid", ")", ")", "# Only registered PIDs can be redirected so we set it back", "# to registered", "self", ".", "status", "=", "PIDStatus", ".", "REGISTERED", "self", ".", "object_type", "=", "None", "self", ".", "object_uuid", "=", "None", "db", ".", "session", ".", "add", "(", "self", ")", "except", "SQLAlchemyError", ":", "logger", ".", "exception", "(", "\"Failed to unassign object.\"", ".", "format", "(", "self", ")", ",", "extra", "=", "dict", "(", "pid", "=", "self", ")", ")", "raise", "logger", ".", "info", "(", "\"Unassigned object from {0}.\"", ".", "format", "(", "self", ")", ",", "extra", "=", "dict", "(", "pid", "=", "self", ")", ")", "return", "True" ]

[ "Unassign", "the", "registered", "object", "." ]

[ "def", "summary", "(", "args", ")", ":", "from", "jcvi", ".", "utils", ".", "cbook", "import", "thousands", "from", "jcvi", ".", "utils", ".", "table", "import", "tabulate", "p", "=", "OptionParser", "(", "summary", ".", "__doc__", ")", "p", ".", "add_option", "(", "\"--counts\"", ",", "help", "=", "\"Print SNP counts in a txt file [default: %default]\"", ")", "p", ".", "add_option", "(", "\"--bed\"", ",", "help", "=", "\"Print SNPs locations in a bed file [default: %default]\"", ")", "opts", ",", "args", "=", "p", ".", "parse_args", "(", "args", ")", "if", "len", "(", "args", ")", "!=", "2", ":", "sys", ".", "exit", "(", "not", "p", ".", "print_help", "(", ")", ")", "txtfile", ",", "fastafile", "=", "args", "bedfw", "=", "open", "(", "opts", ".", "bed", ",", "\"w\"", ")", "if", "opts", ".", "bed", "else", "None", "fp", "=", "open", "(", "txtfile", ")", "header", "=", "fp", ".", "next", "(", ")", ".", "split", "(", ")", "# Header", "snps", "=", "defaultdict", "(", "list", ")", "# contig => list of loci", "combinations", "=", "defaultdict", "(", "int", ")", "intraSNPs", "=", "interSNPs", "=", "0", "distinctSet", "=", "set", "(", ")", "# set of genes that show A-B pattern", "ref", ",", "alt", "=", "header", "[", "1", ":", "3", "]", "snpcounts", ",", "goodsnpcounts", "=", "defaultdict", "(", "int", ")", ",", "defaultdict", "(", "int", ")", "for", "row", "in", "fp", ":", "atoms", "=", "row", ".", "split", "(", ")", "assert", "len", "(", "atoms", ")", "==", "3", ",", "\"Only three-column file is supported\"", "locus", ",", "intra", ",", "inter", "=", "atoms", "ctg", ",", "pos", "=", "locus", ".", "rsplit", "(", "\".\"", ",", "1", ")", "pos", "=", "int", "(", "pos", ")", "snps", "[", "ctg", "]", ".", "append", "(", "pos", ")", "snpcounts", "[", "ctg", "]", "+=", "1", "if", "intra", "==", "'X'", ":", "intraSNPs", "+=", "1", "if", "inter", "in", "(", "'B'", ",", "'X'", ")", ":", "interSNPs", "+=", "1", "if", "intra", "==", "'A'", "and", "inter", "==", "'B'", ":", "distinctSet", ".", "add", "(", "ctg", ")", "goodsnpcounts", "[", "ctg", "]", "+=", "1", "# Tabulate all possible combinations", "intra", "=", "ref", "+", "\"-\"", "+", "intra", "inter", "=", "alt", "+", "\"-\"", "+", "inter", "combinations", "[", "(", "intra", ",", "inter", ")", "]", "+=", "1", "if", "bedfw", ":", "print", "(", "\"\\t\"", ".", "join", "(", "str", "(", "x", ")", "for", "x", "in", "(", "ctg", ",", "pos", "-", "1", ",", "pos", ",", "locus", ")", ")", ",", "file", "=", "bedfw", ")", "if", "bedfw", ":", "logging", ".", "debug", "(", "\"SNP locations written to `{0}`.\"", ".", "format", "(", "opts", ".", "bed", ")", ")", "bedfw", ".", "close", "(", ")", "nsites", "=", "sum", "(", "len", "(", "x", ")", "for", "x", "in", "snps", ".", "values", "(", ")", ")", "sizes", "=", "Sizes", "(", "fastafile", ")", "bpsize", "=", "sizes", ".", "totalsize", "snprate", "=", "lambda", "a", ":", "a", "*", "1000.", "/", "bpsize", "m", "=", "\"Dataset `{0}` contains {1} contigs ({2} bp).\\n\"", ".", "format", "(", "fastafile", ",", "len", "(", "sizes", ")", ",", "thousands", "(", "bpsize", ")", ")", "m", "+=", "\"A total of {0} SNPs within {1} contigs ({2} bp).\\n\"", ".", "format", "(", "nsites", ",", "len", "(", "snps", ")", ",", "thousands", "(", "sum", "(", "sizes", ".", "mapping", "[", "x", "]", "for", "x", "in", "snps", ".", "keys", "(", ")", ")", ")", ")", "m", "+=", "\"SNP rate: {0:.1f}/Kb, \"", ".", "format", "(", "snprate", "(", "nsites", ")", ")", "m", "+=", "\"IntraSNPs: {0} ({1:.1f}/Kb), InterSNPs: {2} ({3:.1f}/Kb)\"", ".", "format", "(", "intraSNPs", ",", "snprate", "(", "intraSNPs", ")", ",", "interSNPs", ",", "snprate", "(", "interSNPs", ")", ")", "print", "(", "m", ",", "file", "=", "sys", ".", "stderr", ")", "print", "(", "tabulate", "(", "combinations", ")", ",", "file", "=", "sys", ".", "stderr", ")", "leg", "=", "\"Legend: A - homozygous same, B - homozygous different, X - heterozygous\"", "print", "(", "leg", ",", "file", "=", "sys", ".", "stderr", ")", "tag", "=", "(", "ref", "+", "\"-A\"", ",", "alt", "+", "\"-B\"", ")", "distinctSNPs", "=", "combinations", "[", "tag", "]", "tag", "=", "str", "(", "tag", ")", ".", "replace", "(", "\"'\"", ",", "\"\"", ")", "print", "(", "\"A total of {0} disparate {1} SNPs in {2} contigs.\"", ".", "format", "(", "distinctSNPs", ",", "tag", ",", "len", "(", "distinctSet", ")", ")", ",", "file", "=", "sys", ".", "stderr", ")", "if", "not", "opts", ".", "counts", ":", "return", "snpcountsfile", "=", "opts", ".", "counts", "fw", "=", "open", "(", "snpcountsfile", ",", "\"w\"", ")", "header", "=", "\"\\t\"", ".", "join", "(", "(", "\"Contig\"", ",", "\"#_SNPs\"", ",", "\"#_AB_SNP\"", ")", ")", "print", "(", "header", ",", "file", "=", "fw", ")", "assert", "sum", "(", "snpcounts", ".", "values", "(", ")", ")", "==", "nsites", "assert", "sum", "(", "goodsnpcounts", ".", "values", "(", ")", ")", "==", "distinctSNPs", "for", "ctg", "in", "sorted", "(", "snps", ".", "keys", "(", ")", ")", ":", "snpcount", "=", "snpcounts", "[", "ctg", "]", "goodsnpcount", "=", "goodsnpcounts", "[", "ctg", "]", "print", "(", "\"\\t\"", ".", "join", "(", "str", "(", "x", ")", "for", "x", "in", "(", "ctg", ",", "snpcount", ",", "goodsnpcount", ")", ")", ",", "file", "=", "fw", ")", "fw", ".", "close", "(", ")", "logging", ".", "debug", "(", "\"SNP counts per contig is written to `{0}`.\"", ".", "format", "(", "snpcountsfile", ")", ")" ]

[ "%prog", "summary", "txtfile", "fastafile" ]

[ "def", "caller", "(", "self", ",", "fun", ",", "*", "*", "kwargs", ")", ":", "self", ".", "client_cache", "[", "'caller'", "]", ".", "cmd", "(", "fun", ",", "*", "kwargs", "[", "'arg'", "]", ",", "*", "*", "kwargs", "[", "'kwarg'", "]", ")" ]

[ "Wrap", "LocalCaller", "to", "execute", "remote", "exec", "functions", "locally", "on", "the", "Minion" ]

[ "def", "download_interim_for_gssha", "(", "main_directory", ",", "start_datetime", ",", "end_datetime", ",", "leftlon", "=", "-", "180", ",", "rightlon", "=", "180", ",", "toplat", "=", "90", ",", "bottomlat", "=", "-", "90", ",", "precip_only", "=", "False", ")", ":", "# parameters: https://software.ecmwf.int/wiki/display/CKB/Details+of+ERA-Interim+parameters", "# import here to make sure it is not required to run", "from", "ecmwfapi", "import", "ECMWFDataServer", "server", "=", "ECMWFDataServer", "(", ")", "try", ":", "mkdir", "(", "main_directory", ")", "except", "OSError", ":", "pass", "download_area", "=", "\"{toplat}/{leftlon}/{bottomlat}/{rightlon}\"", ".", "format", "(", "toplat", "=", "toplat", ",", "leftlon", "=", "leftlon", ",", "bottomlat", "=", "bottomlat", ",", "rightlon", "=", "rightlon", ")", "download_datetime", "=", "start_datetime", "interim_request", "=", "{", "'dataset'", ":", "\"interim\"", ",", "# 'oper' specifies the high resolution daily data, as opposed to monthly means, wave, eda edmm, etc.", "'stream'", ":", "\"oper\"", ",", "# Surface level, as opposed to pressure level (pl) or model level (ml)", "'levtype'", ":", "\"sfc\"", ",", "# The spatial resolution in ERA interim is 80 km globally on a Gaussian grid.", "# Here we us lat/long with 0.75 degrees, which is approximately the equivalent of 80km.", "'grid'", ":", "\"0.5/0.5\"", ",", "'area'", ":", "download_area", ",", "'format'", ":", "'netcdf'", ",", "}", "while", "download_datetime", "<=", "end_datetime", ":", "interim_request", "[", "'date'", "]", "=", "download_datetime", ".", "strftime", "(", "\"%Y-%m-%d\"", ")", "if", "not", "precip_only", ":", "download_file", "=", "path", ".", "join", "(", "main_directory", ",", "\"erai_gssha_{0}_an.nc\"", ".", "format", "(", "download_datetime", ".", "strftime", "(", "\"%Y%m%d\"", ")", ")", ")", "if", "not", "path", ".", "exists", "(", "download_file", ")", ":", "# We want instantaneous parameters, which are archived as type Analysis ('an') as opposed to forecast (fc)", "interim_request", "[", "'type'", "]", "=", "\"an\"", "# For parameter codes see the ECMWF parameter database at http://apps.ecmwf.int/codes/grib/param-db", "interim_request", "[", "'param'", "]", "=", "\"2t/2d/sp/10u/10v/tcc\"", "# step 0 is analysis, 3-12 is forecast", "interim_request", "[", "'step'", "]", "=", "\"0\"", "# ERA Interim provides 6-hourly analysis", "interim_request", "[", "'time'", "]", "=", "\"00/06/12/18\"", "interim_request", "[", "'target'", "]", "=", "download_file", "server", ".", "retrieve", "(", "interim_request", ")", "download_file", "=", "path", ".", "join", "(", "main_directory", ",", "\"erai_gssha_{0}_1_fc.nc\"", ".", "format", "(", "download_datetime", ".", "strftime", "(", "\"%Y%m%d\"", ")", ")", ")", "if", "not", "path", ".", "exists", "(", "download_file", ")", ":", "interim_request", "[", "'type'", "]", "=", "\"fc\"", "interim_request", "[", "'param'", "]", "=", "\"2t/2d/sp/10u/10v/tcc\"", "interim_request", "[", "'step'", "]", "=", "\"3\"", "interim_request", "[", "'time'", "]", "=", "\"00/06/12/18\"", "interim_request", "[", "'target'", "]", "=", "download_file", "server", ".", "retrieve", "(", "interim_request", ")", "download_file", "=", "path", ".", "join", "(", "main_directory", ",", "\"erai_gssha_{0}_fc.nc\"", ".", "format", "(", "download_datetime", ".", "strftime", "(", "\"%Y%m%d\"", ")", ")", ")", "if", "not", "path", ".", "exists", "(", "download_file", ")", ":", "interim_request", "[", "'type'", "]", "=", "\"fc\"", "interim_request", "[", "'param'", "]", "=", "\"tp/ssrd\"", "interim_request", "[", "'step'", "]", "=", "\"3/6/9/12\"", "interim_request", "[", "'time'", "]", "=", "\"00/12\"", "interim_request", "[", "'target'", "]", "=", "download_file", "server", ".", "retrieve", "(", "interim_request", ")", "# TODO: READ FILE AND MODIFY VALUES SO IT IS NOT INCREMENTAL", "# https://software.ecmwf.int/wiki/pages/viewpage.action?pageId=56658233", "# You need total precipitation for every 6 hours.", "# Daily total precipitation (tp) is only available with a forecast base time 00:00 and 12:00,", "# so to get tp for every 6 hours you will need to extract (and for the second and fourth period calculate):", "# tp(00-06) = (time 00, step 6)", "# tp(06-12) = (time 00, step 12) minus (time 00, step 6)", "# tp(12-18) = (time 12, step 6)", "# tp(18-24) = (time 12, step 12) minus (time 12, step 6)", "# (Note the units for total precipitation is meters.)", "tmp_download_file", "=", "download_file", "+", "'_tmp'", "with", "xr", ".", "open_dataset", "(", "download_file", ")", "as", "xd", ":", "diff_xd", "=", "xd", ".", "diff", "(", "'time'", ")", "xd", ".", "tp", "[", "1", ":", "4", "]", "=", "diff_xd", ".", "tp", "[", ":", "3", "]", "xd", ".", "tp", "[", "5", ":", "]", "=", "diff_xd", ".", "tp", "[", "4", ":", "]", "xd", ".", "ssrd", "[", "1", ":", "4", "]", "=", "diff_xd", ".", "ssrd", "[", ":", "3", "]", "xd", ".", "ssrd", "[", "5", ":", "]", "=", "diff_xd", ".", "ssrd", "[", "4", ":", "]", "xd", ".", "to_netcdf", "(", "tmp_download_file", ")", "remove", "(", "download_file", ")", "rename", "(", "tmp_download_file", ",", "download_file", ")", "download_file", "=", "path", ".", "join", "(", "main_directory", ",", "\"erai_gssha_{0}_0_fc.nc\"", ".", "format", "(", "download_datetime", ".", "strftime", "(", "\"%Y%m%d\"", ")", ")", ")", "if", "download_datetime", "<=", "start_datetime", "and", "not", "path", ".", "exists", "(", "download_file", ")", ":", "loc_download_date", "=", "(", "download_datetime", "-", "timedelta", "(", "1", ")", ")", ".", "strftime", "(", "\"%Y-%m-%d\"", ")", "interim_request", "[", "'type'", "]", "=", "\"fc\"", "interim_request", "[", "'param'", "]", "=", "\"tp/ssrd\"", "interim_request", "[", "'step'", "]", "=", "\"9/12\"", "interim_request", "[", "'time'", "]", "=", "\"12\"", "interim_request", "[", "'target'", "]", "=", "download_file", "interim_request", "[", "'date'", "]", "=", "loc_download_date", "server", ".", "retrieve", "(", "interim_request", ")", "# convert to incremental (see above)", "tmp_download_file", "=", "download_file", "+", "'_tmp'", "with", "xr", ".", "open_dataset", "(", "download_file", ")", "as", "xd", ":", "inc_xd", "=", "xd", ".", "diff", "(", "'time'", ")", "inc_xd", ".", "to_netcdf", "(", "tmp_download_file", ")", "remove", "(", "download_file", ")", "rename", "(", "tmp_download_file", ",", "download_file", ")", "download_datetime", "+=", "timedelta", "(", "1", ")" ]

[ "Function", "to", "download", "ERA5", "data", "for", "GSSHA" ]

[ "def", "search", "(", "self", ",", "criterion", ",", "table", ",", "columns", "=", "''", ",", "fetch", "=", "False", ",", "radius", "=", "1", "/", "60.", ",", "use_converters", "=", "False", ",", "sql_search", "=", "False", ")", ":", "# Get list of columns to search and format properly", "t", "=", "self", ".", "query", "(", "\"PRAGMA table_info({})\"", ".", "format", "(", "table", ")", ",", "unpack", "=", "True", ",", "fmt", "=", "'table'", ")", "all_columns", "=", "t", "[", "'name'", "]", ".", "tolist", "(", ")", "types", "=", "t", "[", "'type'", "]", ".", "tolist", "(", ")", "columns", "=", "columns", "or", "all_columns", "columns", "=", "np", ".", "asarray", "(", "[", "columns", "]", "if", "isinstance", "(", "columns", ",", "str", ")", "else", "columns", ")", "# Separate good and bad columns and corresponding types", "badcols", "=", "columns", "[", "~", "np", ".", "in1d", "(", "columns", ",", "all_columns", ")", "]", "columns", "=", "columns", "[", "np", ".", "in1d", "(", "columns", ",", "all_columns", ")", "]", "columns", "=", "np", ".", "array", "(", "[", "c", "for", "c", "in", "all_columns", "if", "c", "in", "columns", "]", ")", "types", "=", "np", ".", "array", "(", "[", "t", "for", "c", ",", "t", "in", "zip", "(", "all_columns", ",", "types", ")", "if", "c", "in", "columns", "]", ")", "[", "np", ".", "in1d", "(", "columns", ",", "all_columns", ")", "]", "for", "col", "in", "badcols", ":", "print", "(", "\"'{}' is not a column in the {} table.\"", ".", "format", "(", "col", ",", "table", ".", "upper", "(", ")", ")", ")", "# Coordinate search", "if", "sys", ".", "version_info", "[", "0", "]", "==", "2", ":", "str_check", "=", "(", "str", ",", "unicode", ")", "else", ":", "str_check", "=", "str", "results", "=", "''", "if", "isinstance", "(", "criterion", ",", "(", "tuple", ",", "list", ",", "np", ".", "ndarray", ")", ")", ":", "try", ":", "if", "sql_search", ":", "q", "=", "\"SELECT * FROM {} WHERE ra BETWEEN \"", ".", "format", "(", "table", ")", "+", "str", "(", "criterion", "[", "0", "]", "-", "radius", ")", "+", "\" AND \"", "+", "str", "(", "criterion", "[", "0", "]", "+", "radius", ")", "+", "\" AND dec BETWEEN \"", "+", "str", "(", "criterion", "[", "1", "]", "-", "radius", ")", "+", "\" AND \"", "+", "str", "(", "criterion", "[", "1", "]", "+", "radius", ")", "results", "=", "self", ".", "query", "(", "q", ",", "fmt", "=", "'table'", ")", "else", ":", "t", "=", "self", ".", "query", "(", "'SELECT id,ra,dec FROM sources'", ",", "fmt", "=", "'table'", ")", "df", "=", "t", ".", "to_pandas", "(", ")", "df", "[", "[", "'ra'", ",", "'dec'", "]", "]", "=", "df", "[", "[", "'ra'", ",", "'dec'", "]", "]", ".", "apply", "(", "pd", ".", "to_numeric", ")", "# convert everything to floats", "mask", "=", "df", "[", "'ra'", "]", ".", "isnull", "(", ")", "df", "=", "df", "[", "~", "mask", "]", "df", "[", "'theta'", "]", "=", "df", ".", "apply", "(", "ang_sep", ",", "axis", "=", "1", ",", "args", "=", "(", "criterion", "[", "0", "]", ",", "criterion", "[", "1", "]", ")", ")", "good", "=", "df", "[", "'theta'", "]", "<=", "radius", "if", "sum", "(", "good", ")", ">", "0", ":", "params", "=", "\", \"", ".", "join", "(", "[", "'{}'", ".", "format", "(", "s", ")", "for", "s", "in", "df", "[", "good", "]", "[", "'id'", "]", ".", "tolist", "(", ")", "]", ")", "try", ":", "results", "=", "self", ".", "query", "(", "'SELECT * FROM {} WHERE source_id IN ({})'", ".", "format", "(", "table", ",", "params", ")", ",", "fmt", "=", "'table'", ")", "except", ":", "results", "=", "self", ".", "query", "(", "'SELECT * FROM {} WHERE id IN ({})'", ".", "format", "(", "table", ",", "params", ")", ",", "fmt", "=", "'table'", ")", "except", ":", "print", "(", "\"Could not search {} table by coordinates {}. Try again.\"", ".", "format", "(", "table", ".", "upper", "(", ")", ",", "criterion", ")", ")", "# Text string search of columns with 'TEXT' data type", "elif", "isinstance", "(", "criterion", ",", "str_check", ")", "and", "any", "(", "columns", ")", "and", "'TEXT'", "in", "types", ":", "try", ":", "q", "=", "\"SELECT * FROM {} WHERE {}\"", ".", "format", "(", "table", ",", "' OR '", ".", "join", "(", "[", "r\"REPLACE(\"", "+", "c", "+", "r\",' ','') like '%\"", "+", "criterion", ".", "replace", "(", "' '", ",", "''", ")", "+", "r\"%'\"", "for", "c", ",", "t", "in", "zip", "(", "columns", ",", "types", "[", "np", ".", "in1d", "(", "columns", ",", "all_columns", ")", "]", ")", "if", "t", "==", "'TEXT'", "]", ")", ")", "results", "=", "self", ".", "query", "(", "q", ",", "fmt", "=", "'table'", ",", "use_converters", "=", "use_converters", ")", "except", ":", "print", "(", "\"Could not search {} table by string {}. Try again.\"", ".", "format", "(", "table", ".", "upper", "(", ")", ",", "criterion", ")", ")", "# Integer search of columns with 'INTEGER' data type", "elif", "isinstance", "(", "criterion", ",", "int", ")", ":", "try", ":", "q", "=", "\"SELECT * FROM {} WHERE {}\"", ".", "format", "(", "table", ",", "' OR '", ".", "join", "(", "[", "'{}={}'", ".", "format", "(", "c", ",", "criterion", ")", "for", "c", ",", "t", "in", "zip", "(", "columns", ",", "types", "[", "np", ".", "in1d", "(", "columns", ",", "all_columns", ")", "]", ")", "if", "t", "==", "'INTEGER'", "]", ")", ")", "results", "=", "self", ".", "query", "(", "q", ",", "fmt", "=", "'table'", ",", "use_converters", "=", "use_converters", ")", "except", ":", "print", "(", "\"Could not search {} table by id {}. Try again.\"", ".", "format", "(", "table", ".", "upper", "(", ")", ",", "criterion", ")", ")", "# Problem!", "else", ":", "print", "(", "\"Could not search {} table by '{}'. Try again.\"", ".", "format", "(", "table", ".", "upper", "(", ")", ",", "criterion", ")", ")", "# Print or return the results", "if", "fetch", ":", "return", "results", "or", "at", ".", "Table", "(", "names", "=", "columns", ",", "dtype", "=", "[", "type_dict", "[", "t", "]", "for", "t", "in", "types", "]", ",", "masked", "=", "True", ")", "else", ":", "if", "results", ":", "pprint", "(", "results", ",", "title", "=", "table", ".", "upper", "(", ")", ")", "else", ":", "print", "(", "\"No results found for {} in the {} table.\"", ".", "format", "(", "criterion", ",", "table", ".", "upper", "(", ")", ")", ")" ]

[ "General", "search", "method", "for", "tables", ".", "For", "(", "ra", "dec", ")", "input", "in", "decimal", "degrees", "i", ".", "e", ".", "(", "12", ".", "3456", "-", "65", ".", "4321", ")", "returns", "all", "sources", "within", "1", "arcminute", "or", "the", "specified", "radius", ".", "For", "string", "input", "i", ".", "e", ".", "vb10", "returns", "all", "sources", "with", "case", "-", "insensitive", "partial", "text", "matches", "in", "columns", "with", "TEXT", "data", "type", ".", "For", "integer", "input", "i", ".", "e", ".", "123", "returns", "all", "exact", "matches", "of", "columns", "with", "INTEGER", "data", "type", "." ]

[ "def", "filesystem_from_config_dict", "(", "config_fs", ")", ":", "if", "\"module\"", "not", "in", "config_fs", ":", "print", "(", "\"Key 'module' should be defined for the filesystem provider ('fs' configuration option)\"", ",", "file", "=", "sys", ".", "stderr", ")", "exit", "(", "1", ")", "filesystem_providers", "=", "get_filesystems_providers", "(", ")", "if", "config_fs", "[", "\"module\"", "]", "not", "in", "filesystem_providers", ":", "print", "(", "\"Unknown filesystem provider \"", "+", "config_fs", "[", "\"module\"", "]", ",", "file", "=", "sys", ".", "stderr", ")", "exit", "(", "1", ")", "fs_class", "=", "filesystem_providers", "[", "config_fs", "[", "\"module\"", "]", "]", "fs_args_needed", "=", "fs_class", ".", "get_needed_args", "(", ")", "fs_args", "=", "{", "}", "for", "arg_name", ",", "(", "arg_type", ",", "arg_required", ",", "_", ")", "in", "fs_args_needed", ".", "items", "(", ")", ":", "if", "arg_name", "in", "config_fs", ":", "fs_args", "[", "arg_name", "]", "=", "arg_type", "(", "config_fs", "[", "arg_name", "]", ")", "elif", "arg_required", ":", "print", "(", "\"fs option {} is required\"", ".", "format", "(", "arg_name", ")", ",", "file", "=", "sys", ".", "stderr", ")", "exit", "(", "1", ")", "try", ":", "return", "fs_class", ".", "init_from_args", "(", "*", "*", "fs_args", ")", "except", ":", "print", "(", "\"Unable to load class \"", "+", "config_fs", "[", "\"module\"", "]", ",", "file", "=", "sys", ".", "stderr", ")", "raise" ]

[ "Given", "a", "dict", "containing", "an", "entry", "module", "which", "contains", "a", "FSProvider", "identifier", "parse", "the", "configuration", "and", "returns", "a", "fs_provider", ".", "Exits", "if", "there", "is", "an", "error", "." ]

[ "def", "remap_name", "(", "name_generator", ",", "names", ",", "table", "=", "None", ")", ":", "out", "=", "\"\"", "for", "name", "in", "names", ":", "if", "table", "and", "name", "in", "table", "[", "0", "]", ".", "keys", "(", ")", ":", "replacement", "=", "table", "[", "0", "]", "[", "name", "]", "else", ":", "replacement", "=", "next", "(", "name_generator", ")", "out", "+=", "\"%s=%s\\n\"", "%", "(", "replacement", ",", "name", ")", "return", "out" ]

[ "Produces", "a", "series", "of", "variable", "assignments", "in", "the", "form", "of", "::" ]

[ "def", "get_active_forms_state", "(", "self", ")", ":", "for", "term", "in", "self", ".", "_isolated_terms", ":", "act", "=", "term", ".", "find", "(", "'features/active'", ")", "if", "act", "is", "None", ":", "continue", "if", "act", ".", "text", "==", "'TRUE'", ":", "is_active", "=", "True", "elif", "act", ".", "text", "==", "'FALSE'", ":", "is_active", "=", "False", "else", ":", "logger", ".", "warning", "(", "'Unhandled term activity feature %s'", "%", "act", ".", "text", ")", "agent", "=", "self", ".", "_get_agent_by_id", "(", "term", ".", "attrib", "[", "'id'", "]", ",", "None", ")", "# Skip aggregates for now", "if", "not", "isinstance", "(", "agent", ",", "Agent", ")", ":", "continue", "# If the Agent state is at the base state then this is not an", "# ActiveForm statement", "if", "_is_base_agent_state", "(", "agent", ")", ":", "continue", "# Remove the activity flag since it's irrelevant here", "agent", ".", "activity", "=", "None", "text_term", "=", "term", ".", "find", "(", "'text'", ")", "if", "text_term", "is", "not", "None", ":", "ev_text", "=", "text_term", ".", "text", "else", ":", "ev_text", "=", "None", "ev", "=", "Evidence", "(", "source_api", "=", "'trips'", ",", "text", "=", "ev_text", ",", "pmid", "=", "self", ".", "doc_id", ")", "st", "=", "ActiveForm", "(", "agent", ",", "'activity'", ",", "is_active", ",", "evidence", "=", "[", "ev", "]", ")", "self", ".", "statements", ".", "append", "(", "st", ")" ]

[ "Extract", "ActiveForm", "INDRA", "Statements", "." ]

[ "def", "get_all", "(", "self", ",", "references", ",", "field_paths", "=", "None", ",", "transaction", "=", "None", ")", ":", "document_paths", ",", "reference_map", "=", "_reference_info", "(", "references", ")", "mask", "=", "_get_doc_mask", "(", "field_paths", ")", "response_iterator", "=", "self", ".", "_firestore_api", ".", "batch_get_documents", "(", "self", ".", "_database_string", ",", "document_paths", ",", "mask", ",", "transaction", "=", "_helpers", ".", "get_transaction_id", "(", "transaction", ")", ",", "metadata", "=", "self", ".", "_rpc_metadata", ",", ")", "for", "get_doc_response", "in", "response_iterator", ":", "yield", "_parse_batch_get", "(", "get_doc_response", ",", "reference_map", ",", "self", ")" ]

[ "Retrieve", "a", "batch", "of", "documents", "." ]

[ "def", "timed_loop", "(", "name", "=", "None", ",", "rgstr_stamps", "=", "None", ",", "save_itrs", "=", "SET", "[", "'SI'", "]", ",", "loop_end_stamp", "=", "None", ",", "end_stamp_unique", "=", "SET", "[", "'UN'", "]", ",", "keep_prev_subdivisions", "=", "SET", "[", "'KS'", "]", ",", "keep_end_subdivisions", "=", "SET", "[", "'KS'", "]", ",", "quick_print", "=", "SET", "[", "'QP'", "]", ")", ":", "return", "TimedLoop", "(", "name", "=", "name", ",", "rgstr_stamps", "=", "rgstr_stamps", ",", "save_itrs", "=", "save_itrs", ",", "loop_end_stamp", "=", "loop_end_stamp", ",", "end_stamp_unique", "=", "end_stamp_unique", ",", "keep_prev_subdivisions", "=", "keep_prev_subdivisions", ",", "keep_end_subdivisions", "=", "keep_end_subdivisions", ")" ]

[ "Instantiate", "a", "TimedLoop", "object", "for", "measuring", "loop", "iteration", "timing", "data", ".", "Can", "be", "used", "with", "either", "for", "or", "while", "loops", "." ]

[ "def", "readline", "(", "self", ")", ":", "data", "=", "self", ".", "_file", ".", "readline", "(", ")", "s", "=", "self", ".", "parse", "(", "data", ")", "return", "s" ]

[ "Return", "the", "next", "NMEASentence", "in", "the", "file", "object", ":", "return", ":", "NMEASentence" ]

[ "def", "histogram", "(", "self", ",", "axis", "=", "None", ",", "*", "*", "kargs", ")", ":", "if", "(", "axis", "==", "None", ")", ":", "axis", "=", "plt", ".", "gca", "(", ")", "axis", ".", "hist", "(", "self", ".", "__image", ".", "ravel", "(", ")", ",", "*", "*", "kargs", ")" ]

[ "-", "histogram", "(", "axis", "=", "None", "**", "kargs", ")", ":", "It", "computes", "and", "shows", "the", "histogram", "of", "the", "image", ".", "This", "is", "usefull", "for", "choosing", "a", "proper", "scale", "to", "the", "output", "or", "for", "clipping", "some", "values", ".", "If", "axis", "is", "None", "it", "selects", "the", "current", "axis", "to", "plot", "the", "histogram", ".", "Keyword", "arguments", ":", "*", "bins", "*", ":", "Either", "an", "integer", "number", "of", "bins", "or", "a", "sequence", "giving", "the", "bins", ".", "If", "*", "bins", "*", "is", "an", "integer", "*", "bins", "*", "+", "1", "bin", "edges", "will", "be", "returned", "consistent", "with", ":", "func", ":", "numpy", ".", "histogram", "for", "numpy", "version", ">", "=", "1", ".", "3", "and", "with", "the", "*", "new", "*", "=", "True", "argument", "in", "earlier", "versions", ".", "Unequally", "spaced", "bins", "are", "supported", "if", "*", "bins", "*", "is", "a", "sequence", ".", "*", "range", "*", ":", "The", "lower", "and", "upper", "range", "of", "the", "bins", ".", "Lower", "and", "upper", "outliers", "are", "ignored", ".", "If", "not", "provided", "*", "range", "*", "is", "(", "x", ".", "min", "()", "x", ".", "max", "()", ")", ".", "Range", "has", "no", "effect", "if", "*", "bins", "*", "is", "a", "sequence", ".", "If", "*", "bins", "*", "is", "a", "sequence", "or", "*", "range", "*", "is", "specified", "autoscaling", "is", "based", "on", "the", "specified", "bin", "range", "instead", "of", "the", "range", "of", "x", ".", "*", "normed", "*", ":", "If", "*", "True", "*", "the", "first", "element", "of", "the", "return", "tuple", "will", "be", "the", "counts", "normalized", "to", "form", "a", "probability", "density", "i", ".", "e", ".", "n", "/", "(", "len", "(", "x", ")", "*", "dbin", ")", ".", "In", "a", "probability", "density", "the", "integral", "of", "the", "histogram", "should", "be", "1", ";", "you", "can", "verify", "that", "with", "a", "trapezoidal", "integration", "of", "the", "probability", "density", "function", "::", "pdf", "bins", "patches", "=", "ax", ".", "hist", "(", "...", ")", "print", "(", "np", ".", "sum", "(", "pdf", "*", "np", ".", "diff", "(", "bins", ")))", "..", "note", "::", "Until", "numpy", "release", "1", ".", "5", "the", "underlying", "numpy", "histogram", "function", "was", "incorrect", "with", "*", "normed", "*", "=", "*", "True", "*", "if", "bin", "sizes", "were", "unequal", ".", "MPL", "inherited", "that", "error", ".", "It", "is", "now", "corrected", "within", "MPL", "when", "using", "earlier", "numpy", "versions", "*", "weights", "*", ":", "An", "array", "of", "weights", "of", "the", "same", "shape", "as", "*", "x", "*", ".", "Each", "value", "in", "*", "x", "*", "only", "contributes", "its", "associated", "weight", "towards", "the", "bin", "count", "(", "instead", "of", "1", ")", ".", "If", "*", "normed", "*", "is", "True", "the", "weights", "are", "normalized", "so", "that", "the", "integral", "of", "the", "density", "over", "the", "range", "remains", "1", ".", "*", "cumulative", "*", ":", "If", "*", "True", "*", "then", "a", "histogram", "is", "computed", "where", "each", "bin", "gives", "the", "counts", "in", "that", "bin", "plus", "all", "bins", "for", "smaller", "values", ".", "The", "last", "bin", "gives", "the", "total", "number", "of", "datapoints", ".", "If", "*", "normed", "*", "is", "also", "*", "True", "*", "then", "the", "histogram", "is", "normalized", "such", "that", "the", "last", "bin", "equals", "1", ".", "If", "*", "cumulative", "*", "evaluates", "to", "less", "than", "0", "(", "e", ".", "g", ".", "-", "1", ")", "the", "direction", "of", "accumulation", "is", "reversed", ".", "In", "this", "case", "if", "*", "normed", "*", "is", "also", "*", "True", "*", "then", "the", "histogram", "is", "normalized", "such", "that", "the", "first", "bin", "equals", "1", ".", "*", "histtype", "*", ":", "[", "bar", "|", "barstacked", "|", "step", "|", "stepfilled", "]", "The", "type", "of", "histogram", "to", "draw", ".", "-", "bar", "is", "a", "traditional", "bar", "-", "type", "histogram", ".", "If", "multiple", "data", "are", "given", "the", "bars", "are", "aranged", "side", "by", "side", ".", "-", "barstacked", "is", "a", "bar", "-", "type", "histogram", "where", "multiple", "data", "are", "stacked", "on", "top", "of", "each", "other", ".", "-", "step", "generates", "a", "lineplot", "that", "is", "by", "default", "unfilled", ".", "-", "stepfilled", "generates", "a", "lineplot", "that", "is", "by", "default", "filled", ".", "*", "align", "*", ":", "[", "left", "|", "mid", "|", "right", "]", "Controls", "how", "the", "histogram", "is", "plotted", ".", "-", "left", ":", "bars", "are", "centered", "on", "the", "left", "bin", "edges", ".", "-", "mid", ":", "bars", "are", "centered", "between", "the", "bin", "edges", ".", "-", "right", ":", "bars", "are", "centered", "on", "the", "right", "bin", "edges", ".", "*", "orientation", "*", ":", "[", "horizontal", "|", "vertical", "]", "If", "horizontal", ":", "func", ":", "~matplotlib", ".", "pyplot", ".", "barh", "will", "be", "used", "for", "bar", "-", "type", "histograms", "and", "the", "*", "bottom", "*", "kwarg", "will", "be", "the", "left", "edges", ".", "*", "rwidth", "*", ":", "The", "relative", "width", "of", "the", "bars", "as", "a", "fraction", "of", "the", "bin", "width", ".", "If", "*", "None", "*", "automatically", "compute", "the", "width", ".", "Ignored", "if", "*", "histtype", "*", "=", "step", "or", "stepfilled", ".", "*", "log", "*", ":", "If", "*", "True", "*", "the", "histogram", "axis", "will", "be", "set", "to", "a", "log", "scale", ".", "If", "*", "log", "*", "is", "*", "True", "*", "and", "*", "x", "*", "is", "a", "1D", "array", "empty", "bins", "will", "be", "filtered", "out", "and", "only", "the", "non", "-", "empty", "(", "*", "n", "*", "*", "bins", "*", "*", "patches", "*", ")", "will", "be", "returned", ".", "*", "color", "*", ":", "Color", "spec", "or", "sequence", "of", "color", "specs", "one", "per", "dataset", ".", "Default", "(", "*", "None", "*", ")", "uses", "the", "standard", "line", "color", "sequence", ".", "*", "label", "*", ":", "String", "or", "sequence", "of", "strings", "to", "match", "multiple", "datasets", ".", "Bar", "charts", "yield", "multiple", "patches", "per", "dataset", "but", "only", "the", "first", "gets", "the", "label", "so", "that", "the", "legend", "command", "will", "work", "as", "expected", "::", "ax", ".", "hist", "(", "10", "+", "2", "*", "np", ".", "random", ".", "randn", "(", "1000", ")", "label", "=", "men", ")", "ax", ".", "hist", "(", "12", "+", "3", "*", "np", ".", "random", ".", "randn", "(", "1000", ")", "label", "=", "women", "alpha", "=", "0", ".", "5", ")", "ax", ".", "legend", "()", "kwargs", "are", "used", "to", "update", "the", "properties", "of", "the", ":", "class", ":", "~matplotlib", ".", "patches", ".", "Patch", "instances", "returned", "by", "*", "hist", "*", ":", "agg_filter", ":", "unknown", "alpha", ":", "float", "or", "None", "animated", ":", "[", "True", "|", "False", "]", "antialiased", "or", "aa", ":", "[", "True", "|", "False", "]", "or", "None", "for", "default", "axes", ":", "an", ":", "class", ":", "~matplotlib", ".", "axes", ".", "Axes", "instance", "clip_box", ":", "a", ":", "class", ":", "matplotlib", ".", "transforms", ".", "Bbox", "instance", "clip_on", ":", "[", "True", "|", "False", "]", "clip_path", ":", "[", "(", ":", "class", ":", "~matplotlib", ".", "path", ".", "Path", ":", "class", ":", "~matplotlib", ".", "transforms", ".", "Transform", ")", "|", ":", "class", ":", "~matplotlib", ".", "patches", ".", "Patch", "|", "None", "]", "color", ":", "matplotlib", "color", "spec", "contains", ":", "a", "callable", "function", "edgecolor", "or", "ec", ":", "mpl", "color", "spec", "or", "None", "for", "default", "or", "none", "for", "no", "color", "facecolor", "or", "fc", ":", "mpl", "color", "spec", "or", "None", "for", "default", "or", "none", "for", "no", "color", "figure", ":", "a", ":", "class", ":", "matplotlib", ".", "figure", ".", "Figure", "instance", "fill", ":", "[", "True", "|", "False", "]", "gid", ":", "an", "id", "string", "hatch", ":", "[", "/", "|", "\\\\", "|", "|", "|", "-", "|", "+", "|", "x", "|", "o", "|", "O", "|", ".", "|", "*", "]", "label", ":", "any", "string", "linestyle", "or", "ls", ":", "[", "solid", "|", "dashed", "|", "dashdot", "|", "dotted", "]", "linewidth", "or", "lw", ":", "float", "or", "None", "for", "default", "lod", ":", "[", "True", "|", "False", "]", "path_effects", ":", "unknown", "picker", ":", "[", "None|float|boolean|callable", "]", "rasterized", ":", "[", "True", "|", "False", "|", "None", "]", "snap", ":", "unknown", "transform", ":", ":", "class", ":", "~matplotlib", ".", "transforms", ".", "Transform", "instance", "url", ":", "a", "url", "string", "visible", ":", "[", "True", "|", "False", "]", "zorder", ":", "any", "number" ]

[ "def", "FPE", "(", "N", ",", "rho", ",", "k", "=", "None", ")", ":", "#k #todo check convention. agrees with octave", "fpe", "=", "rho", "*", "(", "N", "+", "k", "+", "1.", ")", "/", "(", "N", "-", "k", "-", "1", ")", "return", "fpe" ]

[ "r", "Final", "prediction", "error", "criterion" ]

[ "def", "get_description", "(", "self", ",", "description_type", "=", "'Abstract'", ")", ":", "if", "'descriptions'", "in", "self", ".", "xml", ":", "if", "isinstance", "(", "self", ".", "xml", "[", "'descriptions'", "]", "[", "'description'", "]", ",", "list", ")", ":", "for", "description", "in", "self", ".", "xml", "[", "'descriptions'", "]", "[", "'description'", "]", ":", "if", "description_type", "in", "description", ":", "return", "description", "[", "description_type", "]", "elif", "isinstance", "(", "self", ".", "xml", "[", "'descriptions'", "]", "[", "'description'", "]", ",", "dict", ")", ":", "description", "=", "self", ".", "xml", "[", "'descriptions'", "]", "[", "'description'", "]", "if", "description_type", "in", "description", ":", "return", "description", "[", "description_type", "]", "elif", "len", "(", "description", ")", "==", "1", ":", "# return the only description", "return", "description", ".", "values", "(", ")", "[", "0", "]", "return", "None" ]

[ "Get", "DataCite", "description", "." ]

[ "def", "createEditor", "(", "self", ",", "delegate", ",", "parent", ",", "option", ")", ":", "return", "StringCtiEditor", "(", "self", ",", "delegate", ",", "parent", "=", "parent", ")" ]

[ "Creates", "a", "StringCtiEditor", ".", "For", "the", "parameters", "see", "the", "AbstractCti", "constructor", "documentation", "." ]

[ "def", "parse", "(", "self", ")", ":", "super", "(", "AcisIO", ",", "self", ")", ".", "parse", "(", ")", "# This is more of a \"mapping\" step than a \"parsing\" step, but mappers", "# only allow one-to-one mapping from input fields to output fields.", "for", "row", "in", "self", ".", "data", ":", "if", "'meta'", "in", "row", ":", "row", "=", "row", "[", "'meta'", "]", "if", "'ll'", "in", "row", ":", "row", "[", "'longitude'", "]", ",", "row", "[", "'latitude'", "]", "=", "row", "[", "'ll'", "]", "del", "row", "[", "'ll'", "]" ]

[ "Convert", "ACIS", "ll", "value", "into", "separate", "latitude", "and", "longitude", "." ]

[ "def", "run", "(", "self", ",", "data_cb", ")", ":", "if", "self", ".", "_error", ":", "err", "=", "self", ".", "_error", "if", "isinstance", "(", "self", ".", "_error", ",", "KeyboardInterrupt", ")", ":", "# KeyboardInterrupt is not destructive(it may be used in", "# the REPL).", "# After throwing KeyboardInterrupt, cleanup the _error field", "# so the loop may be started again", "self", ".", "_error", "=", "None", "raise", "err", "self", ".", "_on_data", "=", "data_cb", "if", "threading", ".", "current_thread", "(", ")", "==", "main_thread", ":", "self", ".", "_setup_signals", "(", "[", "signal", ".", "SIGINT", ",", "signal", ".", "SIGTERM", "]", ")", "debug", "(", "'Entering event loop'", ")", "self", ".", "_run", "(", ")", "debug", "(", "'Exited event loop'", ")", "if", "threading", ".", "current_thread", "(", ")", "==", "main_thread", ":", "self", ".", "_teardown_signals", "(", ")", "signal", ".", "signal", "(", "signal", ".", "SIGINT", ",", "default_int_handler", ")", "self", ".", "_on_data", "=", "None" ]

[ "Run", "the", "event", "loop", "." ]

[ "def", "subdivide", "(", "self", ")", ":", "nodes_a", ",", "nodes_b", ",", "nodes_c", ",", "nodes_d", "=", "_surface_helpers", ".", "subdivide_nodes", "(", "self", ".", "_nodes", ",", "self", ".", "_degree", ")", "return", "(", "Surface", "(", "nodes_a", ",", "self", ".", "_degree", ",", "_copy", "=", "False", ")", ",", "Surface", "(", "nodes_b", ",", "self", ".", "_degree", ",", "_copy", "=", "False", ")", ",", "Surface", "(", "nodes_c", ",", "self", ".", "_degree", ",", "_copy", "=", "False", ")", ",", "Surface", "(", "nodes_d", ",", "self", ".", "_degree", ",", "_copy", "=", "False", ")", ",", ")" ]

[ "r", "Split", "the", "surface", "into", "four", "sub", "-", "surfaces", "." ]

[ "def", "CheckCommandSpaces", "(", "filename", ",", "linenumber", ",", "clean_lines", ",", "errors", ")", ":", "line", "=", "clean_lines", ".", "lines", "[", "linenumber", "]", "match", "=", "ContainsCommand", "(", "line", ")", "if", "match", "and", "len", "(", "match", ".", "group", "(", "2", ")", ")", ":", "errors", "(", "filename", ",", "linenumber", ",", "'whitespace/extra'", ",", "\"Extra spaces between '%s' and its ()\"", "%", "(", "match", ".", "group", "(", "1", ")", ")", ")", "if", "match", ":", "spaces_after_open", "=", "len", "(", "_RE_COMMAND_START_SPACES", ".", "match", "(", "line", ")", ".", "group", "(", "1", ")", ")", "initial_spaces", "=", "GetInitialSpaces", "(", "line", ")", "initial_linenumber", "=", "linenumber", "end", "=", "None", "while", "True", ":", "line", "=", "clean_lines", ".", "lines", "[", "linenumber", "]", "end", "=", "_RE_COMMAND_END_SPACES", ".", "search", "(", "line", ")", "if", "end", ":", "break", "linenumber", "+=", "1", "if", "linenumber", ">=", "len", "(", "clean_lines", ".", "lines", ")", ":", "break", "if", "linenumber", "==", "len", "(", "clean_lines", ".", "lines", ")", "and", "not", "end", ":", "errors", "(", "filename", ",", "initial_linenumber", ",", "'syntax'", ",", "'Unable to find the end of this command'", ")", "if", "end", ":", "spaces_before_end", "=", "len", "(", "end", ".", "group", "(", "1", ")", ")", "initial_spaces", "=", "GetInitialSpaces", "(", "line", ")", "if", "initial_linenumber", "!=", "linenumber", "and", "spaces_before_end", ">=", "initial_spaces", ":", "spaces_before_end", "-=", "initial_spaces", "if", "spaces_after_open", "!=", "spaces_before_end", ":", "errors", "(", "filename", ",", "initial_linenumber", ",", "'whitespace/mismatch'", ",", "'Mismatching spaces inside () after command'", ")" ]

[ "No", "extra", "spaces", "between", "command", "and", "parenthesis" ]

[ "def", "_to_dict", "(", "self", ")", ":", "_dict", "=", "{", "}", "if", "hasattr", "(", "self", ",", "'relations'", ")", "and", "self", ".", "relations", "is", "not", "None", ":", "_dict", "[", "'relations'", "]", "=", "[", "x", ".", "_to_dict", "(", ")", "for", "x", "in", "self", ".", "relations", "]", "return", "_dict" ]

[ "Return", "a", "json", "dictionary", "representing", "this", "model", "." ]

[ "def", "etag", "(", "self", ",", "etag", ")", ":", "if", "not", "isinstance", "(", "etag", ",", "bytes", ")", ":", "etag", "=", "bytes", "(", "etag", ",", "\"utf-8\"", ")", "self", ".", "_etag", ".", "append", "(", "etag", ")" ]

[ "Set", "the", "ETag", "of", "the", "resource", "." ]

[ "def", "get", "(", "self", ",", "block", "=", "1", ",", "delay", "=", "None", ")", ":", "if", "_debug", ":", "IOQueue", ".", "_debug", "(", "\"get block=%r delay=%r\"", ",", "block", ",", "delay", ")", "# if the queue is empty and we do not block return None", "if", "not", "block", "and", "not", "self", ".", "notempty", ".", "isSet", "(", ")", ":", "if", "_debug", ":", "IOQueue", ".", "_debug", "(", "\" - not blocking and empty\"", ")", "return", "None", "# wait for something to be in the queue", "if", "delay", ":", "self", ".", "notempty", ".", "wait", "(", "delay", ")", "if", "not", "self", ".", "notempty", ".", "isSet", "(", ")", ":", "return", "None", "else", ":", "self", ".", "notempty", ".", "wait", "(", ")", "# extract the first element", "priority", ",", "iocb", "=", "self", ".", "queue", "[", "0", "]", "del", "self", ".", "queue", "[", "0", "]", "iocb", ".", "ioQueue", "=", "None", "# if the queue is empty, clear the event", "qlen", "=", "len", "(", "self", ".", "queue", ")", "if", "not", "qlen", ":", "self", ".", "notempty", ".", "clear", "(", ")", "# return the request", "return", "iocb" ]

[ "Get", "a", "request", "from", "a", "queue", "optionally", "block", "until", "a", "request", "is", "available", "." ]

[ "def", "set", "(", "self", ",", "value", ",", "mode", "=", "None", ")", ":", "if", "mode", "==", "'max'", ":", "func", "=", "uwsgi", ".", "metric_set_max", "elif", "mode", "==", "'min'", ":", "func", "=", "uwsgi", ".", "metric_set_min", "else", ":", "func", "=", "uwsgi", ".", "metric_set", "return", "func", "(", "self", ".", "name", ",", "value", ")" ]

[ "Sets", "metric", "value", "." ]

[ "def", "_export_local_images", "(", "project", ",", "image", ",", "z", ")", ":", "from", ".", ".", "compute", "import", "MODULES", "for", "module", "in", "MODULES", ":", "try", ":", "img_directory", "=", "module", ".", "instance", "(", ")", ".", "get_images_directory", "(", ")", "except", "NotImplementedError", ":", "# Some modules don't have images", "continue", "directory", "=", "os", ".", "path", ".", "split", "(", "img_directory", ")", "[", "-", "1", ":", "]", "[", "0", "]", "if", "os", ".", "path", ".", "exists", "(", "image", ")", ":", "path", "=", "image", "else", ":", "path", "=", "os", ".", "path", ".", "join", "(", "img_directory", ",", "image", ")", "if", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "arcname", "=", "os", ".", "path", ".", "join", "(", "\"images\"", ",", "directory", ",", "os", ".", "path", ".", "basename", "(", "image", ")", ")", "z", ".", "write", "(", "path", ",", "arcname", ")", "return" ]

[ "Take", "a", "project", "file", "(", ".", "gns3", ")", "and", "export", "images", "to", "the", "zip" ]

[ "def", "get_blobstore", "(", "layout", ")", ":", "if", "layout", ".", "is_s3", ":", "from", "wal_e", ".", "blobstore", "import", "s3", "blobstore", "=", "s3", "elif", "layout", ".", "is_wabs", ":", "from", "wal_e", ".", "blobstore", "import", "wabs", "blobstore", "=", "wabs", "elif", "layout", ".", "is_swift", ":", "from", "wal_e", ".", "blobstore", "import", "swift", "blobstore", "=", "swift", "elif", "layout", ".", "is_gs", ":", "from", "wal_e", ".", "blobstore", "import", "gs", "blobstore", "=", "gs", "elif", "layout", ".", "is_file", ":", "from", "wal_e", ".", "blobstore", "import", "file", "blobstore", "=", "file", "return", "blobstore" ]

[ "Return", "Blobstore", "instance", "for", "a", "given", "storage", "layout", "Args", ":", "layout", "(", "StorageLayout", ")", ":", "Target", "storage", "layout", "." ]

[ "def", "show_instances", "(", "server", ",", "cim_class", ")", ":", "if", "cim_class", "==", "'CIM_RegisteredProfile'", ":", "for", "inst", "in", "server", ".", "profiles", ":", "print", "(", "inst", ".", "tomof", "(", ")", ")", "return", "for", "ns", "in", "server", ".", "namespaces", ":", "try", ":", "insts", "=", "server", ".", "conn", ".", "EnumerateInstances", "(", "cim_class", ",", "namespace", "=", "ns", ")", "if", "len", "(", "insts", ")", ":", "print", "(", "'INSTANCES OF %s ns=%s'", "%", "(", "cim_class", ",", "ns", ")", ")", "for", "inst", "in", "insts", ":", "print", "(", "inst", ".", "tomof", "(", ")", ")", "except", "pywbem", ".", "Error", "as", "er", ":", "if", "er", ".", "status_code", "!=", "pywbem", ".", "CIM_ERR_INVALID_CLASS", ":", "print", "(", "'%s namespace %s Enumerate failed for conn=%s\\n'", "'exception=%s'", "%", "(", "cim_class", ",", "ns", ",", "server", ",", "er", ")", ")" ]

[ "Display", "the", "instances", "of", "the", "CIM_Class", "defined", "by", "cim_class", ".", "If", "the", "namespace", "is", "None", "use", "the", "interop", "namespace", ".", "Search", "all", "namespaces", "for", "instances", "except", "for", "CIM_RegisteredProfile" ]

[ "def", "direct_command_hub", "(", "self", ",", "command", ")", ":", "self", ".", "logger", ".", "info", "(", "\"direct_command_hub: Command %s\"", ",", "command", ")", "command_url", "=", "(", "self", ".", "hub_url", "+", "'/3?'", "+", "command", "+", "\"=I=3\"", ")", "return", "self", ".", "post_direct_command", "(", "command_url", ")" ]

[ "Send", "direct", "hub", "command" ]

[ "def", "_check_download_dir", "(", "link", ",", "download_dir", ",", "hashes", ")", ":", "# type: (Link, str, Hashes) -> Optional[str]", "download_path", "=", "os", ".", "path", ".", "join", "(", "download_dir", ",", "link", ".", "filename", ")", "if", "os", ".", "path", ".", "exists", "(", "download_path", ")", ":", "# If already downloaded, does its hash match?", "logger", ".", "info", "(", "'File was already downloaded %s'", ",", "download_path", ")", "if", "hashes", ":", "try", ":", "hashes", ".", "check_against_path", "(", "download_path", ")", "except", "HashMismatch", ":", "logger", ".", "warning", "(", "'Previously-downloaded file %s has bad hash. '", "'Re-downloading.'", ",", "download_path", ")", "os", ".", "unlink", "(", "download_path", ")", "return", "None", "return", "download_path", "return", "None" ]

[ "Check", "download_dir", "for", "previously", "downloaded", "file", "with", "correct", "hash", "If", "a", "correct", "file", "is", "found", "return", "its", "path", "else", "None" ]

[ "def", "combine_files", "(", "*", "args", ")", ":", "file_contents", "=", "[", "]", "for", "filename", "in", "args", ":", "with", "codecs", ".", "open", "(", "filename", ",", "mode", "=", "'r'", ",", "encoding", "=", "'utf8'", ")", "as", "f", ":", "file_contents", ".", "append", "(", "f", ".", "read", "(", ")", ")", "return", "\"\\n\\n\"", ".", "join", "(", "file_contents", ")" ]

[ "returns", "a", "string", "of", "all", "the", "strings", "in", "*", "args", "combined", "together", "with", "two", "line", "breaks", "between", "them" ]

[ "def", "dump_pmean", "(", "self", ",", "filename", ")", ":", "warnings", ".", "warn", "(", "\"nonlinear_fit.dump_pmean deprecated; use pickle.dump instead\"", ",", "DeprecationWarning", ",", ")", "with", "open", "(", "filename", ",", "\"wb\"", ")", "as", "f", ":", "if", "self", ".", "p0", ".", "shape", "is", "not", "None", ":", "pickle", ".", "dump", "(", "numpy", ".", "array", "(", "self", ".", "pmean", ")", ",", "f", ")", "else", ":", "pickle", ".", "dump", "(", "collections", ".", "OrderedDict", "(", "self", ".", "pmean", ")", ",", "f", ")" ]

[ "Dump", "parameter", "means", "(", "fit", ".", "pmean", ")", "into", "file", "filename", "." ]

[ "def", "patched_function", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "result", "=", "self", ".", "function", "(", "*", "args", ",", "*", "*", "kwargs", ")", "self", ".", "validate", "(", "result", ")", "return", "result" ]

[ "Step", "3", ".", "Wrapped", "function", "calling", "." ]

[ "def", "wait_for_keypresses", "(", "self", ",", "refresh_rate", "=", "1", ")", ":", "if", "not", "self", ".", "_enable_keyboard", ":", "return", "with", "self", ".", "_blessed_term", ".", "cbreak", "(", ")", ":", "while", "True", ":", "yield", "self", ".", "_blessed_term", ".", "inkey", "(", "timeout", "=", "refresh_rate", ")" ]

[ "Listen", "to", "user", "s", "keystrokes", "and", "return", "them", "to", "caller", "one", "at", "a", "time", "." ]

[ "def", "get_notifications", "(", "self", ",", "from_ts", ",", "to_ts", ",", "state", "=", "None", ",", "resolved", "=", "None", ")", ":", "params", "=", "{", "}", "if", "from_ts", "is", "not", "None", ":", "params", "[", "'from'", "]", "=", "from_ts", "*", "1000000", "if", "to_ts", "is", "not", "None", ":", "params", "[", "'to'", "]", "=", "to_ts", "*", "1000000", "if", "state", "is", "not", "None", ":", "params", "[", "'state'", "]", "=", "state", "if", "resolved", "is", "not", "None", ":", "params", "[", "'resolved'", "]", "=", "resolved", "res", "=", "requests", ".", "get", "(", "self", ".", "url", "+", "'/api/notifications'", ",", "headers", "=", "self", ".", "hdrs", ",", "params", "=", "params", ",", "verify", "=", "self", ".", "ssl_verify", ")", "if", "not", "self", ".", "_checkResponse", "(", "res", ")", ":", "return", "[", "False", ",", "self", ".", "lasterr", "]", "return", "[", "True", ",", "res", ".", "json", "(", ")", "]" ]

[ "**", "Description", "**", "Returns", "the", "list", "of", "Sysdig", "Monitor", "alert", "notifications", "." ]

[ "def", "persist", "(", "self", ",", "status", "=", "None", ")", ":", "self", ".", "_persist", "=", "status", "if", "type", "(", "status", ")", "is", "bool", "else", "True" ]

[ "Enables", "persistent", "mode", "for", "the", "current", "mock", "." ]

[ "def", "__process", "(", "self", ",", "event", ")", ":", "# 检查是否存在对该事件进行监听的处理函数", "if", "event", ".", "type_", "in", "self", ".", "__handlers", ":", "# 若存在，则按顺序将事件传递给处理函数执行", "[", "handler", "(", "event", ")", "for", "handler", "in", "self", ".", "__handlers", "[", "event", ".", "type_", "]", "]", "# 以上语句为Python列表解析方式的写法，对应的常规循环写法为：", "#for handler in self.__handlers[event.type_]:", "#handler(event) ", "# 调用通用处理函数进行处理", "if", "self", ".", "__generalHandlers", ":", "[", "handler", "(", "event", ")", "for", "handler", "in", "self", ".", "__generalHandlers", "]" ]

[ "处理事件" ]

[ "def", "_mean_prediction", "(", "self", ",", "sigma2", ",", "Y", ",", "scores", ",", "h", ",", "t_params", ")", ":", "# Create arrays to iteratre over", "sigma2_exp", "=", "sigma2", ".", "copy", "(", ")", "scores_exp", "=", "scores", ".", "copy", "(", ")", "# Loop over h time periods ", "for", "t", "in", "range", "(", "0", ",", "h", ")", ":", "new_value", "=", "t_params", "[", "0", "]", "# ARCH", "if", "self", ".", "q", "!=", "0", ":", "for", "j", "in", "range", "(", "1", ",", "self", ".", "q", "+", "1", ")", ":", "new_value", "+=", "t_params", "[", "j", "]", "*", "scores_exp", "[", "-", "j", "]", "# GARCH", "if", "self", ".", "p", "!=", "0", ":", "for", "k", "in", "range", "(", "1", ",", "self", ".", "p", "+", "1", ")", ":", "new_value", "+=", "t_params", "[", "k", "+", "self", ".", "q", "]", "*", "sigma2_exp", "[", "-", "k", "]", "sigma2_exp", "=", "np", ".", "append", "(", "sigma2_exp", ",", "[", "new_value", "]", ")", "# For indexing consistency", "scores_exp", "=", "np", ".", "append", "(", "scores_exp", ",", "[", "0", "]", ")", "# expectation of score is zero", "return", "sigma2_exp" ]

[ "Creates", "a", "h", "-", "step", "ahead", "mean", "prediction" ]

[ "def", "recode", "(", "self", ",", "table", ":", "pd", ".", "DataFrame", ",", "validate", "=", "False", ")", "->", "pd", ".", "DataFrame", ":", "return", "self", ".", "_recode_output", "(", "self", ".", "_recode_input", "(", "table", ",", "validate", "=", "validate", ")", ",", "validate", "=", "validate", ")" ]

[ "Pass", "the", "appropriate", "columns", "through", "each", "recoder", "function", "sequentially", "and", "return", "the", "final", "result", "." ]

[ "def", "to_records_", "(", "self", ")", "->", "dict", ":", "try", ":", "dic", "=", "self", ".", "df", ".", "to_dict", "(", "orient", "=", "\"records\"", ")", "return", "dic", "except", "Exception", "as", "e", ":", "self", ".", "err", "(", "e", ",", "\"Can not convert data to records\"", ")" ]

[ "Returns", "a", "list", "of", "dictionary", "records", "from", "the", "main", "dataframe" ]

[ "def", "store", "(", "self", ",", "deferred_result", ")", ":", "self", ".", "_counter", "+=", "1", "self", ".", "_stored", "[", "self", ".", "_counter", "]", "=", "deferred_result", "return", "self", ".", "_counter" ]

[ "Store", "a", "EventualResult", "." ]

[ "def", "get_mnist", "(", ")", ":", "np", ".", "random", ".", "seed", "(", "1234", ")", "# set seed for deterministic ordering", "mnist_data", "=", "mx", ".", "test_utils", ".", "get_mnist", "(", ")", "X", "=", "np", ".", "concatenate", "(", "[", "mnist_data", "[", "'train_data'", "]", ",", "mnist_data", "[", "'test_data'", "]", "]", ")", "Y", "=", "np", ".", "concatenate", "(", "[", "mnist_data", "[", "'train_label'", "]", ",", "mnist_data", "[", "'test_label'", "]", "]", ")", "p", "=", "np", ".", "random", ".", "permutation", "(", "X", ".", "shape", "[", "0", "]", ")", "X", "=", "X", "[", "p", "]", ".", "reshape", "(", "(", "X", ".", "shape", "[", "0", "]", ",", "-", "1", ")", ")", ".", "astype", "(", "np", ".", "float32", ")", "*", "5", "Y", "=", "Y", "[", "p", "]", "return", "X", ",", "Y" ]

[ "Gets", "MNIST", "dataset" ]

[ "def", "CreateDataTypeMapByType", "(", "cls", ",", "data_type_definition", ")", ":", "data_type_map_class", "=", "cls", ".", "_MAP_PER_DEFINITION", ".", "get", "(", "data_type_definition", ".", "TYPE_INDICATOR", ",", "None", ")", "if", "not", "data_type_map_class", ":", "return", "None", "return", "data_type_map_class", "(", "data_type_definition", ")" ]

[ "Creates", "a", "specific", "data", "type", "map", "by", "type", "indicator", "." ]

[ "def", "add_device", "(", "self", ",", "device", ",", "container", ")", ":", "# There is a size tag which the JSS manages for us, so we can", "# ignore it.", "if", "self", ".", "findtext", "(", "\"is_smart\"", ")", "==", "\"false\"", ":", "self", ".", "add_object_to_path", "(", "device", ",", "container", ")", "else", ":", "# Technically this isn't true. It will strangely accept", "# them, and they even show up as members of the group!", "raise", "ValueError", "(", "\"Devices may not be added to smart groups.\"", ")" ]

[ "Add", "a", "device", "to", "a", "group", ".", "Wraps", "JSSObject", ".", "add_object_to_path", "." ]

[ "def", "get_resource_component_and_children", "(", "self", ",", "resource_id", ",", "resource_type", "=", "\"collection\"", ",", "level", "=", "1", ",", "sort_data", "=", "{", "}", ",", "recurse_max_level", "=", "False", ",", "sort_by", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "_get_resources", "(", "resource_id", ",", "recurse_max_level", "=", "recurse_max_level", ",", "sort_by", "=", "sort_by", ")" ]

[ "Fetch", "detailed", "metadata", "for", "the", "specified", "resource_id", "and", "all", "of", "its", "children", "." ]

[ "def", "get_moments", "(", "model", ",", "x", ")", ":", "input_dim", "=", "model", ".", "X", ".", "shape", "[", "1", "]", "x", "=", "reshape", "(", "x", ",", "input_dim", ")", "fmin", "=", "min", "(", "model", ".", "predict", "(", "model", ".", "X", ")", "[", "0", "]", ")", "m", ",", "v", "=", "model", ".", "predict", "(", "x", ")", "s", "=", "np", ".", "sqrt", "(", "np", ".", "clip", "(", "v", ",", "0", ",", "np", ".", "inf", ")", ")", "return", "(", "m", ",", "s", ",", "fmin", ")" ]

[ "Moments", "(", "mean", "and", "sdev", ".", ")", "of", "a", "GP", "model", "at", "x" ]

[ "def", "_create_xref", "(", "self", ",", "current_class", ")", ":", "cur_cls_name", "=", "current_class", ".", "get_name", "(", ")", "log", ".", "debug", "(", "\"Creating XREF/DREF for %s\"", "%", "cur_cls_name", ")", "for", "current_method", "in", "current_class", ".", "get_methods", "(", ")", ":", "log", ".", "debug", "(", "\"Creating XREF for %s\"", "%", "current_method", ")", "off", "=", "0", "for", "instruction", "in", "current_method", ".", "get_instructions", "(", ")", ":", "op_value", "=", "instruction", ".", "get_op_value", "(", ")", "# 1) check for class calls: const-class (0x1c), new-instance (0x22)", "if", "op_value", "in", "[", "0x1c", ",", "0x22", "]", ":", "idx_type", "=", "instruction", ".", "get_ref_kind", "(", ")", "# type_info is the string like 'Ljava/lang/Object;'", "type_info", "=", "instruction", ".", "cm", ".", "vm", ".", "get_cm_type", "(", "idx_type", ")", "# Internal xref related to class manipulation", "# FIXME should the xref really only set if the class is in self.classes? If an external class is added later, it will be added too!", "# See https://github.com/androguard/androguard/blob/d720ebf2a9c8e2a28484f1c81fdddbc57e04c157/androguard/core/analysis/analysis.py#L806", "# Before the check would go for internal classes only!", "# FIXME: effectively ignoring calls to itself - do we want that?", "if", "type_info", "!=", "cur_cls_name", ":", "if", "type_info", "not", "in", "self", ".", "classes", ":", "# Create new external class", "self", ".", "classes", "[", "type_info", "]", "=", "ClassAnalysis", "(", "ExternalClass", "(", "type_info", ")", ")", "cur_cls", "=", "self", ".", "classes", "[", "cur_cls_name", "]", "oth_cls", "=", "self", ".", "classes", "[", "type_info", "]", "# FIXME: xref_to does not work here! current_method is wrong, as it is not the target!", "cur_cls", ".", "AddXrefTo", "(", "REF_TYPE", "(", "op_value", ")", ",", "oth_cls", ",", "current_method", ",", "off", ")", "oth_cls", ".", "AddXrefFrom", "(", "REF_TYPE", "(", "op_value", ")", ",", "cur_cls", ",", "current_method", ",", "off", ")", "# 2) check for method calls: invoke-* (0x6e ... 0x72), invoke-xxx/range (0x74 ... 0x78)", "elif", "(", "0x6e", "<=", "op_value", "<=", "0x72", ")", "or", "(", "0x74", "<=", "op_value", "<=", "0x78", ")", ":", "idx_meth", "=", "instruction", ".", "get_ref_kind", "(", ")", "method_info", "=", "instruction", ".", "cm", ".", "vm", ".", "get_cm_method", "(", "idx_meth", ")", "if", "method_info", ":", "class_info", "=", "method_info", "[", "0", "]", "method_item", "=", "None", "# TODO: should create get_method_descriptor inside Analysis", "for", "vm", "in", "self", ".", "vms", ":", "method_item", "=", "vm", ".", "get_method_descriptor", "(", "method_info", "[", "0", "]", ",", "method_info", "[", "1", "]", ",", "''", ".", "join", "(", "method_info", "[", "2", "]", ")", ")", "if", "method_item", ":", "break", "if", "not", "method_item", ":", "# Seems to be an external class, create it first", "# Beware: if not all DEX files are loaded at the time create_xref runs", "# you will run into problems!", "if", "method_info", "[", "0", "]", "not", "in", "self", ".", "classes", ":", "self", ".", "classes", "[", "method_info", "[", "0", "]", "]", "=", "ClassAnalysis", "(", "ExternalClass", "(", "method_info", "[", "0", "]", ")", ")", "method_item", "=", "self", ".", "classes", "[", "method_info", "[", "0", "]", "]", ".", "get_fake_method", "(", "method_info", "[", "1", "]", ",", "method_info", "[", "2", "]", ")", "self", ".", "classes", "[", "cur_cls_name", "]", ".", "AddMXrefTo", "(", "current_method", ",", "self", ".", "classes", "[", "class_info", "]", ",", "method_item", ",", "off", ")", "self", ".", "classes", "[", "class_info", "]", ".", "AddMXrefFrom", "(", "method_item", ",", "self", ".", "classes", "[", "cur_cls_name", "]", ",", "current_method", ",", "off", ")", "# Internal xref related to class manipulation", "if", "class_info", "in", "self", ".", "classes", "and", "class_info", "!=", "cur_cls_name", ":", "self", ".", "classes", "[", "cur_cls_name", "]", ".", "AddXrefTo", "(", "REF_TYPE", "(", "op_value", ")", ",", "self", ".", "classes", "[", "class_info", "]", ",", "method_item", ",", "off", ")", "self", ".", "classes", "[", "class_info", "]", ".", "AddXrefFrom", "(", "REF_TYPE", "(", "op_value", ")", ",", "self", ".", "classes", "[", "cur_cls_name", "]", ",", "current_method", ",", "off", ")", "# 3) check for string usage: const-string (0x1a), const-string/jumbo (0x1b)", "elif", "0x1a", "<=", "op_value", "<=", "0x1b", ":", "string_value", "=", "instruction", ".", "cm", ".", "vm", ".", "get_cm_string", "(", "instruction", ".", "get_ref_kind", "(", ")", ")", "if", "string_value", "not", "in", "self", ".", "strings", ":", "self", ".", "strings", "[", "string_value", "]", "=", "StringAnalysis", "(", "string_value", ")", "# TODO: The bytecode offset is stored for classes but not here?", "self", ".", "strings", "[", "string_value", "]", ".", "AddXrefFrom", "(", "self", ".", "classes", "[", "cur_cls_name", "]", ",", "current_method", ")", "# TODO maybe we should add a step 3a) here and check for all const fields. You can then xref for integers etc!", "# But: This does not work, as const fields are usually optimized internally to const calls...", "# 4) check for field usage: i*op (0x52 ... 0x5f), s*op (0x60 ... 0x6d)", "elif", "0x52", "<=", "op_value", "<=", "0x6d", ":", "idx_field", "=", "instruction", ".", "get_ref_kind", "(", ")", "field_info", "=", "instruction", ".", "cm", ".", "vm", ".", "get_cm_field", "(", "idx_field", ")", "field_item", "=", "instruction", ".", "cm", ".", "vm", ".", "get_field_descriptor", "(", "field_info", "[", "0", "]", ",", "field_info", "[", "2", "]", ",", "field_info", "[", "1", "]", ")", "# TODO: The bytecode offset is stored for classes but not here?", "if", "field_item", ":", "if", "(", "0x52", "<=", "op_value", "<=", "0x58", ")", "or", "(", "0x60", "<=", "op_value", "<=", "0x66", ")", ":", "# read access to a field", "self", ".", "classes", "[", "cur_cls_name", "]", ".", "AddFXrefRead", "(", "current_method", ",", "self", ".", "classes", "[", "cur_cls_name", "]", ",", "field_item", ")", "else", ":", "# write access to a field", "self", ".", "classes", "[", "cur_cls_name", "]", ".", "AddFXrefWrite", "(", "current_method", ",", "self", ".", "classes", "[", "cur_cls_name", "]", ",", "field_item", ")", "off", "+=", "instruction", ".", "get_length", "(", ")" ]

[ "Create", "the", "xref", "for", "current_class" ]

[ "def", "_do_notebook", "(", "self", ",", "name", ",", "convert_notebooks", "=", "False", ")", ":", "if", "convert_notebooks", ":", "self", ".", "convert_and_execute_notebook", "(", "name", ")", "else", ":", "self", ".", "execute_notebook", "(", "name", ")" ]

[ "Called", "by", "do_notebook", "to", "actually", "run", "the", "notebook", "." ]

[ "def", "__root_path", "(", "self", ")", ":", "if", "self", ".", "root_path", "is", "not", "None", ":", "if", "os", ".", "path", ".", "isdir", "(", "self", ".", "root_path", ")", ":", "sys", ".", "path", ".", "append", "(", "self", ".", "root_path", ")", "return", "raise", "RuntimeError", "(", "'EverNode requires a valid root path.'", "' Directory: %s does not exist'", "%", "(", "self", ".", "root_path", ")", ")" ]

[ "Just", "checks", "the", "root", "path", "if", "set" ]

[ "def", "remove", "(", "self", ",", "bundle", ")", ":", "from", "six", "import", "string_types", "if", "isinstance", "(", "bundle", ",", "string_types", ")", ":", "bundle", "=", "self", ".", "bundle", "(", "bundle", ")", "self", ".", "database", ".", "remove_dataset", "(", "bundle", ".", "dataset", ")" ]

[ "Removes", "a", "bundle", "from", "the", "library", "and", "deletes", "the", "configuration", "for", "it", "from", "the", "library", "database", "." ]

[ "def", "list_repo_pkgs", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "byrepo", "=", "kwargs", ".", "pop", "(", "'byrepo'", ",", "False", ")", "cacheonly", "=", "kwargs", ".", "pop", "(", "'cacheonly'", ",", "False", ")", "fromrepo", "=", "kwargs", ".", "pop", "(", "'fromrepo'", ",", "''", ")", "or", "''", "disablerepo", "=", "kwargs", ".", "pop", "(", "'disablerepo'", ",", "''", ")", "or", "''", "enablerepo", "=", "kwargs", ".", "pop", "(", "'enablerepo'", ",", "''", ")", "or", "''", "repo_arg", "=", "_get_options", "(", "fromrepo", "=", "fromrepo", ",", "*", "*", "kwargs", ")", "if", "fromrepo", "and", "not", "isinstance", "(", "fromrepo", ",", "list", ")", ":", "try", ":", "fromrepo", "=", "[", "x", ".", "strip", "(", ")", "for", "x", "in", "fromrepo", ".", "split", "(", "','", ")", "]", "except", "AttributeError", ":", "fromrepo", "=", "[", "x", ".", "strip", "(", ")", "for", "x", "in", "six", ".", "text_type", "(", "fromrepo", ")", ".", "split", "(", "','", ")", "]", "if", "disablerepo", "and", "not", "isinstance", "(", "disablerepo", ",", "list", ")", ":", "try", ":", "disablerepo", "=", "[", "x", ".", "strip", "(", ")", "for", "x", "in", "disablerepo", ".", "split", "(", "','", ")", "if", "x", "!=", "'*'", "]", "except", "AttributeError", ":", "disablerepo", "=", "[", "x", ".", "strip", "(", ")", "for", "x", "in", "six", ".", "text_type", "(", "disablerepo", ")", ".", "split", "(", "','", ")", "if", "x", "!=", "'*'", "]", "if", "enablerepo", "and", "not", "isinstance", "(", "enablerepo", ",", "list", ")", ":", "try", ":", "enablerepo", "=", "[", "x", ".", "strip", "(", ")", "for", "x", "in", "enablerepo", ".", "split", "(", "','", ")", "if", "x", "!=", "'*'", "]", "except", "AttributeError", ":", "enablerepo", "=", "[", "x", ".", "strip", "(", ")", "for", "x", "in", "six", ".", "text_type", "(", "enablerepo", ")", ".", "split", "(", "','", ")", "if", "x", "!=", "'*'", "]", "if", "fromrepo", ":", "repos", "=", "fromrepo", "else", ":", "repos", "=", "[", "repo_name", "for", "repo_name", ",", "repo_info", "in", "six", ".", "iteritems", "(", "list_repos", "(", ")", ")", "if", "repo_name", "in", "enablerepo", "or", "(", "repo_name", "not", "in", "disablerepo", "and", "six", ".", "text_type", "(", "repo_info", ".", "get", "(", "'enabled'", ",", "'1'", ")", ")", "==", "'1'", ")", "]", "ret", "=", "{", "}", "def", "_check_args", "(", "args", ",", "name", ")", ":", "'''\n Do glob matching on args and return True if a match was found.\n Otherwise, return False\n '''", "for", "arg", "in", "args", ":", "if", "fnmatch", ".", "fnmatch", "(", "name", ",", "arg", ")", ":", "return", "True", "return", "False", "def", "_parse_output", "(", "output", ",", "strict", "=", "False", ")", ":", "for", "pkg", "in", "_yum_pkginfo", "(", "output", ")", ":", "if", "strict", "and", "(", "pkg", ".", "repoid", "not", "in", "repos", "or", "not", "_check_args", "(", "args", ",", "pkg", ".", "name", ")", ")", ":", "continue", "repo_dict", "=", "ret", ".", "setdefault", "(", "pkg", ".", "repoid", ",", "{", "}", ")", "version_list", "=", "repo_dict", ".", "setdefault", "(", "pkg", ".", "name", ",", "set", "(", ")", ")", "version_list", ".", "add", "(", "pkg", ".", "version", ")", "yum_version", "=", "None", "if", "_yum", "(", ")", "!=", "'yum'", "else", "_LooseVersion", "(", "__salt__", "[", "'cmd.run'", "]", "(", "[", "'yum'", ",", "'--version'", "]", ",", "python_shell", "=", "False", ")", ".", "splitlines", "(", ")", "[", "0", "]", ".", "strip", "(", ")", ")", "# Really old version of yum; does not even have --showduplicates option", "if", "yum_version", "and", "yum_version", "<", "_LooseVersion", "(", "'3.2.13'", ")", ":", "cmd_prefix", "=", "[", "'--quiet'", "]", "if", "cacheonly", ":", "cmd_prefix", ".", "append", "(", "'-C'", ")", "cmd_prefix", ".", "append", "(", "'list'", ")", "for", "pkg_src", "in", "(", "'installed'", ",", "'available'", ")", ":", "# Check installed packages first", "out", "=", "_call_yum", "(", "cmd_prefix", "+", "[", "pkg_src", "]", ",", "ignore_retcode", "=", "True", ")", "if", "out", "[", "'retcode'", "]", "==", "0", ":", "_parse_output", "(", "out", "[", "'stdout'", "]", ",", "strict", "=", "True", ")", "# The --showduplicates option is added in 3.2.13, but the", "# repository-packages subcommand is only in 3.4.3 and newer", "elif", "yum_version", "and", "yum_version", "<", "_LooseVersion", "(", "'3.4.3'", ")", ":", "cmd_prefix", "=", "[", "'--quiet'", ",", "'--showduplicates'", "]", "if", "cacheonly", ":", "cmd_prefix", ".", "append", "(", "'-C'", ")", "cmd_prefix", ".", "append", "(", "'list'", ")", "for", "pkg_src", "in", "(", "'installed'", ",", "'available'", ")", ":", "# Check installed packages first", "out", "=", "_call_yum", "(", "cmd_prefix", "+", "[", "pkg_src", "]", ",", "ignore_retcode", "=", "True", ")", "if", "out", "[", "'retcode'", "]", "==", "0", ":", "_parse_output", "(", "out", "[", "'stdout'", "]", ",", "strict", "=", "True", ")", "else", ":", "for", "repo", "in", "repos", ":", "cmd", "=", "[", "'--quiet'", ",", "'--showduplicates'", ",", "'repository-packages'", ",", "repo", ",", "'list'", "]", "if", "cacheonly", ":", "cmd", ".", "append", "(", "'-C'", ")", "# Can't concatenate because args is a tuple, using list.extend()", "cmd", ".", "extend", "(", "args", ")", "out", "=", "_call_yum", "(", "cmd", ",", "ignore_retcode", "=", "True", ")", "if", "out", "[", "'retcode'", "]", "!=", "0", "and", "'Error:'", "in", "out", "[", "'stdout'", "]", ":", "continue", "_parse_output", "(", "out", "[", "'stdout'", "]", ")", "if", "byrepo", ":", "for", "reponame", "in", "ret", ":", "# Sort versions newest to oldest", "for", "pkgname", "in", "ret", "[", "reponame", "]", ":", "sorted_versions", "=", "sorted", "(", "[", "_LooseVersion", "(", "x", ")", "for", "x", "in", "ret", "[", "reponame", "]", "[", "pkgname", "]", "]", ",", "reverse", "=", "True", ")", "ret", "[", "reponame", "]", "[", "pkgname", "]", "=", "[", "x", ".", "vstring", "for", "x", "in", "sorted_versions", "]", "return", "ret", "else", ":", "byrepo_ret", "=", "{", "}", "for", "reponame", "in", "ret", ":", "for", "pkgname", "in", "ret", "[", "reponame", "]", ":", "byrepo_ret", ".", "setdefault", "(", "pkgname", ",", "[", "]", ")", ".", "extend", "(", "ret", "[", "reponame", "]", "[", "pkgname", "]", ")", "for", "pkgname", "in", "byrepo_ret", ":", "sorted_versions", "=", "sorted", "(", "[", "_LooseVersion", "(", "x", ")", "for", "x", "in", "byrepo_ret", "[", "pkgname", "]", "]", ",", "reverse", "=", "True", ")", "byrepo_ret", "[", "pkgname", "]", "=", "[", "x", ".", "vstring", "for", "x", "in", "sorted_versions", "]", "return", "byrepo_ret" ]

[ "..", "versionadded", "::", "2014", ".", "1", ".", "0", "..", "versionchanged", "::", "2014", ".", "7", ".", "0", "All", "available", "versions", "of", "each", "package", "are", "now", "returned", ".", "This", "required", "a", "slight", "modification", "to", "the", "structure", "of", "the", "return", "dict", ".", "The", "return", "data", "shown", "below", "reflects", "the", "updated", "return", "dict", "structure", ".", "Note", "that", "packages", "which", "are", "version", "-", "locked", "using", ":", "py", ":", "mod", ":", "pkg", ".", "hold", "<salt", ".", "modules", ".", "yumpkg", ".", "hold", ">", "will", "only", "show", "the", "currently", "-", "installed", "version", "as", "locking", "a", "package", "will", "make", "other", "versions", "appear", "unavailable", "to", "yum", "/", "dnf", ".", "..", "versionchanged", "::", "2017", ".", "7", ".", "0", "By", "default", "the", "versions", "for", "each", "package", "are", "no", "longer", "organized", "by", "repository", ".", "To", "get", "results", "organized", "by", "repository", "use", "byrepo", "=", "True", "." ]

[ "def", "pre_filter", "(", "self", ",", "queryset", ",", "user", ")", ":", "in_user_carts", "=", "Q", "(", "enabling_products__productitem__cart__user", "=", "user", ")", "released", "=", "commerce", ".", "Cart", ".", "STATUS_RELEASED", "paid", "=", "commerce", ".", "Cart", ".", "STATUS_PAID", "active", "=", "commerce", ".", "Cart", ".", "STATUS_ACTIVE", "in_released_carts", "=", "Q", "(", "enabling_products__productitem__cart__status", "=", "released", ")", "not_in_paid_or_active_carts", "=", "~", "(", "Q", "(", "enabling_products__productitem__cart__status", "=", "paid", ")", "|", "Q", "(", "enabling_products__productitem__cart__status", "=", "active", ")", ")", "queryset", "=", "queryset", ".", "filter", "(", "in_user_carts", ")", "queryset", "=", "queryset", ".", "exclude", "(", "in_released_carts", "&", "not_in_paid_or_active_carts", ")", "return", "queryset" ]

[ "Returns", "all", "of", "the", "items", "from", "queryset", "where", "the", "user", "has", "a", "product", "invoking", "that", "item", "s", "condition", "in", "one", "of", "their", "carts", "." ]

[ "def", "divisions", "(", "self", ")", ":", "from", ".", "placeholder_division", "import", "PlaceholderDivision", "placeholder", "=", "None", "for", "item", "in", "self", ".", "__parts_and_divisions", ":", "if", "item", ".", "tag", "==", "'part'", ":", "if", "not", "placeholder", ":", "placeholder", "=", "PlaceholderDivision", "(", ")", "placeholder", ".", "parts", ".", "append", "(", "item", ")", "else", ":", "if", "placeholder", ":", "yield", "placeholder", "placeholder", "=", "None", "yield", "item", "if", "placeholder", ":", "yield", "placeholder" ]

[ "Recursively", "get", "all", "the", "text", "divisions", "directly", "part", "of", "this", "element", ".", "If", "an", "element", "contains", "parts", "or", "text", "without", "tag", ".", "Those", "will", "be", "returned", "in", "order", "and", "wrapped", "with", "a", "TextDivision", "." ]

[ "def", "from_file", "(", "path", ")", ":", "with", "open", "(", "path", ")", "as", "stream", ":", "obj", "=", "yaml", ".", "safe_load", "(", "stream", ")", "Config", ".", "lint", "(", "obj", ")", "return", "Config", "(", "config_dict", "=", "obj", ")" ]

[ "Return", "a", "Config", "instance", "by", "reading", "a", "configuration", "file", "." ]

[ "def", "find_orfs", "(", "fa", ",", "seqs", ")", ":", "faa", "=", "'%s.prodigal.faa'", "%", "(", "fa", ")", "fna", "=", "'%s.prodigal.fna'", "%", "(", "fa", ")", "gbk", "=", "'%s.prodigal.gbk'", "%", "(", "fa", ")", "if", "os", ".", "path", ".", "exists", "(", "faa", ")", "is", "False", ":", "p", "=", "subprocess", ".", "Popen", "(", "'prodigal -q -i %s -a %s -d %s -c -f gbk -m -n -o %s -p meta'", "%", "(", "fa", ",", "faa", ",", "fna", ",", "gbk", ")", ",", "shell", "=", "True", ")", "p", ".", "communicate", "(", ")", "for", "orf", "in", "parse_fasta", "(", "faa", ")", ":", "if", "orf", "[", "0", "]", "==", "[", "]", ":", "continue", "id", "=", "orf", "[", "0", "]", ".", "split", "(", "'>'", ")", "[", "1", "]", ".", "split", "(", "'_'", ",", "1", ")", "[", "0", "]", "pos", "=", "sorted", "(", "[", "int", "(", "i", ")", "for", "i", "in", "orf", "[", "0", "]", ".", "split", "(", ")", "[", "2", ":", "5", "]", "if", "i", "!=", "'#'", "]", ")", "if", "id", "not", "in", "seqs", ":", "continue", "for", "i", ",", "ins", "in", "enumerate", "(", "seqs", "[", "id", "]", "[", "2", "]", ")", ":", "if", "check_overlap", "(", "pos", ",", "ins", ",", "0.90", ")", "is", "True", ":", "seqs", "[", "id", "]", "[", "2", "]", "[", "i", "]", "[", "4", "]", ".", "append", "(", "orf", ")", "return", "seqs", ",", "faa" ]

[ "find", "orfs", "and", "see", "if", "they", "overlap", "with", "insertions", "#", "seqs", "[", "id", "]", "=", "[", "gene", "model", "[[", "i", "-", "gene_pos", "i", "-", "model_pos", "i", "-", "length", "iseq", "[", "orfs", "]", "[", "introns", "]]", "...", "]]" ]

[ "def", "upd_scroll", "(", "self", ",", "*", "args", ")", ":", "att", "=", "'deck_{}_hint_offsets'", ".", "format", "(", "'x'", "if", "self", ".", "orientation", "==", "'horizontal'", "else", "'y'", ")", "self", ".", "_scroll", "=", "getattr", "(", "self", ".", "deckbuilder", ",", "att", ")", "[", "self", ".", "deckidx", "]" ]

[ "Update", "my", "own", "scroll", "property", "to", "where", "my", "deck", "is", "actually", "scrolled", "." ]

[ "def", "gcs_dataset_info_files", "(", "dataset_dir", ")", ":", "prefix", "=", "posixpath", ".", "join", "(", "GCS_DATASET_INFO_DIR", ",", "dataset_dir", ",", "\"\"", ")", "# Filter for this dataset", "filenames", "=", "[", "el", "for", "el", "in", "gcs_files", "(", "prefix_filter", "=", "prefix", ")", "if", "el", ".", "startswith", "(", "prefix", ")", "and", "len", "(", "el", ")", ">", "len", "(", "prefix", ")", "]", "return", "filenames" ]

[ "Return", "paths", "to", "GCS", "files", "in", "the", "given", "dataset", "directory", "." ]

[ "def", "build", "(", "self", ")", ":", "# Grab hyperparameters from self.config:", "hidden_dim", "=", "self", ".", "config", "[", "'encoding-layer-width'", "]", "recurrent_unit", "=", "self", ".", "config", "[", "'recurrent-unit-type'", "]", "bidirectional", "=", "False", "#self.config['encoding-layer-bidirectional']", "vocab_size", "=", "self", ".", "data", ".", "properties", ".", "vocab_size", "embedding_dim", "=", "math", ".", "ceil", "(", "math", ".", "log", "(", "vocab_size", ",", "2", ")", ")", "# self.config['embedding-dim']", "input_length", "=", "self", ".", "data", ".", "properties", "[", "'max-utterance-length'", "]", "+", "1", "# Assemble the network components:", "decoder_input", "=", "Input", "(", "shape", "=", "(", "None", ",", ")", ")", "decoder_embed", "=", "Embedding", "(", "vocab_size", ",", "embedding_dim", ",", "mask_zero", "=", "True", ")", "(", "decoder_input", ")", "#, input_length=input_length)(decoder_input)", "if", "recurrent_unit", "==", "'lstm'", ":", "decoder_rnn", "=", "LSTM", "(", "hidden_dim", ",", "return_sequences", "=", "True", ",", "return_state", "=", "True", ")", "decoder_output", ",", "decoder_h", ",", "decoder_c", "=", "decoder_rnn", "(", "decoder_embed", ",", "initial_state", "=", "self", ".", "encoder", ".", "encoder_hidden_state", ")", "elif", "recurrent_unit", "==", "'gru'", ":", "decoder_rnn", "=", "GRU", "(", "hidden_dim", ",", "return_sequences", "=", "True", ",", "return_state", "=", "True", ")", "decoder_output", ",", "_", "=", "decoder_rnn", "(", "decoder_embed", ",", "initial_state", "=", "self", ".", "encoder", ".", "encoder_hidden_state", ")", "else", ":", "raise", "Exception", "(", "'Invalid recurrent unit type: {}'", ".", "format", "(", "recurrent_unit", ")", ")", "# make the RNN component bidirectional, if desired", "if", "bidirectional", ":", "decoder_rnn", "=", "Bidirectional", "(", "decoder_rnn", ",", "merge_mode", "=", "'ave'", ")", "decoder_dense", "=", "Dense", "(", "vocab_size", ",", "activation", "=", "'softmax'", ")", "decoder_output", "=", "decoder_dense", "(", "decoder_output", ")", "# save the four Decoder components as class state", "self", ".", "decoder_input", "=", "decoder_input", "self", ".", "decoder_embed", "=", "decoder_embed", "self", ".", "decoder_rnn", "=", "decoder_rnn", "self", ".", "decoder_dense", "=", "decoder_dense", "self", ".", "decoder_output", "=", "decoder_output", "return" ]

[ "The", "decoder", "computational", "graph", "consists", "of", "three", "components", ":", "(", "1", ")", "the", "input", "node", "decoder_input", "(", "2", ")", "the", "embedding", "node", "decoder_embed", "(", "3", ")", "the", "recurrent", "(", "RNN", ")", "part", "decoder_rnn", "(", "4", ")", "the", "output", "of", "the", "decoder", "RNN", "decoder_output", "(", "5", ")", "the", "classification", "output", "layer", "decoder_dense" ]

[ "def", "sample_forward_transitions", "(", "self", ",", "batch_size", ",", "batch_info", ",", "forward_steps", ":", "int", ",", "discount_factor", ":", "float", ")", "->", "Transitions", ":", "raise", "NotImplementedError" ]

[ "Sample", "transitions", "from", "replay", "buffer", "with", "_forward", "steps_", ".", "That", "is", "instead", "of", "getting", "a", "transition", "s_t", "-", ">", "s_t", "+", "1", "with", "reward", "r", "get", "a", "transition", "s_t", "-", ">", "s_t", "+", "n", "with", "sum", "of", "intermediate", "rewards", "." ]

[ "def", "run", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "# type: (...) -> None", "signal", ".", "signal", "(", "signal", ".", "SIGTERM", ",", "_signal_handler", ")", "try", ":", "sys", ".", "exit", "(", "main", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", "finally", ":", "_terminate_processes", "(", ")" ]

[ "Run", "cwltool", "." ]

[ "def", "set_exception", "(", "self", ",", "exception", ")", ":", "if", "hasattr", "(", "self", ",", "'_result'", ")", ":", "raise", "ValueError", "(", "'Cannot set the result twice'", ")", "self", ".", "_result", "=", "None", "self", ".", "_exception", "=", "exception", "self", ".", "_scheduler", ".", "emergesend", "(", "FutureEvent", "(", "self", ",", "exception", "=", "exception", ")", ")" ]

[ "Set", "an", "exception", "to", "Future", "object", "wake", "up", "all", "the", "waiters", ":", "param", "exception", ":", "exception", "to", "set" ]

[ "def", "get_model", "(", "PARAMS", ")", ":", "model_dict", "=", "{", "'LinearRegression'", ":", "LinearRegression", "(", ")", ",", "'SVR'", ":", "SVR", "(", ")", ",", "'KNeighborsRegressor'", ":", "KNeighborsRegressor", "(", ")", ",", "'DecisionTreeRegressor'", ":", "DecisionTreeRegressor", "(", ")", "}", "if", "not", "model_dict", ".", "get", "(", "PARAMS", "[", "'model_name'", "]", ")", ":", "LOG", ".", "exception", "(", "'Not supported model!'", ")", "exit", "(", "1", ")", "model", "=", "model_dict", "[", "PARAMS", "[", "'model_name'", "]", "]", "try", ":", "if", "PARAMS", "[", "'model_name'", "]", "==", "'SVR'", ":", "model", ".", "kernel", "=", "PARAMS", "[", "'svr_kernel'", "]", "elif", "PARAMS", "[", "'model_name'", "]", "==", "'KNeighborsRegressor'", ":", "model", ".", "weights", "=", "PARAMS", "[", "'knr_weights'", "]", "except", "Exception", "as", "exception", ":", "LOG", ".", "exception", "(", "exception", ")", "raise", "return", "model" ]

[ "Get", "model", "according", "to", "parameters" ]

[ "def", "_catalog_filter_schemas", "(", "manifest", ")", ":", "schemas", "=", "frozenset", "(", "(", "d", ".", "lower", "(", ")", ",", "s", ".", "lower", "(", ")", ")", "for", "d", ",", "s", "in", "manifest", ".", "get_used_schemas", "(", ")", ")", "def", "test", "(", "row", ")", ":", "table_database", "=", "_expect_row_value", "(", "'table_database'", ",", "row", ")", "table_schema", "=", "_expect_row_value", "(", "'table_schema'", ",", "row", ")", "# the schema may be present but None, which is not an error and should", "# be filtered out", "if", "table_schema", "is", "None", ":", "return", "False", "return", "(", "table_database", ".", "lower", "(", ")", ",", "table_schema", ".", "lower", "(", ")", ")", "in", "schemas", "return", "test" ]

[ "Return", "a", "function", "that", "takes", "a", "row", "and", "decides", "if", "the", "row", "should", "be", "included", "in", "the", "catalog", "output", "." ]

[ "def", "dictify_urn", "(", "urn", ",", "combine_interval", "=", "True", ")", ":", "ioos_urn", "=", "IoosUrn", ".", "from_string", "(", "urn", ")", "if", "ioos_urn", ".", "valid", "(", ")", "is", "False", ":", "return", "dict", "(", ")", "if", "ioos_urn", ".", "asset_type", "!=", "'sensor'", ":", "logger", ".", "error", "(", "\"This function only works on 'sensor' URNs.\"", ")", "return", "dict", "(", ")", "if", "'#'", "in", "ioos_urn", ".", "component", ":", "standard_name", ",", "extras", "=", "ioos_urn", ".", "component", ".", "split", "(", "'#'", ")", "else", ":", "standard_name", "=", "ioos_urn", ".", "component", "extras", "=", "''", "d", "=", "dict", "(", "standard_name", "=", "standard_name", ")", "# Discriminant", "if", "'-'", "in", "ioos_urn", ".", "component", ":", "d", "[", "'discriminant'", "]", "=", "standard_name", ".", "split", "(", "'-'", ")", "[", "-", "1", "]", "d", "[", "'standard_name'", "]", "=", "standard_name", ".", "split", "(", "'-'", ")", "[", "0", "]", "intervals", "=", "[", "]", "cell_methods", "=", "[", "]", "if", "extras", ":", "for", "section", "in", "extras", ".", "split", "(", "';'", ")", ":", "key", ",", "values", "=", "section", ".", "split", "(", "'='", ")", "if", "key", "==", "'interval'", ":", "# special case, intervals should be appended to the cell_methods", "for", "v", "in", "values", ".", "split", "(", "','", ")", ":", "intervals", ".", "append", "(", "v", ")", "else", ":", "if", "key", "==", "'cell_methods'", ":", "value", "=", "[", "x", ".", "replace", "(", "'_'", ",", "' '", ")", ".", "replace", "(", "':'", ",", "': '", ")", "for", "x", "in", "values", ".", "split", "(", "','", ")", "]", "cell_methods", "=", "value", "else", ":", "value", "=", "' '", ".", "join", "(", "[", "x", ".", "replace", "(", "'_'", ",", "' '", ")", ".", "replace", "(", "':'", ",", "': '", ")", "for", "x", "in", "values", ".", "split", "(", "','", ")", "]", ")", "d", "[", "key", "]", "=", "value", "if", "combine_interval", "is", "True", ":", "if", "cell_methods", "and", "intervals", ":", "if", "len", "(", "cell_methods", ")", "==", "len", "(", "intervals", ")", ":", "d", "[", "'cell_methods'", "]", "=", "' '", ".", "join", "(", "[", "'{} (interval: {})'", ".", "format", "(", "x", "[", "0", "]", ",", "x", "[", "1", "]", ".", "upper", "(", ")", ")", "for", "x", "in", "zip", "(", "cell_methods", ",", "intervals", ")", "]", ")", "else", ":", "d", "[", "'cell_methods'", "]", "=", "' '", ".", "join", "(", "cell_methods", ")", "for", "i", "in", "intervals", ":", "d", "[", "'cell_methods'", "]", "+=", "' (interval: {})'", ".", "format", "(", "i", ".", "upper", "(", ")", ")", "elif", "cell_methods", ":", "d", "[", "'cell_methods'", "]", "=", "' '", ".", "join", "(", "cell_methods", ")", "for", "i", "in", "intervals", ":", "d", "[", "'cell_methods'", "]", "+=", "' (interval: {})'", ".", "format", "(", "i", ".", "upper", "(", ")", ")", "elif", "intervals", ":", "raise", "ValueError", "(", "\"An interval without a cell_method is not allowed! Not possible!\"", ")", "else", ":", "d", "[", "'cell_methods'", "]", "=", "' '", ".", "join", "(", "cell_methods", ")", "d", "[", "'interval'", "]", "=", "','", ".", "join", "(", "intervals", ")", ".", "upper", "(", ")", "if", "'vertical_datum'", "in", "d", ":", "d", "[", "'vertical_datum'", "]", "=", "d", "[", "'vertical_datum'", "]", ".", "upper", "(", ")", "return", "d" ]

[ "By", "default", "this", "will", "put", "the", "interval", "as", "part", "of", "the", "cell_methods", "attribute", "(", "NetCDF", "CF", "style", ")", ".", "To", "return", "interval", "as", "its", "own", "key", "use", "the", "combine_interval", "=", "False", "parameter", "." ]

[ "def", "Stein_Schmidt", "(", "m", ",", "Dtank", ",", "Djacket", ",", "H", ",", "Dinlet", ",", "rho", ",", "Cp", ",", "k", ",", "mu", ",", "muw", "=", "None", ",", "rhow", "=", "None", ",", "inlettype", "=", "'tangential'", ",", "inletlocation", "=", "'auto'", ",", "roughness", "=", "0", ")", ":", "delta", "=", "(", "Djacket", "-", "Dtank", ")", "/", "2.", "Q", "=", "m", "/", "rho", "Pr", "=", "Cp", "*", "mu", "/", "k", "lch", "=", "(", "pi", "**", "2", "/", "4", "*", "Dtank", "**", "2", "+", "H", "**", "2", ")", "**", "0.5", "dch", "=", "2", "*", "delta", "if", "inlettype", "==", "'radial'", ":", "bEin", "=", "pi", "/", "8", "*", "Dinlet", "**", "2", "/", "delta", "bMit", "=", "pi", "/", "2", "*", "Dtank", "*", "(", "1", "+", "pi", "**", "2", "/", "4", "*", "Dtank", "**", "2", "/", "H", "**", "2", ")", "**", "0.5", "vMit", "=", "Q", "/", "(", "2", "*", "delta", "*", "bMit", ")", "vch", "=", "vMit", "*", "log", "(", "bMit", "/", "bEin", ")", "/", "(", "1", "-", "bEin", "/", "bMit", ")", "ReJ", "=", "vch", "*", "dch", "*", "rho", "/", "mu", "elif", "inlettype", "==", "'tangential'", ":", "f", "=", "friction_factor", "(", "1E5", ",", "roughness", "/", "dch", ")", "for", "run", "in", "range", "(", "5", ")", ":", "vinlet", "=", "Q", "/", "(", "pi", "/", "4", "*", "Dinlet", "**", "2", ")", "vz", "=", "Q", "/", "(", "pi", "*", "Dtank", "*", "delta", ")", "K4", "=", "Dinlet", "**", "2", "*", "vinlet", "**", "2", "/", "(", "2", "*", "f", "*", "Dtank", "*", "H", ")", "K3", "=", "vinlet", "/", "4.", "-", "Dinlet", "**", "2", "*", "vinlet", "/", "(", "4", "*", "f", "*", "Dtank", "*", "H", ")", "vx0", "=", "K3", "+", "(", "K3", "**", "2", "+", "K4", ")", "**", "0.5", "vx", "=", "vinlet", "*", "log", "(", "1", "+", "f", "*", "Dtank", "*", "H", "/", "Dinlet", "**", "2", "*", "vx0", "/", "vinlet", ")", "/", "(", "f", "*", "Dtank", "*", "H", "/", "Dinlet", "**", "2", ")", "vch", "=", "(", "vx", "**", "2", "+", "vz", "**", "2", ")", "**", "0.5", "ReJ", "=", "vch", "*", "dch", "*", "rho", "/", "mu", "f", "=", "friction_factor", "(", "ReJ", ",", "roughness", "/", "dch", ")", "if", "inletlocation", "and", "rhow", ":", "GrJ", "=", "g", "*", "rho", "*", "(", "rho", "-", "rhow", ")", "*", "dch", "**", "3", "/", "mu", "**", "2", "if", "rhow", "<", "rho", ":", "# Heating jacket fluid", "if", "inletlocation", "==", "'auto'", "or", "inletlocation", "==", "'bottom'", ":", "ReJeq", "=", "(", "ReJ", "**", "2", "+", "GrJ", "*", "H", "/", "dch", "/", "50.", ")", "**", "0.5", "else", ":", "ReJeq", "=", "(", "ReJ", "**", "2", "-", "GrJ", "*", "H", "/", "dch", "/", "50.", ")", "**", "0.5", "else", ":", "# Cooling jacket fluid", "if", "inletlocation", "==", "'auto'", "or", "inletlocation", "==", "'top'", ":", "ReJeq", "=", "(", "ReJ", "**", "2", "+", "GrJ", "*", "H", "/", "dch", "/", "50.", ")", "**", "0.5", "else", ":", "ReJeq", "=", "(", "ReJ", "**", "2", "-", "GrJ", "*", "H", "/", "dch", "/", "50.", ")", "**", "0.5", "else", ":", "ReJeq", "=", "(", "ReJ", "**", "2", ")", "**", "0.5", "NuA", "=", "3.66", "NuB", "=", "1.62", "*", "Pr", "**", "(", "1", "/", "3.", ")", "*", "ReJeq", "**", "(", "1", "/", "3.", ")", "*", "(", "dch", "/", "lch", ")", "**", "(", "1", "/", "3.", ")", "NuC", "=", "0.664", "*", "Pr", "**", "(", "1", "/", "3.", ")", "*", "(", "ReJeq", "*", "dch", "/", "lch", ")", "**", "0.5", "if", "ReJeq", "<", "2300", ":", "NuD", "=", "0", "else", ":", "NuD", "=", "0.0115", "*", "Pr", "**", "(", "1", "/", "3.", ")", "*", "ReJeq", "**", "0.9", "*", "(", "1", "-", "(", "2300.", "/", "ReJeq", ")", "**", "2.5", ")", "*", "(", "1", "+", "(", "dch", "/", "lch", ")", "**", "(", "2", "/", "3.", ")", ")", "if", "muw", ":", "NuJ", "=", "(", "NuA", "**", "3", "+", "NuB", "**", "3", "+", "NuC", "**", "3", "+", "NuD", "**", "3", ")", "**", "(", "1", "/", "3.", ")", "*", "(", "mu", "/", "muw", ")", "**", "0.14", "else", ":", "NuJ", "=", "(", "NuA", "**", "3", "+", "NuB", "**", "3", "+", "NuC", "**", "3", "+", "NuD", "**", "3", ")", "**", "(", "1", "/", "3.", ")", "return", "NuJ", "*", "k", "/", "dch" ]

[ "r", "Calculates", "average", "heat", "transfer", "coefficient", "for", "a", "jacket", "around", "a", "vessel", "according", "to", "[", "1", "]", "_", "as", "described", "in", "[", "2", "]", "_", "." ]

[ "def", "purge_queues", "(", "self", ",", "queues", ")", ":", "for", "name", ",", "vhost", "in", "queues", ":", "vhost", "=", "quote", "(", "vhost", ",", "''", ")", "name", "=", "quote", "(", "name", ",", "''", ")", "path", "=", "Client", ".", "urls", "[", "'purge_queue'", "]", "%", "(", "vhost", ",", "name", ")", "self", ".", "_call", "(", "path", ",", "'DELETE'", ")", "return", "True" ]

[ "Purge", "all", "messages", "from", "one", "or", "more", "queues", "." ]

[ "def", "get_programs_dict", "(", "pkgname_only", "=", "None", ",", "flag_protected", "=", "False", ")", ":", "___ret", "=", "_get_programs_dict", "(", ")", "__ret", "=", "___ret", "if", "pkgname_only", "is", "None", "else", "OrderedDict", "(", "(", "(", "pkgname_only", ",", "___ret", "[", "pkgname_only", "]", ")", ",", ")", ")", "if", "flag_protected", ":", "_ret", "=", "__ret", "else", ":", "_ret", "=", "copy", ".", "deepcopy", "(", "__ret", ")", "for", "value", "in", "_ret", ".", "values", "(", ")", ":", "value", "[", "\"exeinfo\"", "]", "=", "[", "exeinfo", "for", "exeinfo", "in", "value", "[", "\"exeinfo\"", "]", "if", "not", "exeinfo", ".", "filename", ".", "startswith", "(", "\"_\"", ")", "]", "# Removes packages that may have gone out of scripts after filtering", "ret", "=", "_ret", "if", "pkgname_only", "is", "None", "and", "flag_protected", "is", "None", "else", "OrderedDict", "(", "(", "(", "key", ",", "value", ")", "for", "key", ",", "value", "in", "_ret", ".", "items", "(", ")", "if", "len", "(", "value", "[", "\"exeinfo\"", "]", ")", ">", "0", ")", ")", "return", "ret" ]

[ "Scans", "COLLABORATORS_S", "packages", "for", "scripts", "eventually", "filtering", "if", "arguments", "passed" ]

[ "def", "warn_if_nans_exist", "(", "X", ")", ":", "null_count", "=", "count_rows_with_nans", "(", "X", ")", "total", "=", "len", "(", "X", ")", "percent", "=", "100", "*", "null_count", "/", "total", "if", "null_count", ">", "0", ":", "warning_message", "=", "'Warning! Found {} rows of {} ({:0.2f}%) with nan values. Only '", "'complete rows will be plotted.'", ".", "format", "(", "null_count", ",", "total", ",", "percent", ")", "warnings", ".", "warn", "(", "warning_message", ",", "DataWarning", ")" ]

[ "Warn", "if", "nans", "exist", "in", "a", "numpy", "array", "." ]

[ "def", "filter", "(", "self", ",", "*", "*", "kwargs", ")", ":", "if", "not", "self", ".", "initialized", ":", "self", ".", "initialize", "(", ")", "cards", "=", "self", ".", "values", "(", ")", "if", "\"type\"", "not", "in", "kwargs", ":", "kwargs", "[", "\"type\"", "]", "=", "[", "CardType", ".", "SPELL", ",", "CardType", ".", "WEAPON", ",", "CardType", ".", "MINION", "]", "for", "attr", ",", "value", "in", "kwargs", ".", "items", "(", ")", ":", "if", "value", "is", "not", "None", ":", "# What? this doesn't work?", "# cards = __builtins__[\"filter\"](lambda c: getattr(c, attr) == value, cards)", "cards", "=", "[", "card", "for", "card", "in", "cards", "if", "(", "isinstance", "(", "value", ",", "list", ")", "and", "getattr", "(", "card", ",", "attr", ")", "in", "value", ")", "or", "getattr", "(", "card", ",", "attr", ")", "==", "value", "]", "return", "[", "card", ".", "id", "for", "card", "in", "cards", "]" ]

[ "Returns", "a", "list", "of", "card", "IDs", "matching", "the", "given", "filters", ".", "Each", "filter", "if", "not", "None", "is", "matched", "against", "the", "registered", "card", "database", ".", "cards", ".", "Examples", "arguments", ":", "\\", "a", "collectible", ":", "Whether", "the", "card", "is", "collectible", "or", "not", ".", "\\", "a", "type", ":", "The", "type", "of", "the", "card", "(", "hearthstone", ".", "enums", ".", "CardType", ")", "\\", "a", "race", ":", "The", "race", "(", "tribe", ")", "of", "the", "card", "(", "hearthstone", ".", "enums", ".", "Race", ")", "\\", "a", "rarity", ":", "The", "rarity", "of", "the", "card", "(", "hearthstone", ".", "enums", ".", "Rarity", ")", "\\", "a", "cost", ":", "The", "mana", "cost", "of", "the", "card" ]

[ "def", "with_settings", "(", "self", ",", "stop", ":", "Optional", "[", "int", "]", "=", "None", ",", "start", ":", "int", "=", "0", ",", "step", ":", "int", "=", "1", ")", "->", "'Loop'", ":", "self", ".", "start", "=", "start", "self", ".", "stop", "=", "stop", "self", ".", "step", "=", "step", "return", "self" ]

[ "Set", "start", "stop", "and", "step", "loop", "configuration", "." ]

[ "def", "_wait_until", "(", "obj", ",", "att", ",", "desired", ",", "callback", ",", "interval", ",", "attempts", ",", "verbose", ",", "verbose_atts", ")", ":", "if", "not", "isinstance", "(", "desired", ",", "(", "list", ",", "tuple", ")", ")", ":", "desired", "=", "[", "desired", "]", "if", "verbose_atts", "is", "None", ":", "verbose_atts", "=", "[", "]", "if", "not", "isinstance", "(", "verbose_atts", ",", "(", "list", ",", "tuple", ")", ")", ":", "verbose_atts", "=", "[", "verbose_atts", "]", "infinite", "=", "(", "attempts", "==", "0", ")", "attempt", "=", "0", "start", "=", "time", ".", "time", "(", ")", "while", "infinite", "or", "(", "attempt", "<", "attempts", ")", ":", "try", ":", "# For servers:", "obj", ".", "get", "(", ")", "except", "AttributeError", ":", "try", ":", "# For other objects that don't support .get()", "obj", "=", "obj", ".", "manager", ".", "get", "(", "obj", ".", "id", ")", "except", "AttributeError", ":", "# punt", "raise", "exc", ".", "NoReloadError", "(", "\"The 'wait_until' method is not \"", "\"supported for '%s' objects.\"", "%", "obj", ".", "__class__", ")", "attval", "=", "getattr", "(", "obj", ",", "att", ")", "if", "verbose", ":", "elapsed", "=", "time", ".", "time", "(", ")", "-", "start", "msgs", "=", "[", "\"Current value of %s: %s (elapsed: %4.1f seconds)\"", "%", "(", "att", ",", "attval", ",", "elapsed", ")", "]", "for", "vatt", "in", "verbose_atts", ":", "vattval", "=", "getattr", "(", "obj", ",", "vatt", ",", "None", ")", "msgs", ".", "append", "(", "\"%s=%s\"", "%", "(", "vatt", ",", "vattval", ")", ")", "print", "(", "\" \"", ".", "join", "(", "msgs", ")", ")", "if", "attval", "in", "desired", ":", "return", "obj", "time", ".", "sleep", "(", "interval", ")", "attempt", "+=", "1", "return", "obj" ]

[ "Loops", "until", "either", "the", "desired", "value", "of", "the", "attribute", "is", "reached", "or", "the", "number", "of", "attempts", "is", "exceeded", "." ]

[ "def", "_generate_route_objects_m", "(", "self", ",", "route_schema", ",", "namespace", ")", ":", "output_path", "=", "'Routes/RouteObjects/{}.m'", ".", "format", "(", "fmt_route_obj_class", "(", "namespace", ".", "name", ")", ")", "with", "self", ".", "output_to_relative_path", "(", "output_path", ")", ":", "self", ".", "emit_raw", "(", "base_file_comment", ")", "import_classes", "=", "[", "fmt_route_obj_class", "(", "namespace", ".", "name", ")", ",", "'DBStoneBase'", ",", "'DBRequestErrors'", ",", "]", "for", "auth_type", "in", "self", ".", "namespace_to_has_route_auth_list", "[", "namespace", "]", ":", "import_classes", ".", "append", "(", "fmt_routes_class", "(", "namespace", ".", "name", ",", "auth_type", ")", ")", "imports_classes_m", "=", "import_classes", "+", "self", ".", "_get_imports_m", "(", "self", ".", "_get_namespace_route_imports", "(", "namespace", ",", "include_route_args", "=", "False", ")", ",", "[", "]", ")", "self", ".", "_generate_imports_m", "(", "imports_classes_m", ")", "with", "self", ".", "block_m", "(", "fmt_route_obj_class", "(", "namespace", ".", "name", ")", ")", ":", "for", "route", "in", "namespace", ".", "routes", ":", "route_name", "=", "fmt_route_var", "(", "namespace", ".", "name", ",", "route", ")", "self", ".", "emit", "(", "'static DBRoute *{};'", ".", "format", "(", "route_name", ")", ")", "self", ".", "emit", "(", ")", "for", "route", "in", "namespace", ".", "routes", ":", "route_name", "=", "fmt_route_var", "(", "namespace", ".", "name", ",", "route", ")", "if", "route", ".", "version", "==", "1", ":", "route_path", "=", "route", ".", "name", "else", ":", "route_path", "=", "'{}_v{}'", ".", "format", "(", "route", ".", "name", ",", "route", ".", "version", ")", "if", "route", ".", "deprecated", ":", "deprecated", "=", "'@{}'", ".", "format", "(", "'YES'", ")", "else", ":", "deprecated", "=", "'@{}'", ".", "format", "(", "'NO'", ")", "if", "not", "is_void_type", "(", "route", ".", "result_data_type", ")", ":", "caller", "=", "fmt_class_type", "(", "route", ".", "result_data_type", ",", "suppress_ptr", "=", "True", ")", "result_type", "=", "fmt_func_call", "(", "caller", "=", "caller", ",", "callee", "=", "'class'", ")", "else", ":", "result_type", "=", "'nil'", "if", "not", "is_void_type", "(", "route", ".", "error_data_type", ")", ":", "caller", "=", "fmt_class_type", "(", "route", ".", "error_data_type", ",", "suppress_ptr", "=", "True", ")", "error_type", "=", "fmt_func_call", "(", "caller", "=", "caller", ",", "callee", "=", "'class'", ")", "else", ":", "error_type", "=", "'nil'", "if", "is_list_type", "(", "route", ".", "arg_data_type", ")", "or", "is_map_type", "(", "route", ".", "arg_data_type", ")", ":", "dataStructSerialBlock", "=", "'^id(id dataStruct) {{ return {}; }}'", ".", "format", "(", "self", ".", "_fmt_serialization_call", "(", "route", ".", "result_data_type", ",", "'dataStruct'", ",", "True", ")", ")", "else", ":", "dataStructSerialBlock", "=", "'nil'", "if", "is_list_type", "(", "route", ".", "result_data_type", ")", "or", "is_map_type", "(", "route", ".", "result_data_type", ")", ":", "dataStructDeserialBlock", "=", "'^id(id dataStruct) {{ return {}; }}'", ".", "format", "(", "self", ".", "_fmt_serialization_call", "(", "route", ".", "result_data_type", ",", "'dataStruct'", ",", "False", ")", ")", "else", ":", "dataStructDeserialBlock", "=", "'nil'", "with", "self", ".", "block_func", "(", "func", "=", "route_name", ",", "args", "=", "[", "]", ",", "return_type", "=", "'DBRoute *'", ",", "class_func", "=", "True", ")", ":", "with", "self", ".", "block", "(", "'if (!{})'", ".", "format", "(", "route_name", ")", ")", ":", "with", "self", ".", "block", "(", "'{} = [[DBRoute alloc] init:'", ".", "format", "(", "route_name", ")", ",", "delim", "=", "(", "None", ",", "None", ")", ",", "after", "=", "'];'", ")", ":", "self", ".", "emit", "(", "'@\\\"{}\\\"'", ".", "format", "(", "route_path", ")", ")", "self", ".", "emit", "(", "'namespace_:@\\\"{}\\\"'", ".", "format", "(", "namespace", ".", "name", ")", ")", "self", ".", "emit", "(", "'deprecated:{}'", ".", "format", "(", "deprecated", ")", ")", "self", ".", "emit", "(", "'resultType:{}'", ".", "format", "(", "result_type", ")", ")", "self", ".", "emit", "(", "'errorType:{}'", ".", "format", "(", "error_type", ")", ")", "attrs", "=", "[", "]", "for", "field", "in", "route_schema", ".", "fields", ":", "attr_key", "=", "field", ".", "name", "attr_val", "=", "(", "\"@\\\"{}\\\"\"", ".", "format", "(", "route", ".", "attrs", ".", "get", "(", "attr_key", ")", ")", "if", "route", ".", "attrs", ".", "get", "(", "attr_key", ")", "else", "'nil'", ")", "attrs", ".", "append", "(", "'@\\\"{}\\\": {}'", ".", "format", "(", "attr_key", ",", "attr_val", ")", ")", "self", ".", "generate_multiline_list", "(", "attrs", ",", "delim", "=", "(", "'attrs:@{'", ",", "'}'", ")", ",", "compact", "=", "True", ")", "self", ".", "emit", "(", "'dataStructSerialBlock:{}'", ".", "format", "(", "dataStructSerialBlock", ")", ")", "self", ".", "emit", "(", "'dataStructDeserialBlock:{}'", ".", "format", "(", "dataStructDeserialBlock", ")", ")", "self", ".", "emit", "(", "'return {};'", ".", "format", "(", "route_name", ")", ")", "self", ".", "emit", "(", ")" ]

[ "Emits", "implementation", "files", "for", "Route", "objects", "which", "encapsulate", "information", "regarding", "each", "route", ".", "These", "objects", "are", "passed", "as", "parameters", "when", "route", "calls", "are", "made", "." ]

[ "def", "present", "(", "dbname", ",", "name", ",", "owner", "=", "None", ",", "user", "=", "None", ",", "db_user", "=", "None", ",", "db_password", "=", "None", ",", "db_host", "=", "None", ",", "db_port", "=", "None", ")", ":", "ret", "=", "{", "'dbname'", ":", "dbname", ",", "'name'", ":", "name", ",", "'changes'", ":", "{", "}", ",", "'result'", ":", "True", ",", "'comment'", ":", "'Schema {0} is already present in '", "'database {1}'", ".", "format", "(", "name", ",", "dbname", ")", "}", "db_args", "=", "{", "'db_user'", ":", "db_user", ",", "'db_password'", ":", "db_password", ",", "'db_host'", ":", "db_host", ",", "'db_port'", ":", "db_port", ",", "'user'", ":", "user", "}", "# check if schema exists", "schema_attr", "=", "__salt__", "[", "'postgres.schema_get'", "]", "(", "dbname", ",", "name", ",", "*", "*", "db_args", ")", "cret", "=", "None", "# The schema is not present, make it!", "if", "schema_attr", "is", "None", ":", "if", "__opts__", "[", "'test'", "]", ":", "ret", "[", "'result'", "]", "=", "None", "ret", "[", "'comment'", "]", "=", "'Schema {0} is set to be created'", "' in database {1}.'", ".", "format", "(", "name", ",", "dbname", ")", "return", "ret", "cret", "=", "__salt__", "[", "'postgres.schema_create'", "]", "(", "dbname", ",", "name", ",", "owner", "=", "owner", ",", "*", "*", "db_args", ")", "else", ":", "msg", "=", "'Schema {0} already exists in database {1}'", "cret", "=", "None", "if", "cret", ":", "msg", "=", "'Schema {0} has been created in database {1}'", "ret", "[", "'result'", "]", "=", "True", "ret", "[", "'changes'", "]", "[", "name", "]", "=", "'Present'", "elif", "cret", "is", "not", "None", ":", "msg", "=", "'Failed to create schema {0} in database {1}'", "ret", "[", "'result'", "]", "=", "False", "else", ":", "msg", "=", "'Schema {0} already exists in database {1}'", "ret", "[", "'result'", "]", "=", "True", "ret", "[", "'comment'", "]", "=", "msg", ".", "format", "(", "name", ",", "dbname", ")", "return", "ret" ]

[ "Ensure", "that", "the", "named", "schema", "is", "present", "in", "the", "database", "." ]