Datasets:

kejian

/

codesearchnet-python-rebalanced

like 1

[ "def", "experiment", "(", "qnum", ",", "repetitions", "=", "100", ")", ":", "def", "example_gate", "(", "phi", ")", ":", "\"\"\"An example unitary 1-qubit gate U with an eigen vector |0> and an\n eigen value exp(2*Pi*i*phi)\n \"\"\"", "gate", "=", "cirq", ".", "SingleQubitMatrixGate", "(", "matrix", "=", "np", ".", "array", "(", "[", "[", "np", ".", "exp", "(", "2", "*", "np", ".", "pi", "*", "1.0j", "*", "phi", ")", ",", "0", "]", ",", "[", "0", ",", "1", "]", "]", ")", ")", "return", "gate", "print", "(", "'Estimation with {}qubits.'", ".", "format", "(", "qnum", ")", ")", "print", "(", "'Actual, Estimation (Raw binary)'", ")", "errors", "=", "[", "]", "fold_func", "=", "lambda", "ms", ":", "''", ".", "join", "(", "np", ".", "flip", "(", "ms", ",", "0", ")", ".", "astype", "(", "int", ")", ".", "astype", "(", "str", ")", ")", "for", "phi", "in", "np", ".", "arange", "(", "0", ",", "1", ",", "0.1", ")", ":", "result", "=", "run_estimate", "(", "example_gate", "(", "phi", ")", ",", "qnum", ",", "repetitions", ")", "hist", "=", "result", ".", "histogram", "(", "key", "=", "'phase'", ",", "fold_func", "=", "fold_func", ")", "estimate_bin", "=", "hist", ".", "most_common", "(", "1", ")", "[", "0", "]", "[", "0", "]", "estimate", "=", "(", "sum", "(", "[", "float", "(", "s", ")", "*", "0.5", "**", "(", "order", "+", "1", ")", "for", "order", ",", "s", "in", "enumerate", "(", "estimate_bin", ")", "]", ")", ")", "print", "(", "'{:0.4f}, {:0.4f} ({})'", ".", "format", "(", "phi", ",", "estimate", ",", "estimate_bin", ")", ")", "errors", ".", "append", "(", "(", "phi", "-", "estimate", ")", "**", "2", ")", "print", "(", "'RMS Error: {:0.4f}\\n'", ".", "format", "(", "np", ".", "sqrt", "(", "sum", "(", "errors", ")", "/", "len", "(", "errors", ")", ")", ")", ")" ]

[ "def", "_update_rs_with_primary_from_member", "(", "sds", ",", "replica_set_name", ",", "server_description", ")", ":", "assert", "replica_set_name", "is", "not", "None", "if", "replica_set_name", "!=", "server_description", ".", "replica_set_name", ":", "sds", ".", "pop", "(", "server_description", ".", "address", ")", "elif", "(", "server_description", ".", "me", "and", "server_description", ".", "address", "!=", "server_description", ".", "me", ")", ":", "sds", ".", "pop", "(", "server_description", ".", "address", ")", "# Had this member been the primary?", "return", "_check_has_primary", "(", "sds", ")" ]

[ "def", "set_widgets", "(", "self", ")", ":", "self", ".", "clear_further_steps", "(", ")", "# Set widgets", "purpose", "=", "self", ".", "parent", ".", "step_kw_purpose", ".", "selected_purpose", "(", ")", "subcategory", "=", "self", ".", "parent", ".", "step_kw_subcategory", ".", "selected_subcategory", "(", ")", "self", ".", "lblSelectUnit", ".", "setText", "(", "unit_question", "%", "(", "subcategory", "[", "'name'", "]", ",", "purpose", "[", "'name'", "]", ")", ")", "self", ".", "lblDescribeUnit", ".", "setText", "(", "''", ")", "self", ".", "lstUnits", ".", "clear", "(", ")", "subcat", "=", "self", ".", "parent", ".", "step_kw_subcategory", ".", "selected_subcategory", "(", ")", "[", "'key'", "]", "if", "purpose", "==", "layer_purpose_hazard", ":", "units_for_layer", "=", "hazard_units", "(", "subcat", ")", "else", ":", "units_for_layer", "=", "exposure_units", "(", "subcat", ")", "for", "unit_for_layer", "in", "units_for_layer", ":", "item", "=", "QListWidgetItem", "(", "unit_for_layer", "[", "'name'", "]", ",", "self", ".", "lstUnits", ")", "item", ".", "setData", "(", "QtCore", ".", "Qt", ".", "UserRole", ",", "unit_for_layer", "[", "'key'", "]", ")", "self", ".", "lstUnits", ".", "addItem", "(", "item", ")", "# Set values based on existing keywords (if already assigned)", "if", "self", ".", "parent", ".", "step_kw_purpose", ".", "selected_purpose", "(", ")", "==", "layer_purpose_hazard", ":", "key", "=", "continuous_hazard_unit", "[", "'key'", "]", "else", ":", "key", "=", "exposure_unit", "[", "'key'", "]", "unit_id", "=", "self", ".", "parent", ".", "get_existing_keyword", "(", "key", ")", "if", "unit_id", ":", "units", "=", "[", "]", "for", "index", "in", "range", "(", "self", ".", "lstUnits", ".", "count", "(", ")", ")", ":", "item", "=", "self", ".", "lstUnits", ".", "item", "(", "index", ")", "units", ".", "append", "(", "item", ".", "data", "(", "QtCore", ".", "Qt", ".", "UserRole", ")", ")", "if", "unit_id", "in", "units", ":", "self", ".", "lstUnits", ".", "setCurrentRow", "(", "units", ".", "index", "(", "unit_id", ")", ")", "self", ".", "auto_select_one_item", "(", "self", ".", "lstUnits", ")" ]

[ "def", "close", "(", "self", ")", ":", "# Seek to the start of the buffer", "self", ".", "seek", "(", "0", ")", "while", "True", ":", "# Copy bytes from the buffer until we reach the end of the JSON", "brace_count", "=", "0", "quoted", "=", "False", "json_string", "=", "''", "while", "True", ":", "# Read a character", "b", "=", "self", ".", "read", "(", "1", ")", "if", "b", "==", "b''", ":", "return", "c", "=", "b", ".", "decode", "(", ")", "# If it is a \\ then copy the next character", "if", "c", "==", "'\\\\'", ":", "json_string", "+=", "c", "json_string", "+=", "self", ".", "read", "(", "1", ")", ".", "decode", "(", ")", "continue", "# If we are inside quotes we just need to detect a", "# closing quote", "if", "c", "==", "'\"'", ":", "if", "quoted", ":", "quoted", "=", "False", "else", ":", "quoted", "=", "True", "# Otherwise we count the braces", "if", "c", "==", "'{'", ":", "brace_count", "+=", "1", "elif", "c", "==", "'}'", ":", "brace_count", "-=", "1", "# Copy the character into the JSON string", "json_string", "+=", "c", "# If the brace count is zero we are done", "if", "brace_count", "==", "0", ":", "break", "# Parse the JSON so that we can get the size of the data array", "meta", "=", "json", ".", "loads", "(", "json_string", ")", "n_channels", "=", "meta", "[", "'data_cube'", "]", "[", "'n_channels'", "]", "n_sub_integrations", "=", "meta", "[", "'data_cube'", "]", "[", "'n_sub_integrations'", "]", "# Save the JSON to a file", "f", "=", "open", "(", "'{0}_{1}_{2}.json'", ".", "format", "(", "meta", "[", "'metadata'", "]", "[", "'observation_id'", "]", ",", "meta", "[", "'metadata'", "]", "[", "'beam_id'", "]", ",", "meta", "[", "'metadata'", "]", "[", "'name'", "]", ")", ",", "'w'", ")", "f", ".", "write", "(", "json", ".", "dumps", "(", "meta", ")", ")", "f", ".", "close", "(", ")", "# Read the data", "data", "=", "self", ".", "read", "(", "n_channels", "*", "n_sub_integrations", ")", "# Write it to a file", "f", "=", "open", "(", "'{0}_{1}_{2}.data'", ".", "format", "(", "meta", "[", "'metadata'", "]", "[", "'observation_id'", "]", ",", "meta", "[", "'metadata'", "]", "[", "'beam_id'", "]", ",", "meta", "[", "'metadata'", "]", "[", "'name'", "]", ")", ",", "'wb'", ")", "f", ".", "write", "(", "data", ")", "f", ".", "close", "(", ")" ]

[ "def", "connect_patch_namespaced_pod_proxy_with_path", "(", "self", ",", "name", ",", "namespace", ",", "path", ",", "*", "*", "kwargs", ")", ":", "# noqa: E501", "kwargs", "[", "'_return_http_data_only'", "]", "=", "True", "if", "kwargs", ".", "get", "(", "'async_req'", ")", ":", "return", "self", ".", "connect_patch_namespaced_pod_proxy_with_path_with_http_info", "(", "name", ",", "namespace", ",", "path", ",", "*", "*", "kwargs", ")", "# noqa: E501", "else", ":", "(", "data", ")", "=", "self", ".", "connect_patch_namespaced_pod_proxy_with_path_with_http_info", "(", "name", ",", "namespace", ",", "path", ",", "*", "*", "kwargs", ")", "# noqa: E501", "return", "data" ]

[ "def", "_create_latent_variables", "(", "self", ")", ":", "# Input layer", "for", "unit", "in", "range", "(", "self", ".", "units", ")", ":", "self", ".", "latent_variables", ".", "add_z", "(", "'Constant | Layer '", "+", "str", "(", "1", ")", "+", "' | Unit '", "+", "str", "(", "unit", "+", "1", ")", ",", "fam", ".", "Cauchy", "(", "0", ",", "1", ",", "transform", "=", "None", ")", ",", "fam", ".", "Normal", "(", "0", ",", "3", ")", ")", "for", "ar_term", "in", "range", "(", "self", ".", "ar", ")", ":", "self", ".", "latent_variables", ".", "add_z", "(", "'AR'", "+", "str", "(", "ar_term", "+", "1", ")", "+", "' | Layer '", "+", "str", "(", "1", ")", "+", "' | Unit '", "+", "str", "(", "unit", "+", "1", ")", ",", "fam", ".", "Cauchy", "(", "0", ",", "1", ",", "transform", "=", "None", ")", ",", "fam", ".", "Normal", "(", "0", ",", "3", ")", ")", "for", "z", "in", "range", "(", "len", "(", "self", ".", "X_names", ")", ")", ":", "self", ".", "latent_variables", ".", "add_z", "(", "'Weight '", "+", "self", ".", "X_names", "[", "z", "]", ",", "fam", ".", "Cauchy", "(", "0", ",", "1", ",", "transform", "=", "None", ")", ",", "fam", ".", "Normal", "(", "0", ",", "3", ")", ")", "# Hidden layers", "for", "layer", "in", "range", "(", "1", ",", "self", ".", "layers", ")", ":", "for", "unit", "in", "range", "(", "self", ".", "units", ")", ":", "for", "weight", "in", "range", "(", "self", ".", "units", ")", ":", "self", ".", "latent_variables", ".", "add_z", "(", "'Weight '", "+", "str", "(", "weight", "+", "1", ")", "+", "' | Layer '", "+", "str", "(", "layer", "+", "1", ")", "+", "' | Unit '", "+", "str", "(", "unit", "+", "1", ")", ",", "fam", ".", "Cauchy", "(", "0", ",", "1", ",", "transform", "=", "None", ")", ",", "fam", ".", "Normal", "(", "0", ",", "3", ")", ")", "# Output layer", "for", "weight", "in", "range", "(", "self", ".", "units", ")", ":", "self", ".", "latent_variables", ".", "add_z", "(", "'Output Weight '", "+", "str", "(", "weight", "+", "1", ")", ",", "fam", ".", "Cauchy", "(", "0", ",", "1", ",", "transform", "=", "None", ")", ",", "fam", ".", "Normal", "(", "0", ",", "3", ")", ")" ]

[ "def", "byaxis_out", "(", "self", ")", ":", "space", "=", "self", "class", "FspaceByaxisOut", "(", "object", ")", ":", "\"\"\"Helper class for indexing by output axes.\"\"\"", "def", "__getitem__", "(", "self", ",", "indices", ")", ":", "\"\"\"Return ``self[indices]``.\n\n Parameters\n ----------\n indices : index expression\n Object used to index the output components.\n\n Returns\n -------\n space : `FunctionSpace`\n The resulting space with same domain and scalar output\n data type, but indexed output components.\n\n Raises\n ------\n IndexError\n If this is a space of scalar-valued functions.\n \"\"\"", "try", ":", "iter", "(", "indices", ")", "except", "TypeError", ":", "newshape", "=", "space", ".", "out_shape", "[", "indices", "]", "else", ":", "newshape", "=", "tuple", "(", "space", ".", "out_shape", "[", "int", "(", "i", ")", "]", "for", "i", "in", "indices", ")", "dtype", "=", "(", "space", ".", "scalar_out_dtype", ",", "newshape", ")", "return", "FunctionSpace", "(", "space", ".", "domain", ",", "out_dtype", "=", "dtype", ")", "def", "__repr__", "(", "self", ")", ":", "\"\"\"Return ``repr(self)``.\"\"\"", "return", "repr", "(", "space", ")", "+", "'.byaxis_out'", "return", "FspaceByaxisOut", "(", ")" ]

[ "def", "get_item_bank_id_metadata", "(", "self", ")", ":", "metadata", "=", "dict", "(", "self", ".", "_item_bank_id_metadata", ")", "metadata", ".", "update", "(", "{", "'existing_id_values'", ":", "self", ".", "my_osid_object_form", ".", "_my_map", "[", "'itemBankId'", "]", "}", ")", "return", "Metadata", "(", "*", "*", "metadata", ")" ]

[ "def", "concat_sheets", "(", "xl_path", ":", "str", ",", "sheetnames", "=", "None", ",", "add_tab_names", "=", "False", ")", ":", "xl_path", ",", "choice", "=", "_check_xl_path", "(", "xl_path", ")", "if", "sheetnames", "is", "None", ":", "sheetnames", "=", "get_sheet_list", "(", "xl_path", ")", "sheets", "=", "pd", ".", "read_excel", "(", "xl_path", ",", "sheetname", "=", "sheetnames", ")", "if", "add_tab_names", ":", "for", "tab", "in", "sheets", ":", "sheets", "[", "tab", "]", "[", "'Tab'", "]", "=", "[", "tab", "]", "*", "len", "(", "sheets", "[", "tab", "]", ")", "return", "pd", ".", "concat", "(", "[", "sheets", "[", "tab", "]", "for", "tab", "in", "sheets", "]", ")" ]

[ "def", "update_bgp_speaker", "(", "self", ",", "bgp_speaker_id", ",", "body", "=", "None", ")", ":", "return", "self", ".", "put", "(", "self", ".", "bgp_speaker_path", "%", "bgp_speaker_id", ",", "body", "=", "body", ")" ]

[ "def", "getCollectionClass", "(", "cls", ",", "name", ")", ":", "try", ":", "return", "cls", ".", "collectionClasses", "[", "name", "]", "except", "KeyError", ":", "raise", "KeyError", "(", "\"There is no Collection Class of type: '%s'; currently supported values: [%s]\"", "%", "(", "name", ",", "', '", ".", "join", "(", "getCollectionClasses", "(", ")", ".", "keys", "(", ")", ")", ")", ")" ]

[ "def", "from_tuples_dict", "(", "pair_dict", ")", ":", "lm", "=", "LigandMap", "(", ")", "for", "k", ",", "v", "in", "pair_dict", ".", "iteritems", "(", ")", ":", "lm", ".", "add", "(", "k", "[", "0", "]", ",", "k", "[", "1", "]", ",", "v", "[", "0", "]", ",", "v", "[", "1", "]", ")", "return", "lm" ]

[ "def", "_generate_route_signature", "(", "self", ",", "route", ",", "namespace", ",", "# pylint: disable=unused-argument", "route_args", ",", "extra_args", ",", "doc_list", ",", "task_type_name", ",", "func_suffix", ")", ":", "for", "name", ",", "_", ",", "typ", "in", "extra_args", ":", "route_args", ".", "append", "(", "(", "name", ",", "typ", ")", ")", "deprecated", "=", "'DEPRECATED: '", "if", "route", ".", "deprecated", "else", "''", "func_name", "=", "'{}{}'", ".", "format", "(", "fmt_route_func", "(", "route", ")", ",", "func_suffix", ")", "self", ".", "emit", "(", "comment_prefix", ")", "if", "route", ".", "doc", ":", "route_doc", "=", "self", ".", "process_doc", "(", "route", ".", "doc", ",", "self", ".", "_docf", ")", "else", ":", "route_doc", "=", "'The {} route'", ".", "format", "(", "func_name", ")", "self", ".", "emit_wrapped_text", "(", "deprecated", "+", "route_doc", ",", "prefix", "=", "comment_prefix", ",", "width", "=", "120", ")", "self", ".", "emit", "(", "comment_prefix", ")", "for", "name", ",", "doc", "in", "doc_list", ":", "self", ".", "emit_wrapped_text", "(", "'@param {} {}'", ".", "format", "(", "name", ",", "doc", "if", "doc", "else", "undocumented", ")", ",", "prefix", "=", "comment_prefix", ",", "width", "=", "120", ")", "self", ".", "emit", "(", "comment_prefix", ")", "output", "=", "(", "'@return Through the response callback, the caller will '", "+", "'receive a `{}` object on success or a `{}` object on failure.'", ")", "output", "=", "output", ".", "format", "(", "fmt_type", "(", "route", ".", "result_data_type", ",", "tag", "=", "False", ",", "no_ptr", "=", "True", ")", ",", "fmt_type", "(", "route", ".", "error_data_type", ",", "tag", "=", "False", ",", "no_ptr", "=", "True", ")", ")", "self", ".", "emit_wrapped_text", "(", "output", ",", "prefix", "=", "comment_prefix", ",", "width", "=", "120", ")", "self", ".", "emit", "(", "comment_prefix", ")", "result_type_str", "=", "fmt_type", "(", "route", ".", "result_data_type", ")", "if", "not", "is_void_type", "(", "route", ".", "result_data_type", ")", "else", "'DBNilObject *'", "error_type_str", "=", "fmt_type", "(", "route", ".", "error_data_type", ")", "if", "not", "is_void_type", "(", "route", ".", "error_data_type", ")", "else", "'DBNilObject *'", "return_type", "=", "'{}<{}, {}> *'", ".", "format", "(", "task_type_name", ",", "result_type_str", ",", "error_type_str", ")", "deprecated", "=", "self", ".", "_get_deprecation_warning", "(", "route", ")", "route_signature", "=", "fmt_signature", "(", "func", "=", "func_name", ",", "args", "=", "fmt_func_args_declaration", "(", "route_args", ")", ",", "return_type", "=", "'{}'", ".", "format", "(", "return_type", ")", ")", "self", ".", "emit", "(", "'{}{};'", ".", "format", "(", "route_signature", ",", "deprecated", ")", ")", "self", ".", "emit", "(", ")" ]

[ "def", "latlng", "(", "arg", ")", ":", "if", "is_string", "(", "arg", ")", ":", "return", "arg", "normalized", "=", "normalize_lat_lng", "(", "arg", ")", "return", "\"%s,%s\"", "%", "(", "format_float", "(", "normalized", "[", "0", "]", ")", ",", "format_float", "(", "normalized", "[", "1", "]", ")", ")" ]

[ "def", "is_identifier_position", "(", "rootpath", ")", ":", "if", "len", "(", "rootpath", ")", ">=", "2", "and", "is_tuple_member_node", "(", "rootpath", "[", "-", "2", "]", ")", "and", "is_identifier", "(", "rootpath", "[", "-", "1", "]", ")", ":", "return", "True", "if", "len", "(", "rootpath", ")", ">=", "1", "and", "is_tuple_node", "(", "rootpath", "[", "-", "1", "]", ")", ":", "# No deeper node than tuple? Must be identifier position, otherwise we'd have a TupleMemberNode.", "return", "True", "return", "False" ]

[ "def", "dict_diff", "(", "dicts", ")", ":", "diff_keys", "=", "set", "(", ")", "for", "k", "in", "union", "(", "set", "(", "d", ".", "keys", "(", ")", ")", "for", "d", "in", "dicts", ")", ":", "values", "=", "[", "]", "for", "d", "in", "dicts", ":", "if", "k", "not", "in", "d", ":", "diff_keys", ".", "add", "(", "k", ")", "break", "else", ":", "values", ".", "append", "(", "d", "[", "k", "]", ")", "if", "nunique", "(", "values", ")", ">", "1", ":", "diff_keys", ".", "add", "(", "k", ")", "break", "return", "[", "dict_subset", "(", "d", ",", "diff_keys", ")", "for", "d", "in", "dicts", "]" ]

[ "def", "from_devanagari", "(", "self", ",", "data", ")", ":", "from", "indic_transliteration", "import", "sanscript", "return", "sanscript", ".", "transliterate", "(", "data", "=", "data", ",", "_from", "=", "sanscript", ".", "DEVANAGARI", ",", "_to", "=", "self", ".", "name", ")" ]

[ "def", "pw", "(", "ctx", ",", "key_pattern", ",", "user_pattern", ",", "mode", ",", "strict_flag", ",", "user_flag", ",", "file", ",", "edit_subcommand", ",", "gen_subcommand", ",", ")", ":", "# install silent Ctrl-C handler", "def", "handle_sigint", "(", "*", "_", ")", ":", "click", ".", "echo", "(", ")", "ctx", ".", "exit", "(", "1", ")", "signal", ".", "signal", "(", "signal", ".", "SIGINT", ",", "handle_sigint", ")", "# invoke a subcommand?", "if", "gen_subcommand", ":", "length", "=", "int", "(", "key_pattern", ")", "if", "key_pattern", "else", "None", "generate_password", "(", "mode", ",", "length", ")", "return", "elif", "edit_subcommand", ":", "launch_editor", "(", "ctx", ",", "file", ")", "return", "# verify that database file is present", "if", "not", "os", ".", "path", ".", "exists", "(", "file", ")", ":", "click", ".", "echo", "(", "\"error: password store not found at '%s'\"", "%", "file", ",", "err", "=", "True", ")", "ctx", ".", "exit", "(", "1", ")", "# load database", "store", "=", "Store", ".", "load", "(", "file", ")", "# if no user query provided, split key query according to right-most \"@\" sign (since usernames are typically email addresses)", "if", "not", "user_pattern", ":", "user_pattern", ",", "_", ",", "key_pattern", "=", "key_pattern", ".", "rpartition", "(", "\"@\"", ")", "# search database", "results", "=", "store", ".", "search", "(", "key_pattern", ",", "user_pattern", ")", "results", "=", "list", "(", "results", ")", "# if strict flag is enabled, check that precisely a single record was found", "if", "strict_flag", "and", "len", "(", "results", ")", "!=", "1", ":", "click", ".", "echo", "(", "\"error: multiple or no records found (but using --strict flag)\"", ",", "err", "=", "True", ")", "ctx", ".", "exit", "(", "2", ")", "# raw mode?", "if", "mode", "==", "Mode", ".", "RAW", ":", "for", "entry", "in", "results", ":", "click", ".", "echo", "(", "entry", ".", "user", "if", "user_flag", "else", "entry", ".", "password", ")", "return", "# print results", "for", "idx", ",", "entry", "in", "enumerate", "(", "results", ")", ":", "# start with key and user", "line", "=", "highlight_match", "(", "key_pattern", ",", "entry", ".", "key", ")", "if", "entry", ".", "user", ":", "line", "+=", "\": \"", "+", "highlight_match", "(", "user_pattern", ",", "entry", ".", "user", ")", "# add password or copy&paste sucess message", "if", "mode", "==", "Mode", ".", "ECHO", "and", "not", "user_flag", ":", "line", "+=", "\" | \"", "+", "style_password", "(", "entry", ".", "password", ")", "elif", "mode", "==", "Mode", ".", "COPY", "and", "idx", "==", "0", ":", "try", ":", "import", "pyperclip", "pyperclip", ".", "copy", "(", "entry", ".", "user", "if", "user_flag", "else", "entry", ".", "password", ")", "result", "=", "style_success", "(", "\"*** %s COPIED TO CLIPBOARD ***\"", "%", "(", "\"USERNAME\"", "if", "user_flag", "else", "\"PASSWORD\"", ")", ")", "except", "ImportError", ":", "result", "=", "style_error", "(", "'*** PYTHON PACKAGE \"PYPERCLIP\" NOT FOUND ***'", ")", "line", "+=", "\" | \"", "+", "result", "# add notes", "if", "entry", ".", "notes", ":", "if", "idx", "==", "0", ":", "line", "+=", "\"\\n\"", "line", "+=", "\"\\n\"", ".", "join", "(", "\" \"", "+", "line", "for", "line", "in", "entry", ".", "notes", ".", "splitlines", "(", ")", ")", "else", ":", "lines", "=", "entry", ".", "notes", ".", "splitlines", "(", ")", "line", "+=", "\" | \"", "+", "lines", "[", "0", "]", "if", "len", "(", "lines", ")", ">", "1", ":", "line", "+=", "\" (...)\"", "click", ".", "echo", "(", "line", ")" ]

[ "def", "sigma_clipped_stats", "(", "data", ",", "mask", "=", "None", ",", "mask_value", "=", "None", ",", "sigma", "=", "3.0", ",", "sigma_lower", "=", "None", ",", "sigma_upper", "=", "None", ",", "maxiters", "=", "5", ",", "cenfunc", "=", "'median'", ",", "stdfunc", "=", "'std'", ",", "std_ddof", "=", "0", ",", "axis", "=", "None", ")", ":", "if", "mask", "is", "not", "None", ":", "data", "=", "np", ".", "ma", ".", "MaskedArray", "(", "data", ",", "mask", ")", "if", "mask_value", "is", "not", "None", ":", "data", "=", "np", ".", "ma", ".", "masked_values", "(", "data", ",", "mask_value", ")", "sigclip", "=", "SigmaClip", "(", "sigma", "=", "sigma", ",", "sigma_lower", "=", "sigma_lower", ",", "sigma_upper", "=", "sigma_upper", ",", "maxiters", "=", "maxiters", ",", "cenfunc", "=", "cenfunc", ",", "stdfunc", "=", "stdfunc", ")", "data_clipped", "=", "sigclip", "(", "data", ",", "axis", "=", "axis", ",", "masked", "=", "False", ",", "return_bounds", "=", "False", ",", "copy", "=", "False", ")", "if", "HAS_BOTTLENECK", ":", "mean", "=", "_nanmean", "(", "data_clipped", ",", "axis", "=", "axis", ")", "median", "=", "_nanmedian", "(", "data_clipped", ",", "axis", "=", "axis", ")", "std", "=", "_nanstd", "(", "data_clipped", ",", "ddof", "=", "std_ddof", ",", "axis", "=", "axis", ")", "else", ":", "# pragma: no cover", "mean", "=", "np", ".", "nanmean", "(", "data_clipped", ",", "axis", "=", "axis", ")", "median", "=", "np", ".", "nanmedian", "(", "data_clipped", ",", "axis", "=", "axis", ")", "std", "=", "np", ".", "nanstd", "(", "data_clipped", ",", "ddof", "=", "std_ddof", ",", "axis", "=", "axis", ")", "return", "mean", ",", "median", ",", "std" ]

[ "def", "unbind", "(", "self", ",", "callback", ",", "event_name", "=", "None", ")", ":", "if", "event_name", "is", "None", ":", "for", "name", "in", "self", ".", "handlers", ".", "keys", "(", ")", ":", "self", ".", "unbind", "(", "callback", ",", "name", ")", "return", "if", "callback", "in", "self", ".", "handlers", "[", "event_name", "]", ":", "self", ".", "handlers", "[", "event_name", "]", ".", "remove", "(", "callback", ")" ]

[ "def", "apply_default_prefetch", "(", "input_source_or_dataflow", ",", "trainer", ")", ":", "if", "not", "isinstance", "(", "input_source_or_dataflow", ",", "InputSource", ")", ":", "# to mimic same behavior of the old trainer interface", "if", "type", "(", "trainer", ")", "==", "SimpleTrainer", ":", "input", "=", "FeedInput", "(", "input_source_or_dataflow", ")", "else", ":", "logger", ".", "info", "(", "\"Automatically applying QueueInput on the DataFlow.\"", ")", "input", "=", "QueueInput", "(", "input_source_or_dataflow", ")", "else", ":", "input", "=", "input_source_or_dataflow", "if", "hasattr", "(", "trainer", ",", "'devices'", ")", ":", "towers", "=", "trainer", ".", "devices", "if", "len", "(", "towers", ")", ">", "1", ":", "# seem to only improve on >1 GPUs", "assert", "not", "isinstance", "(", "trainer", ",", "SimpleTrainer", ")", "if", "isinstance", "(", "input", ",", "FeedfreeInput", ")", "and", "not", "isinstance", "(", "input", ",", "(", "StagingInput", ",", "DummyConstantInput", ")", ")", ":", "logger", ".", "info", "(", "\"Automatically applying StagingInput on the DataFlow.\"", ")", "input", "=", "StagingInput", "(", "input", ")", "return", "input" ]

[ "def", "_symbols", "(", ")", ":", "global", "_SYMBOLS", "if", "_SYMBOLS", "is", "None", ":", "tmp", "=", "[", "(", "s", ",", "'symbol'", ")", "for", "s", "in", "_data", "(", ")", "[", "'symbol'", "]", ".", "keys", "(", ")", "]", "tmp", "+=", "[", "(", "s", ",", "'alpha3'", ")", "for", "s", "in", "_data", "(", ")", "[", "'alpha3'", "]", ".", "keys", "(", ")", "]", "tmp", "+=", "[", "(", "s", ".", "name", ",", "'name'", ")", "for", "s", "in", "_data", "(", ")", "[", "'alpha3'", "]", ".", "values", "(", ")", "]", "_SYMBOLS", "=", "sorted", "(", "tmp", ",", "key", "=", "lambda", "s", ":", "(", "len", "(", "s", "[", "0", "]", ")", ",", "ord", "(", "s", "[", "0", "]", "[", "0", "]", ")", ")", ",", "reverse", "=", "True", ")", "return", "_SYMBOLS" ]

[ "def", "serial_udb_extra_f8_send", "(", "self", ",", "sue_HEIGHT_TARGET_MAX", ",", "sue_HEIGHT_TARGET_MIN", ",", "sue_ALT_HOLD_THROTTLE_MIN", ",", "sue_ALT_HOLD_THROTTLE_MAX", ",", "sue_ALT_HOLD_PITCH_MIN", ",", "sue_ALT_HOLD_PITCH_MAX", ",", "sue_ALT_HOLD_PITCH_HIGH", ",", "force_mavlink1", "=", "False", ")", ":", "return", "self", ".", "send", "(", "self", ".", "serial_udb_extra_f8_encode", "(", "sue_HEIGHT_TARGET_MAX", ",", "sue_HEIGHT_TARGET_MIN", ",", "sue_ALT_HOLD_THROTTLE_MIN", ",", "sue_ALT_HOLD_THROTTLE_MAX", ",", "sue_ALT_HOLD_PITCH_MIN", ",", "sue_ALT_HOLD_PITCH_MAX", ",", "sue_ALT_HOLD_PITCH_HIGH", ")", ",", "force_mavlink1", "=", "force_mavlink1", ")" ]

[ "def", "sparse_angular_random_projection_split", "(", "inds", ",", "indptr", ",", "data", ",", "indices", ",", "rng_state", ")", ":", "# Select two random points, set the hyperplane between them", "left_index", "=", "tau_rand_int", "(", "rng_state", ")", "%", "indices", ".", "shape", "[", "0", "]", "right_index", "=", "tau_rand_int", "(", "rng_state", ")", "%", "indices", ".", "shape", "[", "0", "]", "right_index", "+=", "left_index", "==", "right_index", "right_index", "=", "right_index", "%", "indices", ".", "shape", "[", "0", "]", "left", "=", "indices", "[", "left_index", "]", "right", "=", "indices", "[", "right_index", "]", "left_inds", "=", "inds", "[", "indptr", "[", "left", "]", ":", "indptr", "[", "left", "+", "1", "]", "]", "left_data", "=", "data", "[", "indptr", "[", "left", "]", ":", "indptr", "[", "left", "+", "1", "]", "]", "right_inds", "=", "inds", "[", "indptr", "[", "right", "]", ":", "indptr", "[", "right", "+", "1", "]", "]", "right_data", "=", "data", "[", "indptr", "[", "right", "]", ":", "indptr", "[", "right", "+", "1", "]", "]", "left_norm", "=", "norm", "(", "left_data", ")", "right_norm", "=", "norm", "(", "right_data", ")", "if", "abs", "(", "left_norm", ")", "<", "EPS", ":", "left_norm", "=", "1.0", "if", "abs", "(", "right_norm", ")", "<", "EPS", ":", "right_norm", "=", "1.0", "# Compute the normal vector to the hyperplane (the vector between", "# the two points)", "normalized_left_data", "=", "left_data", "/", "left_norm", "normalized_right_data", "=", "right_data", "/", "right_norm", "hyperplane_inds", ",", "hyperplane_data", "=", "sparse_diff", "(", "left_inds", ",", "normalized_left_data", ",", "right_inds", ",", "normalized_right_data", ")", "hyperplane_norm", "=", "norm", "(", "hyperplane_data", ")", "if", "abs", "(", "hyperplane_norm", ")", "<", "EPS", ":", "hyperplane_norm", "=", "1.0", "for", "d", "in", "range", "(", "hyperplane_data", ".", "shape", "[", "0", "]", ")", ":", "hyperplane_data", "[", "d", "]", "=", "hyperplane_data", "[", "d", "]", "/", "hyperplane_norm", "# For each point compute the margin (project into normal vector)", "# If we are on lower side of the hyperplane put in one pile, otherwise", "# put it in the other pile (if we hit hyperplane on the nose, flip a coin)", "n_left", "=", "0", "n_right", "=", "0", "side", "=", "np", ".", "empty", "(", "indices", ".", "shape", "[", "0", "]", ",", "np", ".", "int8", ")", "for", "i", "in", "range", "(", "indices", ".", "shape", "[", "0", "]", ")", ":", "margin", "=", "0.0", "i_inds", "=", "inds", "[", "indptr", "[", "indices", "[", "i", "]", "]", ":", "indptr", "[", "indices", "[", "i", "]", "+", "1", "]", "]", "i_data", "=", "data", "[", "indptr", "[", "indices", "[", "i", "]", "]", ":", "indptr", "[", "indices", "[", "i", "]", "+", "1", "]", "]", "mul_inds", ",", "mul_data", "=", "sparse_mul", "(", "hyperplane_inds", ",", "hyperplane_data", ",", "i_inds", ",", "i_data", ")", "for", "d", "in", "range", "(", "mul_data", ".", "shape", "[", "0", "]", ")", ":", "margin", "+=", "mul_data", "[", "d", "]", "if", "abs", "(", "margin", ")", "<", "EPS", ":", "side", "[", "i", "]", "=", "tau_rand_int", "(", "rng_state", ")", "%", "2", "if", "side", "[", "i", "]", "==", "0", ":", "n_left", "+=", "1", "else", ":", "n_right", "+=", "1", "elif", "margin", ">", "0", ":", "side", "[", "i", "]", "=", "0", "n_left", "+=", "1", "else", ":", "side", "[", "i", "]", "=", "1", "n_right", "+=", "1", "# Now that we have the counts allocate arrays", "indices_left", "=", "np", ".", "empty", "(", "n_left", ",", "dtype", "=", "np", ".", "int64", ")", "indices_right", "=", "np", ".", "empty", "(", "n_right", ",", "dtype", "=", "np", ".", "int64", ")", "# Populate the arrays with indices according to which side they fell on", "n_left", "=", "0", "n_right", "=", "0", "for", "i", "in", "range", "(", "side", ".", "shape", "[", "0", "]", ")", ":", "if", "side", "[", "i", "]", "==", "0", ":", "indices_left", "[", "n_left", "]", "=", "indices", "[", "i", "]", "n_left", "+=", "1", "else", ":", "indices_right", "[", "n_right", "]", "=", "indices", "[", "i", "]", "n_right", "+=", "1", "hyperplane", "=", "np", ".", "vstack", "(", "(", "hyperplane_inds", ",", "hyperplane_data", ")", ")", "return", "indices_left", ",", "indices_right", ",", "hyperplane", ",", "None" ]

[ "def", "localize", "(", "self", ",", "mode", "=", "\"r\"", ",", "perm", "=", "None", ",", "parent_perm", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "mode", "not", "in", "(", "\"r\"", ",", "\"w\"", ")", ":", "raise", "Exception", "(", "\"unknown mode '{}', use r or w\"", ".", "format", "(", "mode", ")", ")", "# get additional arguments", "skip_copy", "=", "kwargs", ".", "pop", "(", "\"skip_copy\"", ",", "False", ")", "is_tmp", "=", "kwargs", ".", "pop", "(", "\"is_tmp\"", ",", "mode", "==", "\"w\"", ")", "if", "mode", "==", "\"r\"", ":", "if", "is_tmp", ":", "# create a temporary target", "tmp", "=", "self", ".", "__class__", "(", "is_tmp", "=", "self", ".", "ext", "(", "n", "=", "1", ")", "or", "True", ")", "# always copy", "self", ".", "copy_to_local", "(", "tmp", ")", "# yield the copy", "try", ":", "yield", "tmp", "finally", ":", "tmp", ".", "remove", "(", ")", "else", ":", "# simply yield", "yield", "self", "else", ":", "# write mode", "if", "is_tmp", ":", "# create a temporary target", "tmp", "=", "self", ".", "__class__", "(", "is_tmp", "=", "self", ".", "ext", "(", "n", "=", "1", ")", "or", "True", ")", "# copy when existing", "if", "not", "skip_copy", "and", "self", ".", "exists", "(", ")", ":", "self", ".", "copy_to_local", "(", "tmp", ")", "# yield the copy", "try", ":", "yield", "tmp", "# move back again", "if", "tmp", ".", "exists", "(", ")", ":", "tmp", ".", "move_to_local", "(", "self", ",", "dir_perm", "=", "parent_perm", ")", "self", ".", "chmod", "(", "perm", ")", "else", ":", "logger", ".", "warning", "(", "\"cannot move non-existing localized file target {!r}\"", ".", "format", "(", "self", ")", ")", "finally", ":", "tmp", ".", "remove", "(", ")", "else", ":", "# create the parent dir", "self", ".", "parent", ".", "touch", "(", "perm", "=", "parent_perm", ")", "# simply yield", "yield", "self", "if", "self", ".", "exists", "(", ")", ":", "self", ".", "chmod", "(", "perm", ")" ]

[ "def", "_redis_notifier", "(", "state", ")", ":", "tstamp", "=", "time", ".", "time", "(", ")", "state", ".", "_tstamp", "=", "tstamp", "conf", "=", "state", ".", "app", ".", "config", "# Notify timestamp", "r", "=", "redis", ".", "client", ".", "StrictRedis", "(", ")", "r", ".", "publish", "(", "conf", ".", "get", "(", "'WAFFLE_REDIS_CHANNEL'", ",", "'waffleconf'", ")", ",", "tstamp", ")" ]

[ "def", "start", "(", "track_file", ",", "twitter_api_key", ",", "twitter_api_secret", ",", "twitter_access_token", ",", "twitter_access_token_secret", ",", "poll_interval", "=", "15", ",", "unfiltered", "=", "False", ",", "languages", "=", "None", ",", "debug", "=", "False", ",", "outfile", "=", "None", ")", ":", "listener", "=", "construct_listener", "(", "outfile", ")", "checker", "=", "BasicFileTermChecker", "(", "track_file", ",", "listener", ")", "auth", "=", "get_tweepy_auth", "(", "twitter_api_key", ",", "twitter_api_secret", ",", "twitter_access_token", ",", "twitter_access_token_secret", ")", "stream", "=", "DynamicTwitterStream", "(", "auth", ",", "listener", ",", "checker", ",", "unfiltered", "=", "unfiltered", ",", "languages", "=", "languages", ")", "set_terminate_listeners", "(", "stream", ")", "if", "debug", ":", "set_debug_listener", "(", "stream", ")", "begin_stream_loop", "(", "stream", ",", "poll_interval", ")" ]

[ "def", "hash_from_file", "(", "filename", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "filename", ")", ":", "raise", "IOError", "(", "\"Path not found\"", ")", "if", "not", "os", ".", "path", ".", "isfile", "(", "filename", ")", ":", "raise", "IOError", "(", "\"File not found\"", ")", "if", "not", "os", ".", "access", "(", "filename", ",", "os", ".", "R_OK", ")", ":", "raise", "IOError", "(", "\"File is not readable\"", ")", "result", "=", "ffi", ".", "new", "(", "\"char[]\"", ",", "binding", ".", "lib", ".", "FUZZY_MAX_RESULT", ")", "if", "binding", ".", "lib", ".", "fuzzy_hash_filename", "(", "filename", ".", "encode", "(", "\"utf-8\"", ")", ",", "result", ")", "!=", "0", ":", "raise", "InternalError", "(", "\"Function returned an unexpected error code\"", ")", "return", "ffi", ".", "string", "(", "result", ")", ".", "decode", "(", "\"ascii\"", ")" ]

[ "def", "_iana_unassigned_port_ranges", "(", ")", ":", "page", "=", "urllib2", ".", "urlopen", "(", "IANA_DOWNLOAD_URL", ")", ".", "read", "(", ")", "xml", "=", "ElementTree", ".", "fromstring", "(", "page", ")", "records", "=", "xml", ".", "findall", "(", "'{%s}record'", "%", "IANA_NS", ")", "for", "record", "in", "records", ":", "description", "=", "record", ".", "find", "(", "'{%s}description'", "%", "IANA_NS", ")", ".", "text", "if", "description", "==", "'Unassigned'", ":", "numbers", "=", "record", ".", "find", "(", "'{%s}number'", "%", "IANA_NS", ")", ".", "text", "yield", "numbers" ]

[ "def", "random_shift", "(", "image", ",", "wsr", "=", "0.1", ",", "hsr", "=", "0.1", ")", ":", "height", ",", "width", ",", "_", "=", "common_layers", ".", "shape_list", "(", "image", ")", "width_range", ",", "height_range", "=", "wsr", "*", "width", ",", "hsr", "*", "height", "height_translations", "=", "tf", ".", "random_uniform", "(", "(", "1", ",", ")", ",", "-", "height_range", ",", "height_range", ")", "width_translations", "=", "tf", ".", "random_uniform", "(", "(", "1", ",", ")", ",", "-", "width_range", ",", "width_range", ")", "translations", "=", "tf", ".", "concat", "(", "(", "height_translations", ",", "width_translations", ")", ",", "axis", "=", "0", ")", "return", "tf", ".", "contrib", ".", "image", ".", "translate", "(", "image", ",", "translations", "=", "translations", ")" ]

[ "def", "preprocess_input", "(", "features", ",", "target", ",", "train_config", ",", "preprocess_output_dir", ",", "model_type", ")", ":", "target_name", "=", "train_config", "[", "'target_column'", "]", "key_name", "=", "train_config", "[", "'key_column'", "]", "# Do the numerical transforms.", "# Numerical transforms supported for regression/classification", "# 1) num -> do nothing (identity, default)", "# 2) num -> scale to -1, 1 (scale)", "# 3) num -> scale to -a, a (scale with value parameter)", "with", "tf", ".", "name_scope", "(", "'numerical_feature_preprocess'", ")", ":", "if", "train_config", "[", "'numerical_columns'", "]", ":", "numerical_analysis_file", "=", "os", ".", "path", ".", "join", "(", "preprocess_output_dir", ",", "NUMERICAL_ANALYSIS", ")", "if", "not", "file_io", ".", "file_exists", "(", "numerical_analysis_file", ")", ":", "raise", "ValueError", "(", "'File %s not found in %s'", "%", "(", "NUMERICAL_ANALYSIS", ",", "preprocess_output_dir", ")", ")", "numerical_anlysis", "=", "json", ".", "loads", "(", "python_portable_string", "(", "file_io", ".", "read_file_to_string", "(", "numerical_analysis_file", ")", ")", ")", "for", "name", "in", "train_config", "[", "'numerical_columns'", "]", ":", "if", "name", "==", "target_name", "or", "name", "==", "key_name", ":", "continue", "transform_config", "=", "train_config", "[", "'transforms'", "]", ".", "get", "(", "name", ",", "{", "}", ")", "transform_name", "=", "transform_config", ".", "get", "(", "'transform'", ",", "None", ")", "if", "transform_name", "==", "'scale'", ":", "value", "=", "float", "(", "transform_config", ".", "get", "(", "'value'", ",", "1.0", ")", ")", "features", "[", "name", "]", "=", "_scale_tensor", "(", "features", "[", "name", "]", ",", "range_min", "=", "numerical_anlysis", "[", "name", "]", "[", "'min'", "]", ",", "range_max", "=", "numerical_anlysis", "[", "name", "]", "[", "'max'", "]", ",", "scale_min", "=", "-", "value", ",", "scale_max", "=", "value", ")", "elif", "transform_name", "==", "'identity'", "or", "transform_name", "is", "None", ":", "pass", "else", ":", "raise", "ValueError", "(", "(", "'For numerical variables, only scale '", "'and identity are supported: '", "'Error for %s'", ")", "%", "name", ")", "# Do target transform if it exists.", "if", "target", "is", "not", "None", ":", "with", "tf", ".", "name_scope", "(", "'target_feature_preprocess'", ")", ":", "if", "target_name", "in", "train_config", "[", "'categorical_columns'", "]", ":", "labels", "=", "train_config", "[", "'vocab_stats'", "]", "[", "target_name", "]", "[", "'labels'", "]", "table", "=", "tf", ".", "contrib", ".", "lookup", ".", "string_to_index_table_from_tensor", "(", "labels", ")", "target", "=", "table", ".", "lookup", "(", "target", ")", "# target = tf.contrib.lookup.string_to_index(target, labels)", "# Do categorical transforms. Only apply vocab mapping. The real", "# transforms are done with tf learn column features.", "with", "tf", ".", "name_scope", "(", "'categorical_feature_preprocess'", ")", ":", "for", "name", "in", "train_config", "[", "'categorical_columns'", "]", ":", "if", "name", "==", "key_name", "or", "name", "==", "target_name", ":", "continue", "transform_config", "=", "train_config", "[", "'transforms'", "]", ".", "get", "(", "name", ",", "{", "}", ")", "transform_name", "=", "transform_config", ".", "get", "(", "'transform'", ",", "None", ")", "if", "is_dnn_model", "(", "model_type", ")", ":", "if", "transform_name", "==", "'embedding'", "or", "transform_name", "==", "'one_hot'", "or", "transform_name", "is", "None", ":", "map_vocab", "=", "True", "else", ":", "raise", "ValueError", "(", "'Unknown transform %s'", "%", "transform_name", ")", "elif", "is_linear_model", "(", "model_type", ")", ":", "if", "(", "transform_name", "==", "'one_hot'", "or", "transform_name", "is", "None", ")", ":", "map_vocab", "=", "True", "elif", "transform_name", "==", "'embedding'", ":", "map_vocab", "=", "False", "else", ":", "raise", "ValueError", "(", "'Unknown transform %s'", "%", "transform_name", ")", "if", "map_vocab", ":", "labels", "=", "train_config", "[", "'vocab_stats'", "]", "[", "name", "]", "[", "'labels'", "]", "table", "=", "tf", ".", "contrib", ".", "lookup", ".", "string_to_index_table_from_tensor", "(", "labels", ")", "features", "[", "name", "]", "=", "table", ".", "lookup", "(", "features", "[", "name", "]", ")", "return", "features", ",", "target" ]

[ "def", "query_all", "(", "self", ")", ":", "return", "self", ".", "query_model", "(", "self", ".", "model", ",", "self", ".", "condition", ",", "order_by", "=", "self", ".", "order_by", ",", "group_by", "=", "self", ".", "group_by", ",", "having", "=", "self", ".", "having", ")" ]

[ "def", "validate_is_document_type", "(", "option", ",", "value", ")", ":", "if", "not", "isinstance", "(", "value", ",", "(", "collections", ".", "MutableMapping", ",", "RawBSONDocument", ")", ")", ":", "raise", "TypeError", "(", "\"%s must be an instance of dict, bson.son.SON, \"", "\"bson.raw_bson.RawBSONDocument, or \"", "\"a type that inherits from \"", "\"collections.MutableMapping\"", "%", "(", "option", ",", ")", ")" ]

[ "def", "set_setpoint", "(", "self", ",", "setpointvalue", ")", ":", "_checkSetpointValue", "(", "setpointvalue", ",", "self", ".", "setpoint_max", ")", "self", ".", "write_register", "(", "4097", ",", "setpointvalue", ",", "1", ")" ]

[ "def", "_infer_decorator_callchain", "(", "node", ")", ":", "if", "not", "isinstance", "(", "node", ",", "FunctionDef", ")", ":", "return", "None", "if", "not", "node", ".", "parent", ":", "return", "None", "try", ":", "result", "=", "next", "(", "node", ".", "infer_call_result", "(", "node", ".", "parent", ")", ")", "except", "exceptions", ".", "InferenceError", ":", "return", "None", "if", "isinstance", "(", "result", ",", "bases", ".", "Instance", ")", ":", "result", "=", "result", ".", "_proxied", "if", "isinstance", "(", "result", ",", "ClassDef", ")", ":", "if", "result", ".", "is_subtype_of", "(", "\"%s.classmethod\"", "%", "BUILTINS", ")", ":", "return", "\"classmethod\"", "if", "result", ".", "is_subtype_of", "(", "\"%s.staticmethod\"", "%", "BUILTINS", ")", ":", "return", "\"staticmethod\"", "return", "None" ]

[ "def", "parse_extension_item_param", "(", "header", ":", "str", ",", "pos", ":", "int", ",", "header_name", ":", "str", ")", "->", "Tuple", "[", "ExtensionParameter", ",", "int", "]", ":", "# Extract parameter name.", "name", ",", "pos", "=", "parse_token", "(", "header", ",", "pos", ",", "header_name", ")", "pos", "=", "parse_OWS", "(", "header", ",", "pos", ")", "# Extract parameter value, if there is one.", "value", ":", "Optional", "[", "str", "]", "=", "None", "if", "peek_ahead", "(", "header", ",", "pos", ")", "==", "\"=\"", ":", "pos", "=", "parse_OWS", "(", "header", ",", "pos", "+", "1", ")", "if", "peek_ahead", "(", "header", ",", "pos", ")", "==", "'\"'", ":", "pos_before", "=", "pos", "# for proper error reporting below", "value", ",", "pos", "=", "parse_quoted_string", "(", "header", ",", "pos", ",", "header_name", ")", "# https://tools.ietf.org/html/rfc6455#section-9.1 says: the value", "# after quoted-string unescaping MUST conform to the 'token' ABNF.", "if", "_token_re", ".", "fullmatch", "(", "value", ")", "is", "None", ":", "raise", "InvalidHeaderFormat", "(", "header_name", ",", "\"invalid quoted header content\"", ",", "header", ",", "pos_before", ")", "else", ":", "value", ",", "pos", "=", "parse_token", "(", "header", ",", "pos", ",", "header_name", ")", "pos", "=", "parse_OWS", "(", "header", ",", "pos", ")", "return", "(", "name", ",", "value", ")", ",", "pos" ]

[ "def", "pipe", "(", "self", ",", "f", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "isinstance", "(", "f", ",", "tuple", ")", ":", "f", ",", "data_keyword", "=", "f", "kwargs", "=", "kwargs", ".", "copy", "(", ")", "kwargs", "[", "data_keyword", "]", "=", "self", "return", "f", "(", "*", "args", ",", "*", "*", "kwargs", ")", "else", ":", "return", "f", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "def", "get_sphinx_autodoc", "(", "self", ",", "depth", "=", "None", ",", "exclude", "=", "None", ",", "width", "=", "72", ",", "error", "=", "False", ",", "raised", "=", "False", ",", "no_comment", "=", "False", ",", ")", ":", "# This code is cog-specific: cog code file name is the module", "# file name, a plus (+), and then the line number where the", "# cog function is", "frame", "=", "sys", ".", "_getframe", "(", "1", ")", "index", "=", "frame", ".", "f_code", ".", "co_filename", ".", "rfind", "(", "\"+\"", ")", "fname", "=", "os", ".", "path", ".", "abspath", "(", "frame", ".", "f_code", ".", "co_filename", "[", ":", "index", "]", ")", "# Find name of callable based on module name and line number", "# within that module, then get the exceptions by using the", "# get_sphinx_doc() method with this information", "line_num", "=", "int", "(", "frame", ".", "f_code", ".", "co_filename", "[", "index", "+", "1", ":", "]", ")", "module_db", "=", "self", ".", "_module_obj_db", "[", "fname", "]", "names", "=", "[", "callable_dict", "[", "\"name\"", "]", "for", "callable_dict", "in", "module_db", "]", "line_nums", "=", "[", "callable_dict", "[", "\"line\"", "]", "for", "callable_dict", "in", "module_db", "]", "name", "=", "names", "[", "bisect", ".", "bisect", "(", "line_nums", ",", "line_num", ")", "-", "1", "]", "return", "self", ".", "get_sphinx_doc", "(", "name", "=", "name", ",", "depth", "=", "depth", ",", "exclude", "=", "exclude", ",", "width", "=", "width", ",", "error", "=", "error", ",", "raised", "=", "raised", ",", "no_comment", "=", "no_comment", ",", ")" ]

[ "def", "UpdateUserCredentials", "(", "client_id", ",", "client_secret", ",", "refresh_token", ",", "adwords_manager_cid", ",", "developer_token", ")", ":", "app_user", "=", "AppUser", ".", "query", "(", "AppUser", ".", "user", "==", "users", ".", "get_current_user", "(", ")", ")", ".", "fetch", "(", ")", "[", "0", "]", "app_user", ".", "client_id", "=", "client_id", "app_user", ".", "client_secret", "=", "client_secret", "app_user", ".", "refresh_token", "=", "refresh_token", "app_user", ".", "adwords_manager_cid", "=", "adwords_manager_cid", "app_user", ".", "developer_token", "=", "developer_token", "app_user", ".", "put", "(", ")" ]

[ "def", "relate_obs_ids_to_chosen_alts", "(", "obs_id_array", ",", "alt_id_array", ",", "choice_array", ")", ":", "# Figure out which units of observation chose each alternative.", "chosen_alts_to_obs_ids", "=", "{", "}", "for", "alt_id", "in", "np", ".", "sort", "(", "np", ".", "unique", "(", "alt_id_array", ")", ")", ":", "# Determine which observations chose the current alternative.", "selection_condition", "=", "np", ".", "where", "(", "(", "alt_id_array", "==", "alt_id", ")", "&", "(", "choice_array", "==", "1", ")", ")", "# Store the sorted, unique ids that chose the current alternative.", "chosen_alts_to_obs_ids", "[", "alt_id", "]", "=", "np", ".", "sort", "(", "np", ".", "unique", "(", "obs_id_array", "[", "selection_condition", "]", ")", ")", "# Return the desired dictionary.", "return", "chosen_alts_to_obs_ids" ]

[ "def", "extract_mfd_params", "(", "src", ")", ":", "tags", "=", "get_taglist", "(", "src", ")", "if", "\"incrementalMFD\"", "in", "tags", ":", "mfd_node", "=", "src", ".", "nodes", "[", "tags", ".", "index", "(", "\"incrementalMFD\"", ")", "]", "elif", "\"truncGutenbergRichterMFD\"", "in", "tags", ":", "mfd_node", "=", "src", ".", "nodes", "[", "tags", ".", "index", "(", "\"truncGutenbergRichterMFD\"", ")", "]", "elif", "\"arbitraryMFD\"", "in", "tags", ":", "mfd_node", "=", "src", ".", "nodes", "[", "tags", ".", "index", "(", "\"arbitraryMFD\"", ")", "]", "elif", "\"YoungsCoppersmithMFD\"", "in", "tags", ":", "mfd_node", "=", "src", ".", "nodes", "[", "tags", ".", "index", "(", "\"YoungsCoppersmithMFD\"", ")", "]", "else", ":", "raise", "ValueError", "(", "\"Source %s contains no supported MFD type!\"", "%", "src", ".", "tag", ")", "data", "=", "[", "]", "rates", "=", "[", "]", "for", "key", ",", "param", ",", "vtype", "in", "MFD_PARAMS", ":", "if", "key", "in", "mfd_node", ".", "attrib", "and", "mfd_node", ".", "attrib", "[", "key", "]", "is", "not", "None", ":", "data", ".", "append", "(", "(", "param", ",", "mfd_node", ".", "attrib", "[", "key", "]", ")", ")", "else", ":", "data", ".", "append", "(", "(", "param", ",", "None", ")", ")", "if", "(", "\"incrementalMFD\"", "or", "\"arbitraryMFD\"", ")", "in", "mfd_node", ".", "tag", ":", "# Extract Rates", "rates", "=", "~", "mfd_node", ".", "occurRates", "n_r", "=", "len", "(", "rates", ")", "if", "n_r", ">", "MAX_RATES", ":", "raise", "ValueError", "(", "\"Number of rates in source %s too large \"", "\"to be placed into shapefile\"", "%", "src", ".", "tag", ")", "rate_dict", "=", "dict", "(", "[", "(", "key", ",", "rates", "[", "i", "]", "if", "i", "<", "n_r", "else", "None", ")", "for", "i", ",", "(", "key", ",", "_", ")", "in", "enumerate", "(", "RATE_PARAMS", ")", "]", ")", "elif", "\"YoungsCoppersmithMFD\"", "in", "mfd_node", ".", "tag", ":", "rate_dict", "=", "dict", "(", "[", "(", "key", ",", "mfd_node", ".", "attrib", "[", "'characteristicRate'", "]", ")", "for", "i", ",", "(", "key", ",", "_", ")", "in", "enumerate", "(", "RATE_PARAMS", ")", "]", ")", "else", ":", "rate_dict", "=", "dict", "(", "[", "(", "key", ",", "None", ")", "for", "i", ",", "(", "key", ",", "_", ")", "in", "enumerate", "(", "RATE_PARAMS", ")", "]", ")", "return", "dict", "(", "data", ")", ",", "rate_dict" ]

[ "def", "infer", "(", "args", ":", "argparse", ".", "Namespace", ")", "->", "None", ":", "try", ":", "last_tag", "=", "last_git_release_tag", "(", "git_tags", "(", ")", ")", "except", "NoGitTagsException", ":", "print", "(", "SemVer", "(", "0", ",", "1", ",", "0", ")", ")", "exit", "(", "0", ")", "commit_log", "=", "git_commits_since_last_tag", "(", "last_tag", ")", "action", "=", "parse_commit_log", "(", "commit_log", ")", "last_ver", "=", "git_tag_to_semver", "(", "last_tag", ")", "if", "action", "==", "'min'", ":", "new_ver", "=", "last_ver", ".", "bump_minor", "(", ")", "elif", "action", "==", "'maj'", ":", "new_ver", "=", "last_ver", ".", "bump_major", "(", ")", "else", ":", "new_ver", "=", "last_ver", ".", "bump_patch", "(", ")", "print", "(", "new_ver", ")" ]

[ "def", "delete", "(", "gandi", ",", "webacc", ",", "vhost", ",", "backend", ",", "port", ")", ":", "result", "=", "[", "]", "if", "webacc", ":", "result", "=", "gandi", ".", "webacc", ".", "delete", "(", "webacc", ")", "if", "backend", ":", "backends", "=", "backend", "for", "backend", "in", "backends", ":", "if", "'port'", "not", "in", "backend", ":", "if", "not", "port", ":", "backend", "[", "'port'", "]", "=", "click", ".", "prompt", "(", "'Please set a port for '", "'backends. If you want to '", "' different port for '", "'each backend, use `-b '", "'ip:port`'", ",", "type", "=", "int", ")", "else", ":", "backend", "[", "'port'", "]", "=", "port", "result", "=", "gandi", ".", "webacc", ".", "backend_remove", "(", "backend", ")", "if", "vhost", ":", "vhosts", "=", "vhost", "for", "vhost", "in", "vhosts", ":", "result", "=", "gandi", ".", "webacc", ".", "vhost_remove", "(", "vhost", ")", "return", "result" ]

[ "def", "threshold_gradients", "(", "self", ",", "grad_thresh", ")", ":", "data", "=", "np", ".", "copy", "(", "self", ".", "_data", ")", "gx", ",", "gy", "=", "self", ".", "gradients", "(", ")", "gradients", "=", "np", ".", "zeros", "(", "[", "gx", ".", "shape", "[", "0", "]", ",", "gx", ".", "shape", "[", "1", "]", ",", "2", "]", ")", "gradients", "[", ":", ",", ":", ",", "0", "]", "=", "gx", "gradients", "[", ":", ",", ":", ",", "1", "]", "=", "gy", "gradient_mags", "=", "np", ".", "linalg", ".", "norm", "(", "gradients", ",", "axis", "=", "2", ")", "ind", "=", "np", ".", "where", "(", "gradient_mags", ">", "grad_thresh", ")", "data", "[", "ind", "[", "0", "]", ",", "ind", "[", "1", "]", "]", "=", "0.0", "return", "DepthImage", "(", "data", ",", "self", ".", "_frame", ")" ]

[ "def", "boards", "(", "self", ",", "startAt", "=", "0", ",", "maxResults", "=", "50", ",", "type", "=", "None", ",", "name", "=", "None", ",", "projectKeyOrID", "=", "None", ")", ":", "params", "=", "{", "}", "if", "type", ":", "params", "[", "'type'", "]", "=", "type", "if", "name", ":", "params", "[", "'name'", "]", "=", "name", "if", "projectKeyOrID", ":", "params", "[", "'projectKeyOrId'", "]", "=", "projectKeyOrID", "if", "self", ".", "_options", "[", "'agile_rest_path'", "]", "==", "GreenHopperResource", ".", "GREENHOPPER_REST_PATH", ":", "# Old, private API did not support pagination, all records were present in response,", "# and no parameters were supported.", "if", "startAt", "or", "maxResults", "or", "params", ":", "warnings", ".", "warn", "(", "'Old private GreenHopper API is used, all parameters will be ignored.'", ",", "Warning", ")", "r_json", "=", "self", ".", "_get_json", "(", "'rapidviews/list'", ",", "base", "=", "self", ".", "AGILE_BASE_URL", ")", "boards", "=", "[", "Board", "(", "self", ".", "_options", ",", "self", ".", "_session", ",", "raw_boards_json", ")", "for", "raw_boards_json", "in", "r_json", "[", "'views'", "]", "]", "return", "ResultList", "(", "boards", ",", "0", ",", "len", "(", "boards", ")", ",", "len", "(", "boards", ")", ",", "True", ")", "else", ":", "return", "self", ".", "_fetch_pages", "(", "Board", ",", "'values'", ",", "'board'", ",", "startAt", ",", "maxResults", ",", "params", ",", "base", "=", "self", ".", "AGILE_BASE_URL", ")" ]

[ "def", "onepara", "(", "R", ")", ":", "import", "numpy", "as", "np", "import", "warnings", "d", "=", "R", ".", "shape", "[", "0", "]", "if", "d", "<", "2", ":", "raise", "Exception", "(", "(", "\"More than one variable is required.\"", "\"Supply at least a 2x2 matrix.\"", ")", ")", "# the explicit solution", "x", "=", "(", "np", ".", "sum", "(", "R", ")", "+", "np", ".", "trace", "(", "R", ")", ")", "/", "(", "d", "**", "2", "-", "d", ")", "if", "x", "<", "(", "-", "1.", "/", "(", "d", "-", "1", ")", ")", "or", "x", ">", "1", ":", "warnings", ".", "warn", "(", "\"No analytic solution found x={:.8f}\"", ".", "format", "(", "x", ")", ")", "return", "None", "else", ":", "C", "=", "np", ".", "eye", "(", "d", ")", "C", "[", "np", ".", "logical_not", "(", "C", ")", "]", "=", "x", "return", "C" ]

[ "def", "_update_views_binary", "(", "self", ",", "result", ",", "other", ",", "binop", ")", ":", "update_str_template", "=", "'{e2}{binop}e'", "v", "=", "result", ".", "_weldarray_view", "if", "isinstance", "(", "other", ",", "weldarray", ")", ":", "lookup_ind", "=", "'i-{st}'", ".", "format", "(", "st", "=", "v", ".", "start", ")", "# update the base array to include the context from other", "v", ".", "base_array", ".", "weldobj", ".", "update", "(", "other", ".", "weldobj", ")", "e2", "=", "'lookup({arr2},{i}L)'", ".", "format", "(", "arr2", "=", "other", ".", "weldobj", ".", "weld_code", ",", "i", "=", "lookup_ind", ")", "else", ":", "# other is just a scalar.", "e2", "=", "str", "(", "other", ")", "+", "DTYPE_SUFFIXES", "[", "result", ".", "_weld_type", ".", "__str__", "(", ")", "]", "update_str", "=", "update_str_template", ".", "format", "(", "e2", "=", "e2", ",", "binop", "=", "binop", ")", "v", ".", "base_array", ".", "_update_range", "(", "v", ".", "start", ",", "v", ".", "end", ",", "update_str", ")" ]

[ "def", "get_suffixes", "(", ")", ":", "names", "=", "[", "]", "if", "at_least_libvips", "(", "8", ",", "8", ")", ":", "array", "=", "vips_lib", ".", "vips_foreign_get_suffixes", "(", ")", "i", "=", "0", "while", "array", "[", "i", "]", "!=", "ffi", ".", "NULL", ":", "name", "=", "_to_string", "(", "array", "[", "i", "]", ")", "if", "name", "not", "in", "names", ":", "names", ".", "append", "(", "name", ")", "glib_lib", ".", "g_free", "(", "array", "[", "i", "]", ")", "i", "+=", "1", "glib_lib", ".", "g_free", "(", "array", ")", "return", "names" ]

[ "def", "cookieDomainForRequest", "(", "self", ",", "request", ")", ":", "host", "=", "request", ".", "getHeader", "(", "'host'", ")", "if", "host", "is", "None", ":", "# This is a malformed request that we cannot possibly handle", "# safely, fall back to the default behaviour.", "return", "None", "host", "=", "host", ".", "split", "(", "':'", ")", "[", "0", "]", "for", "domain", "in", "self", ".", "_domains", ":", "suffix", "=", "\".\"", "+", "domain", "if", "host", "==", "domain", ":", "# The request is for a domain which is directly recognized.", "if", "self", ".", "_enableSubdomains", ":", "# Subdomains are enabled, so the suffix is returned to", "# enable the cookie for this domain and all its subdomains.", "return", "suffix", "# Subdomains are not enabled, so None is returned to allow the", "# default restriction, which will enable this cookie only for", "# the domain in the request, to apply.", "return", "None", "if", "self", ".", "_enableSubdomains", "and", "host", ".", "endswith", "(", "suffix", ")", ":", "# The request is for a subdomain of a directly recognized", "# domain and subdomains are enabled. Drop the unrecognized", "# subdomain portion and return the suffix to enable the cookie", "# for this domain and all its subdomains.", "return", "suffix", "if", "self", ".", "_enableSubdomains", ":", "# No directly recognized domain matched the request. If subdomains", "# are enabled, prefix the request domain with \".\" to make the", "# cookie valid for that domain and all its subdomains. This", "# probably isn't extremely useful. Perhaps it shouldn't work this", "# way.", "return", "\".\"", "+", "host", "# Subdomains are disabled and the domain from the request was not", "# recognized. Return None to get the default behavior.", "return", "None" ]

[ "def", "_write_callback", "(", "connection_id", ",", "data_buffer", ",", "data_length_pointer", ")", ":", "try", ":", "self", "=", "_connection_refs", ".", "get", "(", "connection_id", ")", "if", "not", "self", ":", "socket", "=", "_socket_refs", ".", "get", "(", "connection_id", ")", "else", ":", "socket", "=", "self", ".", "_socket", "if", "not", "self", "and", "not", "socket", ":", "return", "0", "data_length", "=", "deref", "(", "data_length_pointer", ")", "data", "=", "bytes_from_buffer", "(", "data_buffer", ",", "data_length", ")", "if", "self", "and", "not", "self", ".", "_done_handshake", ":", "self", ".", "_client_hello", "+=", "data", "error", "=", "None", "try", ":", "sent", "=", "socket", ".", "send", "(", "data", ")", "except", "(", "socket_", ".", "error", ")", "as", "e", ":", "error", "=", "e", ".", "errno", "if", "error", "is", "not", "None", "and", "error", "!=", "errno", ".", "EAGAIN", ":", "if", "error", "==", "errno", ".", "ECONNRESET", "or", "error", "==", "errno", ".", "EPIPE", ":", "return", "SecurityConst", ".", "errSSLClosedNoNotify", "return", "SecurityConst", ".", "errSSLClosedAbort", "if", "sent", "!=", "data_length", ":", "pointer_set", "(", "data_length_pointer", ",", "sent", ")", "return", "SecurityConst", ".", "errSSLWouldBlock", "return", "0", "except", "(", "KeyboardInterrupt", ")", "as", "e", ":", "self", ".", "_exception", "=", "e", "return", "SecurityConst", ".", "errSSLPeerUserCancelled" ]

[ "def", "plot_multitrack", "(", "multitrack", ",", "filename", "=", "None", ",", "mode", "=", "'separate'", ",", "track_label", "=", "'name'", ",", "preset", "=", "'default'", ",", "cmaps", "=", "None", ",", "xtick", "=", "'auto'", ",", "ytick", "=", "'octave'", ",", "xticklabel", "=", "True", ",", "yticklabel", "=", "'auto'", ",", "tick_loc", "=", "None", ",", "tick_direction", "=", "'in'", ",", "label", "=", "'both'", ",", "grid", "=", "'both'", ",", "grid_linestyle", "=", "':'", ",", "grid_linewidth", "=", ".5", ")", ":", "if", "not", "HAS_MATPLOTLIB", ":", "raise", "ImportError", "(", "\"matplotlib package is required for plotting \"", "\"supports.\"", ")", "def", "get_track_label", "(", "track_label", ",", "track", "=", "None", ")", ":", "\"\"\"Convenient function to get track labels\"\"\"", "if", "track_label", "==", "'name'", ":", "return", "track", ".", "name", "elif", "track_label", "==", "'program'", ":", "return", "pretty_midi", ".", "program_to_instrument_name", "(", "track", ".", "program", ")", "elif", "track_label", "==", "'family'", ":", "return", "pretty_midi", ".", "program_to_instrument_class", "(", "track", ".", "program", ")", "elif", "track", "is", "None", ":", "return", "track_label", "def", "add_tracklabel", "(", "ax", ",", "track_label", ",", "track", "=", "None", ")", ":", "\"\"\"Convenient function for adding track labels\"\"\"", "if", "not", "ax", ".", "get_ylabel", "(", ")", ":", "return", "ax", ".", "set_ylabel", "(", "get_track_label", "(", "track_label", ",", "track", ")", "+", "'\\n\\n'", "+", "ax", ".", "get_ylabel", "(", ")", ")", "multitrack", ".", "check_validity", "(", ")", "if", "not", "multitrack", ".", "tracks", ":", "raise", "ValueError", "(", "\"There is no track to plot.\"", ")", "if", "mode", "not", "in", "(", "'separate'", ",", "'stacked'", ",", "'hybrid'", ")", ":", "raise", "ValueError", "(", "\"`mode` must be one of {'separate', 'stacked', \"", "\"'hybrid'}.\"", ")", "if", "track_label", "not", "in", "(", "'name'", ",", "'program'", ",", "'family'", ",", "'off'", ")", ":", "raise", "ValueError", "(", "\"`track_label` must be one of {'name', 'program', \"", "\"'family'}.\"", ")", "if", "cmaps", "is", "None", ":", "if", "mode", "==", "'separate'", ":", "cmaps", "=", "(", "'Blues'", ",", "'Oranges'", ",", "'Greens'", ",", "'Reds'", ",", "'Purples'", ",", "'Greys'", ")", "elif", "mode", "==", "'stacked'", ":", "cmaps", "=", "(", "'hsv'", ")", "else", ":", "cmaps", "=", "(", "'Blues'", ",", "'Greens'", ")", "num_track", "=", "len", "(", "multitrack", ".", "tracks", ")", "downbeats", "=", "multitrack", ".", "get_downbeat_steps", "(", ")", "if", "mode", "==", "'separate'", ":", "if", "num_track", ">", "1", ":", "fig", ",", "axs", "=", "plt", ".", "subplots", "(", "num_track", ",", "sharex", "=", "True", ")", "else", ":", "fig", ",", "ax", "=", "plt", ".", "subplots", "(", ")", "axs", "=", "[", "ax", "]", "for", "idx", ",", "track", "in", "enumerate", "(", "multitrack", ".", "tracks", ")", ":", "now_xticklabel", "=", "xticklabel", "if", "idx", "<", "num_track", "else", "False", "plot_pianoroll", "(", "axs", "[", "idx", "]", ",", "track", ".", "pianoroll", ",", "False", ",", "multitrack", ".", "beat_resolution", ",", "downbeats", ",", "preset", "=", "preset", ",", "cmap", "=", "cmaps", "[", "idx", "%", "len", "(", "cmaps", ")", "]", ",", "xtick", "=", "xtick", ",", "ytick", "=", "ytick", ",", "xticklabel", "=", "now_xticklabel", ",", "yticklabel", "=", "yticklabel", ",", "tick_loc", "=", "tick_loc", ",", "tick_direction", "=", "tick_direction", ",", "label", "=", "label", ",", "grid", "=", "grid", ",", "grid_linestyle", "=", "grid_linestyle", ",", "grid_linewidth", "=", "grid_linewidth", ")", "if", "track_label", "!=", "'none'", ":", "add_tracklabel", "(", "axs", "[", "idx", "]", ",", "track_label", ",", "track", ")", "if", "num_track", ">", "1", ":", "fig", ".", "subplots_adjust", "(", "hspace", "=", "0", ")", "if", "filename", "is", "not", "None", ":", "plt", ".", "savefig", "(", "filename", ")", "return", "(", "fig", ",", "axs", ")", "elif", "mode", "==", "'stacked'", ":", "is_all_drum", "=", "True", "for", "track", "in", "multitrack", ".", "tracks", ":", "if", "not", "track", ".", "is_drum", ":", "is_all_drum", "=", "False", "fig", ",", "ax", "=", "plt", ".", "subplots", "(", ")", "stacked", "=", "multitrack", ".", "get_stacked_pianorolls", "(", ")", "colormap", "=", "matplotlib", ".", "cm", ".", "get_cmap", "(", "cmaps", "[", "0", "]", ")", "cmatrix", "=", "colormap", "(", "np", ".", "arange", "(", "0", ",", "1", ",", "1", "/", "num_track", ")", ")", "[", ":", ",", ":", "3", "]", "recolored", "=", "np", ".", "matmul", "(", "stacked", ".", "reshape", "(", "-", "1", ",", "num_track", ")", ",", "cmatrix", ")", "stacked", "=", "recolored", ".", "reshape", "(", "stacked", ".", "shape", "[", ":", "2", "]", "+", "(", "3", ",", ")", ")", "plot_pianoroll", "(", "ax", ",", "stacked", ",", "is_all_drum", ",", "multitrack", ".", "beat_resolution", ",", "downbeats", ",", "preset", "=", "preset", ",", "xtick", "=", "xtick", ",", "ytick", "=", "ytick", ",", "xticklabel", "=", "xticklabel", ",", "yticklabel", "=", "yticklabel", ",", "tick_loc", "=", "tick_loc", ",", "tick_direction", "=", "tick_direction", ",", "label", "=", "label", ",", "grid", "=", "grid", ",", "grid_linestyle", "=", "grid_linestyle", ",", "grid_linewidth", "=", "grid_linewidth", ")", "if", "track_label", "!=", "'none'", ":", "patches", "=", "[", "Patch", "(", "color", "=", "cmatrix", "[", "idx", "]", ",", "label", "=", "get_track_label", "(", "track_label", ",", "track", ")", ")", "for", "idx", ",", "track", "in", "enumerate", "(", "multitrack", ".", "tracks", ")", "]", "plt", ".", "legend", "(", "handles", "=", "patches", ")", "if", "filename", "is", "not", "None", ":", "plt", ".", "savefig", "(", "filename", ")", "return", "(", "fig", ",", "[", "ax", "]", ")", "elif", "mode", "==", "'hybrid'", ":", "drums", "=", "[", "i", "for", "i", ",", "track", "in", "enumerate", "(", "multitrack", ".", "tracks", ")", "if", "track", ".", "is_drum", "]", "others", "=", "[", "i", "for", "i", "in", "range", "(", "len", "(", "multitrack", ".", "tracks", ")", ")", "if", "i", "not", "in", "drums", "]", "merged_drums", "=", "multitrack", ".", "get_merged_pianoroll", "(", "drums", ")", "merged_others", "=", "multitrack", ".", "get_merged_pianoroll", "(", "others", ")", "fig", ",", "(", "ax1", ",", "ax2", ")", "=", "plt", ".", "subplots", "(", "2", ",", "sharex", "=", "True", ",", "sharey", "=", "True", ")", "plot_pianoroll", "(", "ax1", ",", "merged_drums", ",", "True", ",", "multitrack", ".", "beat_resolution", ",", "downbeats", ",", "preset", "=", "preset", ",", "cmap", "=", "cmaps", "[", "0", "]", ",", "xtick", "=", "xtick", ",", "ytick", "=", "ytick", ",", "xticklabel", "=", "xticklabel", ",", "yticklabel", "=", "yticklabel", ",", "tick_loc", "=", "tick_loc", ",", "tick_direction", "=", "tick_direction", ",", "label", "=", "label", ",", "grid", "=", "grid", ",", "grid_linestyle", "=", "grid_linestyle", ",", "grid_linewidth", "=", "grid_linewidth", ")", "plot_pianoroll", "(", "ax2", ",", "merged_others", ",", "False", ",", "multitrack", ".", "beat_resolution", ",", "downbeats", ",", "preset", "=", "preset", ",", "cmap", "=", "cmaps", "[", "1", "]", ",", "ytick", "=", "ytick", ",", "xticklabel", "=", "xticklabel", ",", "yticklabel", "=", "yticklabel", ",", "tick_loc", "=", "tick_loc", ",", "tick_direction", "=", "tick_direction", ",", "label", "=", "label", ",", "grid", "=", "grid", ",", "grid_linestyle", "=", "grid_linestyle", ",", "grid_linewidth", "=", "grid_linewidth", ")", "fig", ".", "subplots_adjust", "(", "hspace", "=", "0", ")", "if", "track_label", "!=", "'none'", ":", "add_tracklabel", "(", "ax1", ",", "'Drums'", ")", "add_tracklabel", "(", "ax2", ",", "'Others'", ")", "if", "filename", "is", "not", "None", ":", "plt", ".", "savefig", "(", "filename", ")", "return", "(", "fig", ",", "[", "ax1", ",", "ax2", "]", ")" ]

[ "def", "set_bool_param", "(", "params", ",", "name", ",", "value", ")", ":", "if", "value", "is", "None", ":", "return", "if", "value", "is", "True", ":", "params", "[", "name", "]", "=", "'true'", "elif", "value", "is", "False", ":", "params", "[", "name", "]", "=", "'false'", "else", ":", "raise", "ValueError", "(", "\"Parameter '%s' must be boolean or None, got %r.\"", "%", "(", "name", ",", "value", ")", ")" ]

[ "def", "find_event", "(", "name", ")", ":", "try", ":", "module", ",", "klass", "=", "parse_event_name", "(", "name", ")", "return", "getattr", "(", "import_module", "(", "module", ")", ",", "klass", ")", "except", "(", "ImportError", ",", "AttributeError", ")", ":", "raise", "EventNotFoundError", "(", "(", "'Event \"{}\" not found. '", "'Make sure you have a class called \"{}\" inside the \"{}\" '", "'module.'", ".", "format", "(", "name", ",", "klass", ",", "module", ")", ")", ")" ]

[ "def", "buff", "(", "self", ",", "target", ",", "buff", ",", "*", "*", "kwargs", ")", ":", "ret", "=", "self", ".", "controller", ".", "card", "(", "buff", ",", "self", ")", "ret", ".", "source", "=", "self", "ret", ".", "apply", "(", "target", ")", "for", "k", ",", "v", "in", "kwargs", ".", "items", "(", ")", ":", "setattr", "(", "ret", ",", "k", ",", "v", ")", "return", "ret" ]

[ "def", "_get_marX", "(", "self", ",", "attr_name", ",", "default", ")", ":", "if", "self", ".", "tcPr", "is", "None", ":", "return", "Emu", "(", "default", ")", "return", "Emu", "(", "int", "(", "self", ".", "tcPr", ".", "get", "(", "attr_name", ",", "default", ")", ")", ")" ]

[ "def", "create_index", "(", "self", ",", "*", "fields", ")", ":", "reset", "=", "False", "for", "f", "in", "fields", ":", "if", "not", "f", "in", "self", ".", "fields", ":", "raise", "NameError", ",", "\"%s is not a field name %s\"", "%", "(", "f", ",", "self", ".", "fields", ")", "# initialize the indices\r", "if", "self", ".", "mode", "==", "\"open\"", "and", "f", "in", "self", ".", "indices", ":", "continue", "reset", "=", "True", "self", ".", "indices", "[", "f", "]", "=", "{", "}", "for", "_id", ",", "record", "in", "self", ".", "records", ".", "iteritems", "(", ")", ":", "# use bisect to quickly insert the id in the list\r", "bisect", ".", "insort", "(", "self", ".", "indices", "[", "f", "]", ".", "setdefault", "(", "record", "[", "f", "]", ",", "[", "]", ")", ",", "_id", ")", "# create a new attribute of self, used to find the records\r", "# by this index\r", "setattr", "(", "self", ",", "'_'", "+", "f", ",", "Index", "(", "self", ",", "f", ")", ")", "if", "reset", ":", "self", ".", "commit", "(", ")" ]

[ "def", "infer", "(", "query", ",", "replacements", "=", "None", ",", "root_type", "=", "None", ",", "libs", "=", "(", "\"stdcore\"", ",", "\"stdmath\"", ")", ")", ":", "# Always make the scope stack start with stdcore.", "if", "root_type", ":", "type_scope", "=", "scope", ".", "ScopeStack", "(", "std_core", ".", "MODULE", ",", "root_type", ")", "else", ":", "type_scope", "=", "scope", ".", "ScopeStack", "(", "std_core", ".", "MODULE", ")", "stdcore_included", "=", "False", "for", "lib", "in", "libs", ":", "if", "lib", "==", "\"stdcore\"", ":", "stdcore_included", "=", "True", "continue", "module", "=", "std_core", ".", "LibraryModule", ".", "ALL_MODULES", ".", "get", "(", "lib", ")", "if", "not", "module", ":", "raise", "TypeError", "(", "\"No standard library module %r.\"", "%", "lib", ")", "type_scope", "=", "scope", ".", "ScopeStack", "(", "module", ",", "type_scope", ")", "if", "not", "stdcore_included", ":", "raise", "TypeError", "(", "\"'stdcore' must always be included.\"", ")", "query", "=", "q", ".", "Query", "(", "query", ",", "params", "=", "replacements", ")", "return", "infer_type", ".", "infer_type", "(", "query", ",", "type_scope", ")" ]

[ "def", "next_frame_sv2p", "(", ")", ":", "hparams", "=", "basic_stochastic", ".", "next_frame_basic_stochastic", "(", ")", "hparams", ".", "optimizer", "=", "\"true_adam\"", "hparams", ".", "learning_rate_schedule", "=", "\"constant\"", "hparams", ".", "learning_rate_constant", "=", "1e-3", "hparams", ".", "video_num_input_frames", "=", "1", "hparams", ".", "video_num_target_frames", "=", "3", "hparams", ".", "batch_size", "=", "16", "hparams", ".", "bottom", "=", "{", "\"inputs\"", ":", "modalities", ".", "video_raw_bottom", ",", "\"targets\"", ":", "modalities", ".", "video_raw_targets_bottom", ",", "}", "hparams", ".", "loss", "=", "{", "\"targets\"", ":", "modalities", ".", "video_l2_raw_loss", ",", "}", "hparams", ".", "top", "=", "{", "\"targets\"", ":", "modalities", ".", "video_raw_top", ",", "}", "hparams", ".", "video_modality_loss_cutoff", "=", "0.0", "hparams", ".", "scheduled_sampling_mode", "=", "\"count\"", "hparams", ".", "scheduled_sampling_k", "=", "900.0", "hparams", ".", "add_hparam", "(", "\"reward_prediction\"", ",", "True", ")", "hparams", ".", "add_hparam", "(", "\"reward_prediction_stop_gradient\"", ",", "False", ")", "hparams", ".", "add_hparam", "(", "\"reward_prediction_buffer_size\"", ",", "0", ")", "hparams", ".", "add_hparam", "(", "\"model_options\"", ",", "\"CDNA\"", ")", "hparams", ".", "add_hparam", "(", "\"num_masks\"", ",", "10", ")", "hparams", ".", "add_hparam", "(", "\"multi_latent\"", ",", "False", ")", "hparams", ".", "add_hparam", "(", "\"relu_shift\"", ",", "1e-12", ")", "hparams", ".", "add_hparam", "(", "\"dna_kernel_size\"", ",", "5", ")", "hparams", ".", "add_hparam", "(", "\"upsample_method\"", ",", "\"conv2d_transpose\"", ")", "hparams", ".", "add_hparam", "(", "\"reward_model\"", ",", "\"basic\"", ")", "hparams", ".", "add_hparam", "(", "\"visualize_logits_histogram\"", ",", "True", ")", "return", "hparams" ]

[ "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", ")" ]

[ "def", "_update_cov_model", "(", "self", ",", "strata_to_update", "=", "'all'", ")", ":", "if", "strata_to_update", "==", "'all'", ":", "strata_to_update", "=", "self", ".", "strata", ".", "indices_", "#: Otherwise assume strata_to_update is valid (no duplicates etc.)", "#: Update covariance matrices", "#: We usually update only one stratum at a time, so for loop is ok", "n_sampled", "=", "np", ".", "clip", "(", "self", ".", "strata", ".", "_n_sampled", ",", "2", ",", "np", ".", "inf", ")", "#: adding 2 avoids undef. cov", "factor", "=", "n_sampled", "/", "(", "n_sampled", "-", "1", ")", "for", "k", "in", "strata_to_update", ":", "TP", "=", "self", ".", "_BB_TP", ".", "theta_", "[", "k", "]", "PP", "=", "self", ".", "_BB_PP", ".", "theta_", "[", "k", "]", "P", "=", "self", ".", "_BB_P", ".", "theta_", "[", "k", "]", "self", ".", "cov_model_", "[", "k", ",", "0", ",", "0", "]", "=", "factor", "[", "k", "]", "*", "TP", "*", "(", "1", "-", "TP", ")", "self", ".", "cov_model_", "[", "k", ",", "0", ",", "1", "]", "=", "factor", "[", "k", "]", "*", "TP", "*", "(", "1", "-", "PP", ")", "self", ".", "cov_model_", "[", "k", ",", "0", ",", "2", "]", "=", "factor", "[", "k", "]", "*", "TP", "*", "(", "1", "-", "P", ")", "self", ".", "cov_model_", "[", "k", ",", "1", ",", "1", "]", "=", "factor", "[", "k", "]", "*", "PP", "*", "(", "1", "-", "PP", ")", "self", ".", "cov_model_", "[", "k", ",", "1", ",", "2", "]", "=", "factor", "[", "k", "]", "*", "(", "TP", "-", "PP", "*", "P", ")", "self", ".", "cov_model_", "[", "k", ",", "2", ",", "2", "]", "=", "factor", "[", "k", "]", "*", "P", "*", "(", "1", "-", "P", ")", "self", ".", "cov_model_", "[", "k", ",", "1", ",", "0", "]", "=", "self", ".", "cov_model_", "[", "k", ",", "0", ",", "1", "]", "self", ".", "cov_model_", "[", "k", ",", "2", ",", "0", "]", "=", "self", ".", "cov_model_", "[", "k", ",", "0", ",", "2", "]", "self", ".", "cov_model_", "[", "k", ",", "2", ",", "1", "]", "=", "self", ".", "cov_model_", "[", "k", ",", "1", ",", "2", "]" ]

[ "def", "run", "(", "self", ",", "lines", ")", ":", "ret", "=", "[", "]", "for", "line", "in", "lines", ":", "ret", ".", "append", "(", "re", ".", "sub", "(", "r'^#'", ",", "'#'", "+", "(", "'#'", "*", "self", ".", "offset", ")", ",", "line", ")", ")", "return", "ret" ]

[ "def", "copy", "(", "self", ",", "items", "=", "None", ")", ":", "return", "NGram", "(", "items", "if", "items", "is", "not", "None", "else", "self", ",", "self", ".", "threshold", ",", "self", ".", "warp", ",", "self", ".", "_key", ",", "self", ".", "N", ",", "self", ".", "_pad_len", ",", "self", ".", "_pad_char", ")" ]

[ "def", "push", "(", "self", ":", "BoardT", ",", "move", ":", "Move", ")", "->", "None", ":", "# Push move and remember board state.", "move", "=", "self", ".", "_to_chess960", "(", "move", ")", "self", ".", "move_stack", ".", "append", "(", "self", ".", "_from_chess960", "(", "self", ".", "chess960", ",", "move", ".", "from_square", ",", "move", ".", "to_square", ",", "move", ".", "promotion", ",", "move", ".", "drop", ")", ")", "self", ".", "_stack", ".", "append", "(", "self", ".", "_board_state", "(", ")", ")", "# Reset en passant square.", "ep_square", "=", "self", ".", "ep_square", "self", ".", "ep_square", "=", "None", "# Increment move counters.", "self", ".", "halfmove_clock", "+=", "1", "if", "self", ".", "turn", "==", "BLACK", ":", "self", ".", "fullmove_number", "+=", "1", "# On a null move, simply swap turns and reset the en passant square.", "if", "not", "move", ":", "self", ".", "turn", "=", "not", "self", ".", "turn", "return", "# Drops.", "if", "move", ".", "drop", ":", "self", ".", "_set_piece_at", "(", "move", ".", "to_square", ",", "move", ".", "drop", ",", "self", ".", "turn", ")", "self", ".", "turn", "=", "not", "self", ".", "turn", "return", "# Zero the half-move clock.", "if", "self", ".", "is_zeroing", "(", "move", ")", ":", "self", ".", "halfmove_clock", "=", "0", "from_bb", "=", "BB_SQUARES", "[", "move", ".", "from_square", "]", "to_bb", "=", "BB_SQUARES", "[", "move", ".", "to_square", "]", "promoted", "=", "bool", "(", "self", ".", "promoted", "&", "from_bb", ")", "piece_type", "=", "self", ".", "_remove_piece_at", "(", "move", ".", "from_square", ")", "assert", "piece_type", "is", "not", "None", ",", "\"push() expects move to be pseudo-legal, but got {} in {}\"", ".", "format", "(", "move", ",", "self", ".", "fen", "(", ")", ")", "capture_square", "=", "move", ".", "to_square", "captured_piece_type", "=", "self", ".", "piece_type_at", "(", "capture_square", ")", "# Update castling rights.", "self", ".", "castling_rights", "=", "self", ".", "clean_castling_rights", "(", ")", "&", "~", "to_bb", "&", "~", "from_bb", "if", "piece_type", "==", "KING", "and", "not", "promoted", ":", "if", "self", ".", "turn", "==", "WHITE", ":", "self", ".", "castling_rights", "&=", "~", "BB_RANK_1", "else", ":", "self", ".", "castling_rights", "&=", "~", "BB_RANK_8", "elif", "captured_piece_type", "==", "KING", "and", "not", "self", ".", "promoted", "&", "to_bb", ":", "if", "self", ".", "turn", "==", "WHITE", "and", "square_rank", "(", "move", ".", "to_square", ")", "==", "7", ":", "self", ".", "castling_rights", "&=", "~", "BB_RANK_8", "elif", "self", ".", "turn", "==", "BLACK", "and", "square_rank", "(", "move", ".", "to_square", ")", "==", "0", ":", "self", ".", "castling_rights", "&=", "~", "BB_RANK_1", "# Handle special pawn moves.", "if", "piece_type", "==", "PAWN", ":", "diff", "=", "move", ".", "to_square", "-", "move", ".", "from_square", "if", "diff", "==", "16", "and", "square_rank", "(", "move", ".", "from_square", ")", "==", "1", ":", "self", ".", "ep_square", "=", "move", ".", "from_square", "+", "8", "elif", "diff", "==", "-", "16", "and", "square_rank", "(", "move", ".", "from_square", ")", "==", "6", ":", "self", ".", "ep_square", "=", "move", ".", "from_square", "-", "8", "elif", "move", ".", "to_square", "==", "ep_square", "and", "abs", "(", "diff", ")", "in", "[", "7", ",", "9", "]", "and", "not", "captured_piece_type", ":", "# Remove pawns captured en passant.", "down", "=", "-", "8", "if", "self", ".", "turn", "==", "WHITE", "else", "8", "capture_square", "=", "ep_square", "+", "down", "captured_piece_type", "=", "self", ".", "_remove_piece_at", "(", "capture_square", ")", "# Promotion.", "if", "move", ".", "promotion", ":", "promoted", "=", "True", "piece_type", "=", "move", ".", "promotion", "# Castling.", "castling", "=", "piece_type", "==", "KING", "and", "self", ".", "occupied_co", "[", "self", ".", "turn", "]", "&", "to_bb", "if", "castling", ":", "a_side", "=", "square_file", "(", "move", ".", "to_square", ")", "<", "square_file", "(", "move", ".", "from_square", ")", "self", ".", "_remove_piece_at", "(", "move", ".", "from_square", ")", "self", ".", "_remove_piece_at", "(", "move", ".", "to_square", ")", "if", "a_side", ":", "self", ".", "_set_piece_at", "(", "C1", "if", "self", ".", "turn", "==", "WHITE", "else", "C8", ",", "KING", ",", "self", ".", "turn", ")", "self", ".", "_set_piece_at", "(", "D1", "if", "self", ".", "turn", "==", "WHITE", "else", "D8", ",", "ROOK", ",", "self", ".", "turn", ")", "else", ":", "self", ".", "_set_piece_at", "(", "G1", "if", "self", ".", "turn", "==", "WHITE", "else", "G8", ",", "KING", ",", "self", ".", "turn", ")", "self", ".", "_set_piece_at", "(", "F1", "if", "self", ".", "turn", "==", "WHITE", "else", "F8", ",", "ROOK", ",", "self", ".", "turn", ")", "# Put the piece on the target square.", "if", "not", "castling", ":", "was_promoted", "=", "bool", "(", "self", ".", "promoted", "&", "to_bb", ")", "self", ".", "_set_piece_at", "(", "move", ".", "to_square", ",", "piece_type", ",", "self", ".", "turn", ",", "promoted", ")", "if", "captured_piece_type", ":", "self", ".", "_push_capture", "(", "move", ",", "capture_square", ",", "captured_piece_type", ",", "was_promoted", ")", "# Swap turn.", "self", ".", "turn", "=", "not", "self", ".", "turn" ]

[ "def", "parse_JSON", "(", "self", ",", "JSON_string", ")", ":", "if", "JSON_string", "is", "None", ":", "raise", "parse_response_error", ".", "ParseResponseError", "(", "'JSON data is None'", ")", "d", "=", "json", ".", "loads", "(", "JSON_string", ")", "try", ":", "# -- reference time (strip away Z and T on ISO8601 format)", "t", "=", "d", "[", "'time'", "]", ".", "replace", "(", "'Z'", ",", "'+00'", ")", ".", "replace", "(", "'T'", ",", "' '", ")", "reference_time", "=", "timeformatutils", ".", "_ISO8601_to_UNIXtime", "(", "t", ")", "# -- reception time (now)", "reception_time", "=", "timeutils", ".", "now", "(", "'unix'", ")", "# -- location", "lon", "=", "float", "(", "d", "[", "'location'", "]", "[", "'longitude'", "]", ")", "lat", "=", "float", "(", "d", "[", "'location'", "]", "[", "'latitude'", "]", ")", "place", "=", "location", ".", "Location", "(", "None", ",", "lon", ",", "lat", ",", "None", ")", "# -- CO samples", "no2_samples", "=", "[", "dict", "(", "label", "=", "key", ",", "precision", "=", "d", "[", "'data'", "]", "[", "key", "]", "[", "'precision'", "]", ",", "value", "=", "d", "[", "'data'", "]", "[", "key", "]", "[", "'value'", "]", ")", "for", "key", "in", "d", "[", "'data'", "]", "]", "except", "KeyError", ":", "raise", "parse_response_error", ".", "ParseResponseError", "(", "''", ".", "join", "(", "[", "__name__", ",", "': impossible to parse NO2Index'", "]", ")", ")", "return", "no2index", ".", "NO2Index", "(", "reference_time", ",", "place", ",", "None", ",", "no2_samples", ",", "reception_time", ")" ]

[ "def", "write_report", "(", "storage_dic", ",", "output_file", ",", "sample_id", ")", ":", "with", "open", "(", "output_file", ",", "\"w\"", ")", "as", "fh", ",", "open", "(", "\".report.json\"", ",", "\"w\"", ")", "as", "json_rep", ":", "# Write header", "fh", ".", "write", "(", "\"Sample,Total length,Total trimmed,%,5end Trim,3end Trim,\"", "\"bad_reads\\\\n\"", ")", "# Write contents", "for", "sample", ",", "vals", "in", "storage_dic", ".", "items", "(", ")", ":", "fh", ".", "write", "(", "\"{},{}\\\\n\"", ".", "format", "(", "sample", ",", "\",\"", ".", "join", "(", "[", "str", "(", "x", ")", "for", "x", "in", "vals", ".", "values", "(", ")", "]", ")", ")", ")", "json_dic", "=", "{", "\"tableRow\"", ":", "[", "{", "\"sample\"", ":", "sample_id", ",", "\"data\"", ":", "[", "{", "\"header\"", ":", "\"trimmed\"", ",", "\"value\"", ":", "vals", "[", "\"total_trim_perc\"", "]", ",", "\"table\"", ":", "\"qc\"", ",", "\"columnBar\"", ":", "True", "}", ",", "]", "}", "]", ",", "\"plotData\"", ":", "[", "{", "\"sample\"", ":", "sample_id", ",", "\"data\"", ":", "{", "\"sparkline\"", ":", "vals", "[", "\"clean_len\"", "]", "}", "}", "]", ",", "\"badReads\"", ":", "vals", "[", "\"bad_reads\"", "]", "}", "json_rep", ".", "write", "(", "json", ".", "dumps", "(", "json_dic", ",", "separators", "=", "(", "\",\"", ",", "\":\"", ")", ")", ")" ]

[ "def", "init_app", "(", "self", ",", "app", ",", "storage", "=", "None", ",", "cache", "=", "None", ",", "file_upload", "=", "None", ")", ":", "self", ".", "app", "=", "app", "self", ".", "config", "=", "self", ".", "app", ".", "config", "self", ".", "storage", "=", "storage", "or", "self", ".", "storage", "self", ".", "file_upload", "=", "file_upload", "or", "self", ".", "file_upload", "self", ".", "cache", "=", "cache", "or", "self", ".", "cache", "self", ".", "_register_plugins", "(", "self", ".", "app", ",", "self", ".", "config", ")", "from", ".", "views", "import", "create_blueprint", "blog_app", "=", "create_blueprint", "(", "__name__", ",", "self", ")", "# external urls", "blueprint_created", ".", "send", "(", "self", ".", "app", ",", "engine", "=", "self", ",", "blueprint", "=", "blog_app", ")", "self", ".", "app", ".", "register_blueprint", "(", "blog_app", ",", "url_prefix", "=", "self", ".", "config", ".", "get", "(", "\"BLOGGING_URL_PREFIX\"", ")", ")", "self", ".", "app", ".", "extensions", "[", "\"FLASK_BLOGGING_ENGINE\"", "]", "=", "self", "# duplicate", "self", ".", "app", ".", "extensions", "[", "\"blogging\"", "]", "=", "self", "self", ".", "principal", "=", "Principal", "(", "self", ".", "app", ")", "engine_initialised", ".", "send", "(", "self", ".", "app", ",", "engine", "=", "self", ")", "if", "self", ".", "config", ".", "get", "(", "\"BLOGGING_ALLOW_FILEUPLOAD\"", ",", "True", ")", ":", "self", ".", "ffu", "=", "self", ".", "file_upload", "or", "FlaskFileUpload", "(", "app", ")" ]

[ "def", "conjugate", "(", "self", ")", ":", "return", "Operator", "(", "np", ".", "conj", "(", "self", ".", "data", ")", ",", "self", ".", "input_dims", "(", ")", ",", "self", ".", "output_dims", "(", ")", ")" ]

[ "def", "get", "(", "self", ")", ":", "sort", "=", "self", ".", "get_argument", "(", "'sort'", ",", "'cum_time'", ")", "count", "=", "self", ".", "get_argument", "(", "'count'", ",", "20", ")", "strip_dirs", "=", "self", ".", "get_argument", "(", "'strip_dirs'", ",", "True", ")", "error", "=", "''", "sorts", "=", "(", "'num_calls'", ",", "'cum_time'", ",", "'total_time'", ",", "'cum_time_per_call'", ",", "'total_time_per_call'", ")", "if", "sort", "not", "in", "sorts", ":", "error", "+=", "\"Invalid `sort` '%s', must be in %s.\"", "%", "(", "sort", ",", "sorts", ")", "try", ":", "count", "=", "int", "(", "count", ")", "except", "(", "ValueError", ",", "TypeError", ")", ":", "error", "+=", "\"Can't cast `count` '%s' to int.\"", "%", "count", "if", "count", "<=", "0", ":", "count", "=", "None", "strip_dirs", "=", "str", "(", "strip_dirs", ")", ".", "lower", "(", ")", "not", "in", "(", "'false'", ",", "'no'", ",", "'none'", ",", "'null'", ",", "'0'", ",", "''", ")", "if", "error", ":", "self", ".", "write", "(", "{", "'error'", ":", "error", "}", ")", "self", ".", "set_status", "(", "400", ")", "self", ".", "finish", "(", ")", "return", "try", ":", "statistics", "=", "get_profiler_statistics", "(", "sort", ",", "count", ",", "strip_dirs", ")", "self", ".", "write", "(", "{", "'statistics'", ":", "statistics", "}", ")", "self", ".", "set_status", "(", "200", ")", "except", "TypeError", ":", "logger", ".", "exception", "(", "'Error while retrieving profiler statistics'", ")", "self", ".", "write", "(", "{", "'error'", ":", "'No stats available. Start and stop the profiler before trying to retrieve stats.'", "}", ")", "self", ".", "set_status", "(", "404", ")", "self", ".", "finish", "(", ")" ]

[ "def", "match", "(", "license", ")", ":", "if", "license", "not", "in", "VALID_LICENSES", ":", "for", "l1", "in", "_split_license", "(", "license", ")", ":", "if", "l1", "in", "VALID_LICENSES", ":", "continue", "for", "l2", "in", "_split_license", "(", "l1", ")", ":", "if", "l2", "not", "in", "VALID_LICENSES", ":", "return", "False", "valid_license", "=", "False", "return", "True" ]

[ "def", "ShowMessage", "(", "self", ",", "title", ",", "message", ",", "filename", "=", "None", ",", "data", "=", "None", ",", "data_base64", "=", "None", ",", "messageicon", "=", "None", ",", "time", "=", "10000", ")", ":", "qicon", "=", "None", "if", "filename", "is", "not", "None", ":", "qicon", "=", "QIcon", "(", "filename", ")", "elif", "data", "is", "not", "None", ":", "ba", "=", "QtCore", ".", "QByteArray", ".", "fromRawData", "(", "data", ")", "pixmap", "=", "QtGui", ".", "QPixmap", "(", ")", "pixmap", ".", "loadFromData", "(", "ba", ")", "qicon", "=", "QIcon", "(", "pixmap", ")", "elif", "data_base64", "is", "not", "None", ":", "ba", "=", "QtCore", ".", "QByteArray", ".", "fromBase64", "(", "data_base64", ")", "pixmap", "=", "QtGui", ".", "QPixmap", "(", ")", "pixmap", ".", "loadFromData", "(", "ba", ")", "qicon", "=", "QIcon", "(", "pixmap", ")", "if", "qicon", "is", "not", "None", ":", "self", ".", "TrayIcon", ".", "showMessage", "(", "title", ",", "message", ",", "qicon", ",", "time", ")", "elif", "messageicon", "is", "not", "None", ":", "self", ".", "TrayIcon", ".", "showMessage", "(", "title", ",", "message", ",", "messageicon", ",", "time", ")", "else", ":", "self", ".", "TrayIcon", ".", "showMessage", "(", "title", ",", "message", ",", "QIcon", "(", ")", ",", "time", ")", "self", ".", "LastMessage", "=", "message", "self", ".", "LastTitle", "=", "title", "return", "self" ]

[ "def", "get_parameter", "(", "self", ",", "parameter", ")", ":", "parameter", "=", "self", ".", "_get_parameter_name", "(", "parameter", ")", "return", "self", ".", "_parameters", "[", "parameter", "]" ]

[ "def", "issue", "(", "self", ",", "issue_instance_id", ")", ":", "with", "self", ".", "db", ".", "make_session", "(", ")", "as", "session", ":", "selected_issue", "=", "(", "session", ".", "query", "(", "IssueInstance", ")", ".", "filter", "(", "IssueInstance", ".", "id", "==", "issue_instance_id", ")", ".", "scalar", "(", ")", ")", "if", "selected_issue", "is", "None", ":", "self", ".", "warning", "(", "f\"Issue {issue_instance_id} doesn't exist. \"", "\"Type 'issues' for available issues.\"", ")", "return", "self", ".", "sources", "=", "self", ".", "_get_leaves_issue_instance", "(", "session", ",", "issue_instance_id", ",", "SharedTextKind", ".", "SOURCE", ")", "self", ".", "sinks", "=", "self", ".", "_get_leaves_issue_instance", "(", "session", ",", "issue_instance_id", ",", "SharedTextKind", ".", "SINK", ")", "self", ".", "current_issue_instance_id", "=", "int", "(", "selected_issue", ".", "id", ")", "self", ".", "current_frame_id", "=", "-", "1", "self", ".", "current_trace_frame_index", "=", "1", "# first one after the source", "print", "(", "f\"Set issue to {issue_instance_id}.\"", ")", "if", "int", "(", "selected_issue", ".", "run_id", ")", "!=", "self", ".", "current_run_id", ":", "self", ".", "current_run_id", "=", "int", "(", "selected_issue", ".", "run_id", ")", "print", "(", "f\"Set run to {self.current_run_id}.\"", ")", "print", "(", ")", "self", ".", "_generate_trace_from_issue", "(", ")", "self", ".", "show", "(", ")" ]

[ "def", "get_all", "(", "self", ",", "cat", ")", ":", "return", "self", ".", "_get_from_local_cache", "(", "cat", ")", "or", "self", ".", "_get_from_cache", "(", "cat", ")", "or", "self", ".", "_get_from_db", "(", "cat", ")" ]

[ "def", "read_interactions", "(", "path", ",", "comments", "=", "\"#\"", ",", "directed", "=", "False", ",", "delimiter", "=", "None", ",", "nodetype", "=", "None", ",", "timestamptype", "=", "None", ",", "encoding", "=", "'utf-8'", ",", "keys", "=", "False", ")", ":", "ids", "=", "None", "lines", "=", "(", "line", ".", "decode", "(", "encoding", ")", "for", "line", "in", "path", ")", "if", "keys", ":", "ids", "=", "read_ids", "(", "path", ".", "name", ",", "delimiter", "=", "delimiter", ",", "timestamptype", "=", "timestamptype", ")", "return", "parse_interactions", "(", "lines", ",", "comments", "=", "comments", ",", "directed", "=", "directed", ",", "delimiter", "=", "delimiter", ",", "nodetype", "=", "nodetype", ",", "timestamptype", "=", "timestamptype", ",", "keys", "=", "ids", ")" ]

[ "def", "create_framework", "(", "bundles", ",", "properties", "=", "None", ",", "auto_start", "=", "False", ",", "wait_for_stop", "=", "False", ",", "auto_delete", "=", "False", ",", ")", ":", "# type: (Union[list, tuple], dict, bool, bool, bool) -> Framework", "# Test if a framework already exists", "if", "FrameworkFactory", ".", "is_framework_running", "(", "None", ")", ":", "raise", "ValueError", "(", "\"A framework is already running\"", ")", "# Create the framework", "framework", "=", "FrameworkFactory", ".", "get_framework", "(", "properties", ")", "# Install bundles", "context", "=", "framework", ".", "get_bundle_context", "(", ")", "for", "bundle", "in", "bundles", ":", "context", ".", "install_bundle", "(", "bundle", ")", "if", "auto_start", ":", "# Automatically start the framework", "framework", ".", "start", "(", ")", "if", "wait_for_stop", ":", "# Wait for the framework to stop", "try", ":", "framework", ".", "wait_for_stop", "(", "None", ")", "except", "KeyboardInterrupt", ":", "# Stop keyboard interruptions", "if", "framework", ".", "get_state", "(", ")", "==", "Bundle", ".", "ACTIVE", ":", "framework", ".", "stop", "(", ")", "if", "auto_delete", ":", "# Delete the framework", "FrameworkFactory", ".", "delete_framework", "(", "framework", ")", "framework", "=", "None", "return", "framework" ]

[ "def", "_find_detections", "(", "cum_net_resp", ",", "nodes", ",", "threshold", ",", "thresh_type", ",", "samp_rate", ",", "realstations", ",", "length", ")", ":", "cum_net_resp", "=", "np", ".", "nan_to_num", "(", "cum_net_resp", ")", "# Force no NaNs", "if", "np", ".", "isnan", "(", "cum_net_resp", ")", ".", "any", "(", ")", ":", "raise", "ValueError", "(", "\"Nans present\"", ")", "print", "(", "'Mean of data is: '", "+", "str", "(", "np", ".", "median", "(", "cum_net_resp", ")", ")", ")", "print", "(", "'RMS of data is: '", "+", "str", "(", "np", ".", "sqrt", "(", "np", ".", "mean", "(", "np", ".", "square", "(", "cum_net_resp", ")", ")", ")", ")", ")", "print", "(", "'MAD of data is: '", "+", "str", "(", "np", ".", "median", "(", "np", ".", "abs", "(", "cum_net_resp", ")", ")", ")", ")", "if", "thresh_type", "==", "'MAD'", ":", "thresh", "=", "(", "np", ".", "median", "(", "np", ".", "abs", "(", "cum_net_resp", ")", ")", "*", "threshold", ")", "elif", "thresh_type", "==", "'abs'", ":", "thresh", "=", "threshold", "elif", "thresh_type", "==", "'RMS'", ":", "thresh", "=", "_rms", "(", "cum_net_resp", ")", "*", "threshold", "print", "(", "'Threshold is set to: '", "+", "str", "(", "thresh", ")", ")", "print", "(", "'Max of data is: '", "+", "str", "(", "max", "(", "cum_net_resp", ")", ")", ")", "peaks", "=", "findpeaks", ".", "find_peaks2_short", "(", "cum_net_resp", ",", "thresh", ",", "length", "*", "samp_rate", ",", "debug", "=", "0", ")", "detections", "=", "[", "]", "if", "peaks", ":", "for", "peak", "in", "peaks", ":", "node", "=", "nodes", "[", "peak", "[", "1", "]", "]", "detections", ".", "append", "(", "Detection", "(", "template_name", "=", "str", "(", "node", "[", "0", "]", ")", "+", "'_'", "+", "str", "(", "node", "[", "1", "]", ")", "+", "'_'", "+", "str", "(", "node", "[", "2", "]", ")", ",", "detect_time", "=", "peak", "[", "1", "]", "/", "samp_rate", ",", "no_chans", "=", "len", "(", "realstations", ")", ",", "detect_val", "=", "peak", "[", "0", "]", ",", "threshold", "=", "thresh", ",", "typeofdet", "=", "'brightness'", ",", "chans", "=", "realstations", ",", "id", "=", "str", "(", "node", "[", "0", "]", ")", "+", "'_'", "+", "str", "(", "node", "[", "1", "]", ")", "+", "'_'", "+", "str", "(", "node", "[", "2", "]", ")", "+", "str", "(", "peak", "[", "1", "]", "/", "samp_rate", ")", ",", "threshold_type", "=", "thresh_type", ",", "threshold_input", "=", "threshold", ")", ")", "else", ":", "detections", "=", "[", "]", "print", "(", "'I have found '", "+", "str", "(", "len", "(", "peaks", ")", ")", "+", "' possible detections'", ")", "return", "detections" ]

[ "def", "send_keys", "(", "self", ",", "keys", ")", ":", "try", ":", "sock", "=", "socket", ".", "socket", "(", "socket", ".", "AF_INET", ",", "socket", ".", "SOCK_STREAM", ")", "sock", ".", "settimeout", "(", "self", ".", "_timeout", ")", "sock", ".", "connect", "(", "(", "self", ".", "_ip", ",", "self", ".", "_port", "[", "'cmd'", "]", ")", ")", "# mandatory dance", "version_info", "=", "sock", ".", "recv", "(", "15", ")", "sock", ".", "send", "(", "version_info", ")", "sock", ".", "recv", "(", "2", ")", "sock", ".", "send", "(", "bytes", ".", "fromhex", "(", "'01'", ")", ")", "sock", ".", "recv", "(", "4", ")", "sock", ".", "recv", "(", "24", ")", "# send our command now!", "for", "key", "in", "keys", ":", "if", "key", "in", "self", ".", "_keys", ":", "sock", ".", "send", "(", "bytes", ".", "fromhex", "(", "\"04 01 00 00 00 00 \"", "+", "self", ".", "_keys", "[", "key", "]", ")", ")", "sock", ".", "send", "(", "bytes", ".", "fromhex", "(", "\"04 00 00 00 00 00 \"", "+", "self", ".", "_keys", "[", "key", "]", ")", ")", "sock", ".", "close", "(", ")", "except", "socket", ".", "error", ":", "raise" ]

[ "def", "_ta_plot", "(", "self", ",", "study", ",", "periods", "=", "14", ",", "column", "=", "None", ",", "include", "=", "True", ",", "str", "=", "'{name}({period})'", ",", "detail", "=", "False", ",", "theme", "=", "None", ",", "sharing", "=", "None", ",", "filename", "=", "''", ",", "asFigure", "=", "False", ",", "*", "*", "iplot_kwargs", ")", ":", "if", "'columns'", "in", "iplot_kwargs", ":", "column", "=", "iplot_kwargs", ".", "pop", "(", "'columns'", ")", "if", "'period'", "in", "iplot_kwargs", ":", "periods", "=", "iplot_kwargs", ".", "pop", "(", "'period'", ")", "if", "'world_readable'", "in", "iplot_kwargs", ":", "sharing", "=", "iplot_kwargs", ".", "pop", "(", "'world_readable'", ")", "if", "'study_color'", "in", "iplot_kwargs", ":", "iplot_kwargs", "[", "'study_colors'", "]", "=", "iplot_kwargs", ".", "pop", "(", "'study_color'", ")", "if", "sharing", "is", "None", ":", "sharing", "=", "auth", ".", "get_config_file", "(", ")", "[", "'sharing'", "]", "if", "isinstance", "(", "sharing", ",", "bool", ")", ":", "if", "sharing", ":", "sharing", "=", "'public'", "else", ":", "sharing", "=", "'private'", "iplot_kwargs", "[", "'sharing'", "]", "=", "sharing", "if", "theme", "is", "None", ":", "theme", "=", "iplot_kwargs", ".", "pop", "(", "'study_theme'", ",", "auth", ".", "get_config_file", "(", ")", "[", "'theme'", "]", ")", "if", "not", "filename", ":", "if", "'title'", "in", "iplot_kwargs", ":", "filename", "=", "iplot_kwargs", "[", "'title'", "]", "else", ":", "filename", "=", "'Plotly Playground {0}'", ".", "format", "(", "time", ".", "strftime", "(", "\"%Y-%m-%d %H:%M:%S\"", ")", ")", "def", "get_subplots", "(", "figures", ")", ":", "shape", "=", "(", "len", "(", "figures", ")", ",", "1", ")", "layout", "=", "tools", ".", "get_base_layout", "(", "figures", ")", "subplots", "=", "tools", ".", "subplots", "(", "figures", ",", "shape", "=", "shape", ",", "shared_xaxes", "=", "True", ",", "base_layout", "=", "layout", ")", "if", "len", "(", "figures", ")", "==", "2", ":", "subplots", "[", "'layout'", "]", "[", "'yaxis'", "]", "[", "'domain'", "]", "=", "[", ".27", ",", "1.0", "]", "subplots", "[", "'layout'", "]", "[", "'yaxis2'", "]", "[", "'domain'", "]", "=", "[", "0", ",", ".25", "]", "return", "subplots", "def", "get_study", "(", "df", ",", "func", ",", "iplot_kwargs", ",", "iplot_study_kwargs", ",", "str", "=", "None", ",", "include", "=", "False", ",", "column", "=", "None", ",", "inset", "=", "False", ")", ":", "df", "=", "df", ".", "copy", "(", ")", "if", "inset", ":", "if", "not", "column", ":", "if", "isinstance", "(", "df", ",", "pd", ".", "DataFrame", ")", ":", "column", "=", "df", ".", "keys", "(", ")", ".", "tolist", "(", ")", "else", ":", "df", "=", "pd", ".", "DataFrame", "(", "df", ")", "column", "=", "df", ".", "keys", "(", ")", ".", "tolist", "(", ")", "if", "'legend'", "in", "iplot_kwargs", ":", "iplot_study_kwargs", "[", "'legend'", "]", "=", "iplot_kwargs", "[", "'legend'", "]", "fig_0", "=", "df", ".", "figure", "(", "*", "*", "iplot_kwargs", ")", "df_ta", "=", "func", "(", "df", ",", "column", "=", "column", ",", "include", "=", "False", ",", "str", "=", "str", ",", "*", "*", "study_kwargs", ")", "kind", "=", "iplot_kwargs", "[", "'kind'", "]", "if", "'kind'", "in", "iplot_kwargs", "else", "''", "iplot_study_kwargs", "[", "'kind'", "]", "=", "'scatter'", "iplot_study_kwargs", "[", "'colors'", "]", "=", "iplot_study_kwargs", ".", "get", "(", "'colors'", ",", "[", "'blue'", ",", "'green'", ",", "'red'", "]", "if", "study", "==", "'dmi'", "else", "'blue'", ")", "fig_1", "=", "df_ta", ".", "figure", "(", "theme", "=", "theme", ",", "*", "*", "iplot_study_kwargs", ")", "if", "kind", "in", "[", "'candle'", ",", "'ohlc'", "]", ":", "for", "i", "in", "fig_1", "[", "'data'", "]", ":", "i", "[", "'x'", "]", "=", "[", "pd", ".", "Timestamp", "(", "_", ")", "for", "_", "in", "i", "[", "'x'", "]", "]", "if", "inset", ":", "figure", "=", "tools", ".", "merge_figures", "(", "[", "fig_0", ",", "fig_1", "]", ")", "if", "include", "else", "fig_1", "else", ":", "figure", "=", "get_subplots", "(", "[", "fig_0", ",", "fig_1", "]", ")", "if", "include", "else", "fig_1", "return", "figure", "study_kwargs", "=", "{", "}", "iplot_study_kwargs", "=", "{", "}", "study_kwargs", "=", "check_kwargs", "(", "iplot_kwargs", ",", "__TA_KWARGS", ",", "{", "}", ",", "clean_origin", "=", "True", ")", "iplot_study_kwargs", "=", "kwargs_from_keyword", "(", "iplot_kwargs", ",", "{", "}", ",", "'study'", ")", "study_kwargs", ".", "update", "(", "{", "'periods'", ":", "periods", "}", ")", "ta_func", "=", "eval", "(", "'ta.{0}'", ".", "format", "(", "study", ")", ")", "inset", "=", "study", "in", "(", "'sma'", ",", "'boll'", ",", "'ema'", ",", "'atr'", ",", "'ptps'", ")", "figure", "=", "get_study", "(", "self", ",", "ta_func", ",", "iplot_kwargs", ",", "iplot_study_kwargs", ",", "include", "=", "include", ",", "column", "=", "column", ",", "str", "=", "str", ",", "inset", "=", "inset", ")", "## Add Bands", "if", "study", "in", "(", "'rsi'", ",", "'cci'", ")", ":", "bands", "=", "{", "'rsi'", ":", "(", "30", ",", "70", ")", ",", "'cci'", ":", "(", "-", "100", ",", "100", ")", "}", "_upper", "=", "study_kwargs", ".", "get", "(", "'{0}_upper'", ".", "format", "(", "study", ")", ",", "bands", "[", "study", "]", "[", "0", "]", ")", "_lower", "=", "study_kwargs", ".", "get", "(", "'{0}_lower'", ".", "format", "(", "study", ")", ",", "bands", "[", "study", "]", "[", "1", "]", ")", "yref", "=", "'y2'", "if", "include", "else", "'y1'", "shapes", "=", "[", "tools", ".", "get_shape", "(", "y", "=", "i", ",", "yref", "=", "yref", ",", "color", "=", "j", ",", "dash", "=", "'dash'", ")", "for", "(", "i", ",", "j", ")", "in", "[", "(", "_lower", ",", "'green'", ")", ",", "(", "_upper", ",", "'red'", ")", "]", "]", "figure", "[", "'layout'", "]", "[", "'shapes'", "]", "=", "shapes", "# if study=='rsi':", "# \trsi_upper=study_kwargs.get('rsi_upper',70)", "# \trsi_lower=study_kwargs.get('rsi_lower',30)", "# \tyref='y2' if include else 'y1'", "# \tshapes=[tools.get_shape(y=i,yref=yref,color=j,dash='dash') for (i,j) in [(rsi_lower,'green'),(rsi_upper,'red')]]", "# \tfigure['layout']['shapes']=shapes", "# if study=='cci':", "# \tcci_upper=study_kwargs.get('cci_upper',100)", "# \tcci_lower=study_kwargs.get('cci_lower',-100)", "# \tyref='y2' if include else 'y1'", "# \tshapes=[tools.get_shape(y=i,yref=yref,color=j,dash='dash') for (i,j) in [(cci_lower,'green'),(cci_upper,'red')]]", "# \tfigure['layout']['shapes']=shapes", "## Exports", "if", "asFigure", ":", "return", "figure", "else", ":", "return", "iplot", "(", "figure", ",", "sharing", "=", "sharing", ",", "filename", "=", "filename", ")" ]

[ "def", "framers", "(", "self", ",", "value", ")", ":", "# Handle sequence values", "if", "isinstance", "(", "value", ",", "collections", ".", "Sequence", ")", ":", "if", "len", "(", "value", ")", "!=", "2", ":", "raise", "ValueError", "(", "'need exactly 2 values to unpack'", ")", "elif", "(", "not", "isinstance", "(", "value", "[", "0", "]", ",", "framers", ".", "Framer", ")", "or", "not", "isinstance", "(", "value", "[", "1", "]", ",", "framers", ".", "Framer", ")", ")", ":", "raise", "ValueError", "(", "\"framer must be an instance of \"", "\"tendril.Framer\"", ")", "self", ".", "_send_framer", ",", "self", ".", "_recv_framer", "=", "value", "# If we have a single value, assume it's a framer", "else", ":", "if", "not", "isinstance", "(", "value", ",", "framers", ".", "Framer", ")", ":", "raise", "ValueError", "(", "\"framer must be an instance of \"", "\"tendril.Framer\"", ")", "self", ".", "_send_framer", "=", "value", "self", ".", "_recv_framer", "=", "value" ]

[ "def", "urljoin_safe", "(", "base_url", ",", "url", ",", "allow_fragments", "=", "True", ")", ":", "try", ":", "return", "wpull", ".", "url", ".", "urljoin", "(", "base_url", ",", "url", ",", "allow_fragments", "=", "allow_fragments", ")", "except", "ValueError", "as", "error", ":", "_logger", ".", "warning", "(", "__", "(", "_", "(", "'Unable to parse URL ‘{url}’: {error}.'),", "", "", "url", "=", "url", ",", "error", "=", "error", ")", ")" ]

[ "def", "t_EQUAL", "(", "self", ",", "t", ")", ":", "t", ".", "endlexpos", "=", "t", ".", "lexpos", "+", "len", "(", "t", ".", "value", ")", "return", "t" ]

[ "def", "exec_command", "(", "command", ",", "*", "*", "kwargs", ")", ":", "shell", "=", "kwargs", ".", "get", "(", "'shell'", ",", "False", ")", "stdin", "=", "kwargs", ".", "get", "(", "'stdin'", ",", "None", ")", "stdout", "=", "kwargs", ".", "get", "(", "'stdout'", ",", "None", ")", "stderr", "=", "kwargs", ".", "get", "(", "'stderr'", ",", "None", ")", "kwargs", ".", "update", "(", "shell", "=", "shell", ")", "kwargs", ".", "update", "(", "stdin", "=", "stdin", ")", "kwargs", ".", "update", "(", "stdout", "=", "stdout", ")", "kwargs", ".", "update", "(", "stderr", "=", "stderr", ")", "if", "not", "isinstance", "(", "command", ",", "list", ")", ":", "command", "=", "shlex", ".", "split", "(", "command", ")", "return_value", "=", "subprocess", ".", "call", "(", "command", ",", "*", "*", "kwargs", ")", "return", "CommandReturnValue", "(", "return_value", "=", "return_value", ",", "stdin", "=", "stdin", ",", "stdout", "=", "stdout", ",", "stderr", "=", "stderr", ")" ]

[ "def", "_should_skip_travis_event", "(", "on_travis_push", ",", "on_travis_pr", ",", "on_travis_api", ",", "on_travis_cron", ")", ":", "travis_event", "=", "os", ".", "getenv", "(", "'TRAVIS_EVENT_TYPE'", ")", "if", "travis_event", "is", "None", ":", "raise", "click", ".", "UsageError", "(", "'Using --travis but the TRAVIS_EVENT_TYPE '", "'environment variable is not detected.'", ")", "if", "travis_event", "==", "'push'", "and", "on_travis_push", "is", "False", ":", "click", ".", "echo", "(", "'Skipping upload on Travis push event.'", ")", "return", "True", "elif", "travis_event", "==", "'pull_request'", "and", "on_travis_pr", "is", "False", ":", "click", ".", "echo", "(", "'Skipping upload on Travis pull request event.'", ")", "return", "True", "elif", "travis_event", "==", "'api'", "and", "on_travis_api", "is", "False", ":", "click", ".", "echo", "(", "'Skipping upload on Travis pull request event.'", ")", "return", "True", "elif", "travis_event", "==", "'cron'", "and", "on_travis_cron", "is", "False", ":", "click", ".", "echo", "(", "'Skipping upload on Travis cron event.'", ")", "return", "True", "else", ":", "return", "False" ]

[ "def", "pack_own", "(", "self", ",", "serializer", ")", ":", "return", "Zframe", "(", "lib", ".", "zhashx_pack_own", "(", "self", ".", "_as_parameter_", ",", "serializer", ")", ",", "True", ")" ]

[ "def", "_gauc", "(", "ref_lca", ",", "est_lca", ",", "transitive", ",", "window", ")", ":", "# Make sure we have the right number of frames", "if", "ref_lca", ".", "shape", "!=", "est_lca", ".", "shape", ":", "raise", "ValueError", "(", "'Estimated and reference hierarchies '", "'must have the same shape.'", ")", "# How many frames?", "n", "=", "ref_lca", ".", "shape", "[", "0", "]", "# By default, the window covers the entire track", "if", "window", "is", "None", ":", "window", "=", "n", "# Initialize the score", "score", "=", "0.0", "# Iterate over query frames", "num_frames", "=", "0", "for", "query", "in", "range", "(", "n", ")", ":", "# Find all pairs i,j such that ref_lca[q, i] > ref_lca[q, j]", "results", "=", "slice", "(", "max", "(", "0", ",", "query", "-", "window", ")", ",", "min", "(", "n", ",", "query", "+", "window", ")", ")", "ref_score", "=", "ref_lca", "[", "query", ",", "results", "]", "est_score", "=", "est_lca", "[", "query", ",", "results", "]", "# Densify the results", "ref_score", "=", "ref_score", ".", "toarray", "(", ")", ".", "squeeze", "(", ")", "est_score", "=", "est_score", ".", "toarray", "(", ")", ".", "squeeze", "(", ")", "# Don't count the query as a result", "# when query < window, query itself is the index within the slice", "# otherwise, query is located at the center of the slice, window", "# (this also holds when the slice goes off the end of the array.)", "idx", "=", "min", "(", "query", ",", "window", ")", "ref_score", "=", "np", ".", "concatenate", "(", "(", "ref_score", "[", ":", "idx", "]", ",", "ref_score", "[", "idx", "+", "1", ":", "]", ")", ")", "est_score", "=", "np", ".", "concatenate", "(", "(", "est_score", "[", ":", "idx", "]", ",", "est_score", "[", "idx", "+", "1", ":", "]", ")", ")", "inversions", ",", "normalizer", "=", "_compare_frame_rankings", "(", "ref_score", ",", "est_score", ",", "transitive", "=", "transitive", ")", "if", "normalizer", ":", "score", "+=", "1.0", "-", "inversions", "/", "float", "(", "normalizer", ")", "num_frames", "+=", "1", "# Normalize by the number of frames counted.", "# If no frames are counted, take the convention 0/0 -> 0", "if", "num_frames", ":", "score", "/=", "float", "(", "num_frames", ")", "else", ":", "score", "=", "0.0", "return", "score" ]

[ "def", "_match", "(", "self", ",", "*", "*", "kwargs", ")", ":", "for", "k", "in", "kwargs", ".", "keys", "(", ")", ":", "try", ":", "val", "=", "getattr", "(", "self", ",", "k", ")", "except", "_a11y", ".", "Error", ":", "return", "False", "# Not all values may be strings (e.g. size, position)", "if", "sys", ".", "version_info", "[", ":", "2", "]", "<=", "(", "2", ",", "6", ")", ":", "if", "isinstance", "(", "val", ",", "basestring", ")", ":", "if", "not", "fnmatch", ".", "fnmatch", "(", "unicode", "(", "val", ")", ",", "kwargs", "[", "k", "]", ")", ":", "return", "False", "else", ":", "if", "val", "!=", "kwargs", "[", "k", "]", ":", "return", "False", "elif", "sys", ".", "version_info", "[", "0", "]", "==", "3", ":", "if", "isinstance", "(", "val", ",", "str", ")", ":", "if", "not", "fnmatch", ".", "fnmatch", "(", "val", ",", "str", "(", "kwargs", "[", "k", "]", ")", ")", ":", "return", "False", "else", ":", "if", "val", "!=", "kwargs", "[", "k", "]", ":", "return", "False", "else", ":", "if", "isinstance", "(", "val", ",", "str", ")", "or", "isinstance", "(", "val", ",", "unicode", ")", ":", "if", "not", "fnmatch", ".", "fnmatch", "(", "val", ",", "kwargs", "[", "k", "]", ")", ":", "return", "False", "else", ":", "if", "val", "!=", "kwargs", "[", "k", "]", ":", "return", "False", "return", "True" ]

[ "def", "set_charset", "(", "self", ",", "charset", ")", ":", "self", ".", "head", ".", "charset", ".", "attr", "(", "charset", "=", "charset", ")", "return", "self" ]

[ "def", "main", "(", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "'Search artists, lyrics, and songs!'", ")", "parser", ".", "add_argument", "(", "'artist'", ",", "help", "=", "'Specify an artist name (Default: Taylor Swift)'", ",", "default", "=", "'Taylor Swift'", ",", "nargs", "=", "'?'", ",", ")", "parser", ".", "add_argument", "(", "'-s'", ",", "'--song'", ",", "help", "=", "'Given artist name, specify a song name'", ",", "required", "=", "False", ",", ")", "parser", ".", "add_argument", "(", "'-l'", ",", "'--lyrics'", ",", "help", "=", "'Search for song by lyrics'", ",", "required", "=", "False", ",", ")", "args", "=", "parser", ".", "parse_args", "(", ")", "if", "args", ".", "lyrics", ":", "song", "=", "Song", ".", "find_song", "(", "args", ".", "lyrics", ")", "else", ":", "if", "args", ".", "song", ":", "song", "=", "Song", "(", "title", "=", "args", ".", "song", ",", "artist", "=", "args", ".", "artist", ",", ")", "else", ":", "artist", "=", "Artist", "(", "args", ".", "artist", ")", "if", "artist", ".", "songs", ":", "song", "=", "random", ".", "choice", "(", "artist", ".", "songs", ")", "else", ":", "print", "(", "'Couldn\\'t find any songs by artist {}!'", ".", "format", "(", "args", ".", "artist", ")", ")", "sys", ".", "exit", "(", "1", ")", "print", "(", "song", ".", "format", "(", ")", ")" ]

[ "def", "normalize", "(", "self", ")", ":", "total", "=", "sum", "(", "self", ".", "values", "(", ")", ")", "stats", "=", "{", "k", ":", "(", "v", "/", "float", "(", "total", ")", ")", "for", "k", ",", "v", "in", "self", ".", "items", "(", ")", "}", "return", "StatsCounter", "(", "stats", ")" ]

[ "def", "KeyPress", "(", "self", ",", "key", ",", "n", "=", "1", ",", "delay", "=", "0", ")", ":", "self", ".", "_delay", "(", "delay", ")", "cmd", "=", "Command", "(", "\"KeyPress\"", ",", "'KeyPress \"%s\", %s'", "%", "(", "key", ",", "n", ")", ")", "self", ".", "add", "(", "cmd", ")" ]

[ "def", "preprocess", "(", "net", ",", "image", ")", ":", "return", "np", ".", "float32", "(", "np", ".", "rollaxis", "(", "image", ",", "2", ")", "[", ":", ":", "-", "1", "]", ")", "-", "net", ".", "transformer", ".", "mean", "[", "\"data\"", "]" ]

[ "def", "comments_2", "(", "self", ",", "value", "=", "None", ")", ":", "if", "value", "is", "not", "None", ":", "try", ":", "value", "=", "str", "(", "value", ")", "except", "ValueError", ":", "raise", "ValueError", "(", "'value {} need to be of type str '", "'for field `comments_2`'", ".", "format", "(", "value", ")", ")", "if", "','", "in", "value", ":", "raise", "ValueError", "(", "'value should not contain a comma '", "'for field `comments_2`'", ")", "self", ".", "_comments_2", "=", "value" ]

[ "def", "set_device_name", "(", "self", ",", "newname", ")", ":", "return", "self", ".", "write", "(", "request", ".", "SetDeviceName", "(", "self", ".", "seq", ",", "*", "self", ".", "prep_str", "(", "newname", ")", ")", ")" ]

[ "def", "get_id", "(", "opts", ",", "cache_minion_id", "=", "False", ")", ":", "if", "opts", "[", "'root_dir'", "]", "is", "None", ":", "root_dir", "=", "salt", ".", "syspaths", ".", "ROOT_DIR", "else", ":", "root_dir", "=", "opts", "[", "'root_dir'", "]", "config_dir", "=", "salt", ".", "syspaths", ".", "CONFIG_DIR", "if", "config_dir", ".", "startswith", "(", "salt", ".", "syspaths", ".", "ROOT_DIR", ")", ":", "config_dir", "=", "config_dir", ".", "split", "(", "salt", ".", "syspaths", ".", "ROOT_DIR", ",", "1", ")", "[", "-", "1", "]", "# Check for cached minion ID", "id_cache", "=", "os", ".", "path", ".", "join", "(", "root_dir", ",", "config_dir", ".", "lstrip", "(", "os", ".", "path", ".", "sep", ")", ",", "'minion_id'", ")", "if", "opts", ".", "get", "(", "'minion_id_caching'", ",", "True", ")", ":", "try", ":", "with", "salt", ".", "utils", ".", "files", ".", "fopen", "(", "id_cache", ")", "as", "idf", ":", "name", "=", "salt", ".", "utils", ".", "stringutils", ".", "to_unicode", "(", "idf", ".", "readline", "(", ")", ".", "strip", "(", ")", ")", "bname", "=", "salt", ".", "utils", ".", "stringutils", ".", "to_bytes", "(", "name", ")", "if", "bname", ".", "startswith", "(", "codecs", ".", "BOM", ")", ":", "# Remove BOM if exists", "name", "=", "salt", ".", "utils", ".", "stringutils", ".", "to_str", "(", "bname", ".", "replace", "(", "codecs", ".", "BOM", ",", "''", ",", "1", ")", ")", "if", "name", "and", "name", "!=", "'localhost'", ":", "log", ".", "debug", "(", "'Using cached minion ID from %s: %s'", ",", "id_cache", ",", "name", ")", "return", "name", ",", "False", "except", "(", "IOError", ",", "OSError", ")", ":", "pass", "if", "'__role'", "in", "opts", "and", "opts", ".", "get", "(", "'__role'", ")", "==", "'minion'", ":", "log", ".", "debug", "(", "'Guessing ID. The id can be explicitly set in %s'", ",", "os", ".", "path", ".", "join", "(", "salt", ".", "syspaths", ".", "CONFIG_DIR", ",", "'minion'", ")", ")", "if", "opts", ".", "get", "(", "'id_function'", ")", ":", "newid", "=", "call_id_function", "(", "opts", ")", "else", ":", "newid", "=", "salt", ".", "utils", ".", "network", ".", "generate_minion_id", "(", ")", "if", "opts", ".", "get", "(", "'minion_id_lowercase'", ")", ":", "newid", "=", "newid", ".", "lower", "(", ")", "log", ".", "debug", "(", "'Changed minion id %s to lowercase.'", ",", "newid", ")", "# Optionally remove one or many domains in a generated minion id", "if", "opts", ".", "get", "(", "'minion_id_remove_domain'", ")", ":", "newid", "=", "remove_domain_from_fqdn", "(", "opts", ",", "newid", ")", "if", "'__role'", "in", "opts", "and", "opts", ".", "get", "(", "'__role'", ")", "==", "'minion'", ":", "if", "opts", ".", "get", "(", "'id_function'", ")", ":", "log", ".", "debug", "(", "'Found minion id from external function %s: %s'", ",", "opts", "[", "'id_function'", "]", ",", "newid", ")", "else", ":", "log", ".", "debug", "(", "'Found minion id from generate_minion_id(): %s'", ",", "newid", ")", "if", "cache_minion_id", "and", "opts", ".", "get", "(", "'minion_id_caching'", ",", "True", ")", ":", "_cache_id", "(", "newid", ",", "id_cache", ")", "is_ipv4", "=", "salt", ".", "utils", ".", "network", ".", "is_ipv4", "(", "newid", ")", "return", "newid", ",", "is_ipv4" ]

[ "def", "PHASE", "(", "angle", ",", "qubit", ")", ":", "return", "Gate", "(", "name", "=", "\"PHASE\"", ",", "params", "=", "[", "angle", "]", ",", "qubits", "=", "[", "unpack_qubit", "(", "qubit", ")", "]", ")" ]

[ "def", "follow", "(", "self", ",", "something", ",", "follow", "=", "True", ")", ":", "from", ".", "question", "import", "Question", "from", ".", "topic", "import", "Topic", "from", ".", "collection", "import", "Collection", "if", "isinstance", "(", "something", ",", "Author", ")", ":", "if", "something", ".", "url", "==", "self", ".", "url", ":", "return", "False", "data", "=", "{", "'_xsrf'", ":", "something", ".", "xsrf", ",", "'method'", ":", "'\tfollow_member'", "if", "follow", "else", "'unfollow_member'", ",", "'params'", ":", "json", ".", "dumps", "(", "{", "'hash_id'", ":", "something", ".", "hash_id", "}", ")", "}", "res", "=", "self", ".", "_session", ".", "post", "(", "Follow_Author_Url", ",", "data", "=", "data", ")", "return", "res", ".", "json", "(", ")", "[", "'r'", "]", "==", "0", "elif", "isinstance", "(", "something", ",", "Question", ")", ":", "data", "=", "{", "'_xsrf'", ":", "something", ".", "xsrf", ",", "'method'", ":", "'follow_question'", "if", "follow", "else", "'unfollow_question'", ",", "'params'", ":", "json", ".", "dumps", "(", "{", "'question_id'", ":", "str", "(", "something", ".", "qid", ")", "}", ")", "}", "res", "=", "self", ".", "_session", ".", "post", "(", "Follow_Question_Url", ",", "data", "=", "data", ")", "return", "res", ".", "json", "(", ")", "[", "'r'", "]", "==", "0", "elif", "isinstance", "(", "something", ",", "Topic", ")", ":", "data", "=", "{", "'_xsrf'", ":", "something", ".", "xsrf", ",", "'method'", ":", "'follow_topic'", "if", "follow", "else", "'unfollow_topic'", ",", "'params'", ":", "json", ".", "dumps", "(", "{", "'topic_id'", ":", "something", ".", "tid", "}", ")", "}", "res", "=", "self", ".", "_session", ".", "post", "(", "Follow_Topic_Url", ",", "data", "=", "data", ")", "return", "res", ".", "json", "(", ")", "[", "'r'", "]", "==", "0", "elif", "isinstance", "(", "something", ",", "Collection", ")", ":", "data", "=", "{", "'_xsrf'", ":", "something", ".", "xsrf", ",", "'favlist_id'", ":", "something", ".", "cid", "}", "res", "=", "self", ".", "_session", ".", "post", "(", "Follow_Collection_Url", "if", "follow", "else", "Unfollow_Collection_Url", ",", "data", "=", "data", ")", "return", "res", ".", "json", "(", ")", "[", "'r'", "]", "==", "0", "else", ":", "raise", "ValueError", "(", "'argument something need to be '", "'zhihu.Author, zhihu.Question'", "', Zhihu.Topic or Zhihu.Collection object.'", ")" ]

[ "def", "name", "(", "dtype", ")", ":", "dtype", "=", "tf", ".", "as_dtype", "(", "dtype", ")", "if", "hasattr", "(", "dtype", ",", "'name'", ")", ":", "return", "dtype", ".", "name", "if", "hasattr", "(", "dtype", ",", "'__name__'", ")", ":", "return", "dtype", ".", "__name__", "return", "str", "(", "dtype", ")" ]

[ "def", "forwards", "(", "apps", ",", "schema_editor", ")", ":", "Movie", "=", "apps", ".", "get_model", "(", "'spectator_events'", ",", "'Movie'", ")", "Work", "=", "apps", ".", "get_model", "(", "'spectator_events'", ",", "'Work'", ")", "WorkRole", "=", "apps", ".", "get_model", "(", "'spectator_events'", ",", "'WorkRole'", ")", "WorkSelection", "=", "apps", ".", "get_model", "(", "'spectator_events'", ",", "'WorkSelection'", ")", "for", "m", "in", "Movie", ".", "objects", ".", "all", "(", ")", ":", "work", "=", "Work", ".", "objects", ".", "create", "(", "kind", "=", "'movie'", ",", "title", "=", "m", ".", "title", ",", "title_sort", "=", "m", ".", "title_sort", ",", "year", "=", "m", ".", "year", ",", "imdb_id", "=", "m", ".", "imdb_id", ")", "for", "role", "in", "m", ".", "roles", ".", "all", "(", ")", ":", "WorkRole", ".", "objects", ".", "create", "(", "creator", "=", "role", ".", "creator", ",", "work", "=", "work", ",", "role_name", "=", "role", ".", "role_name", ",", "role_order", "=", "role", ".", "role_order", ")", "for", "selection", "in", "m", ".", "events", ".", "all", "(", ")", ":", "WorkSelection", ".", "objects", ".", "create", "(", "event", "=", "selection", ".", "event", ",", "work", "=", "work", ",", "order", "=", "selection", ".", "order", ")", "m", ".", "delete", "(", ")" ]

[ "def", "hook", "(", "self", ",", "name", ")", ":", "def", "wrapper", "(", "func", ")", ":", "self", ".", "hooks", ".", "add", "(", "name", ",", "func", ")", "return", "func", "return", "wrapper" ]

[ "def", "INT", "(", "cpu", ",", "op0", ")", ":", "if", "op0", ".", "read", "(", ")", "!=", "0x80", ":", "logger", ".", "warning", "(", "\"Unsupported interrupt\"", ")", "raise", "Interruption", "(", "op0", ".", "read", "(", ")", ")" ]