Datasets:

kejian

/

codesearchnet-python-pep8-full

like 1

[ "def", "indx_table", "(", "node_dict", ",", "tbl_mode", "=", "False", ")", ":", "nt", "=", "PrettyTable", "(", ")", "nt", ".", "header", "=", "False", "nt", ".", "padding_width", "=", "2", "nt", ".", "border", "=", "False", "clr_num", "=", "C_TI", "+", "\"NUM\"", "clr_name", "=", "C_TI", "+", "\"NAME\"", "clr_state", "=", "\"STATE\"", "+", "C_NORM", "t_lu", "=", "{", "True", ":", "[", "clr_num", ",", "\"NAME\"", ",", "\"REGION\"", ",", "\"CLOUD\"", ",", "\"SIZE\"", ",", "\"PUBLIC IP\"", ",", "clr_state", "]", ",", "False", ":", "[", "clr_name", ",", "\"REGION\"", ",", "\"CLOUD\"", ",", "\"SIZE\"", ",", "\"PUBLIC IP\"", ",", "clr_state", "]", "}", "nt", ".", "add_row", "(", "t_lu", "[", "tbl_mode", "]", ")", "for", "i", ",", "node", "in", "node_dict", ".", "items", "(", ")", ":", "state", "=", "C_STAT", "[", "node", ".", "state", "]", "+", "node", ".", "state", "+", "C_NORM", "inum", "=", "C_WARN", "+", "str", "(", "i", ")", "+", "C_NORM", "if", "node", ".", "public_ips", ":", "n_ip", "=", "node", ".", "public_ips", "else", ":", "n_ip", "=", "\"-\"", "r_lu", "=", "{", "True", ":", "[", "inum", ",", "node", ".", "name", ",", "node", ".", "zone", ",", "node", ".", "cloud", ",", "node", ".", "size", ",", "n_ip", ",", "state", "]", ",", "False", ":", "[", "node", ".", "name", ",", "node", ".", "zone", ",", "node", ".", "cloud", ",", "node", ".", "size", ",", "n_ip", ",", "state", "]", "}", "nt", ".", "add_row", "(", "r_lu", "[", "tbl_mode", "]", ")", "if", "not", "tbl_mode", ":", "print", "(", "nt", ")", "else", ":", "idx_tbl", "=", "nt", ".", "get_string", "(", ")", "return", "idx_tbl" ]

[ "def", "_is_national_number_suffix_of_other", "(", "numobj1", ",", "numobj2", ")", ":", "nn1", "=", "str", "(", "numobj1", ".", "national_number", ")", "nn2", "=", "str", "(", "numobj2", ".", "national_number", ")", "# Note that endswith returns True if the numbers are equal.", "return", "nn1", ".", "endswith", "(", "nn2", ")", "or", "nn2", ".", "endswith", "(", "nn1", ")" ]

[ "def", "echo_html_fenye_str", "(", "rec_num", ",", "fenye_num", ")", ":", "pagination_num", "=", "int", "(", "math", ".", "ceil", "(", "rec_num", "*", "1.0", "/", "10", ")", ")", "if", "pagination_num", "==", "1", "or", "pagination_num", "==", "0", ":", "fenye_str", "=", "''", "elif", "pagination_num", ">", "1", ":", "pager_mid", ",", "pager_pre", ",", "pager_next", ",", "pager_last", ",", "pager_home", "=", "''", ",", "''", ",", "''", ",", "''", ",", "''", "fenye_str", "=", "'<ul class=\"pagination\">'", "if", "fenye_num", ">", "1", ":", "pager_home", "=", "'''<li class=\"{0}\" name='fenye' onclick='change(this);'\n value='{1}'><a>First Page</a></li>'''", ".", "format", "(", "''", ",", "1", ")", "pager_pre", "=", "''' <li class=\"{0}\" name='fenye' onclick='change(this);'\n value='{1}'><a>Previous Page</a></li>'''", ".", "format", "(", "''", ",", "fenye_num", "-", "1", ")", "if", "fenye_num", ">", "5", ":", "cur_num", "=", "fenye_num", "-", "4", "else", ":", "cur_num", "=", "1", "if", "pagination_num", ">", "10", "and", "cur_num", "<", "pagination_num", "-", "10", ":", "show_num", "=", "cur_num", "+", "10", "else", ":", "show_num", "=", "pagination_num", "+", "1", "for", "num", "in", "range", "(", "cur_num", ",", "show_num", ")", ":", "if", "num", "==", "fenye_num", ":", "checkstr", "=", "'active'", "else", ":", "checkstr", "=", "''", "tmp_str_df", "=", "'''<li class=\"{0}\" name='fenye' onclick='change(this);'\n value='{1}'><a>{1}</a></li>'''", ".", "format", "(", "checkstr", ",", "num", ")", "pager_mid", "+=", "tmp_str_df", "if", "fenye_num", "<", "pagination_num", ":", "pager_next", "=", "'''<li class=\"{0}\" name='fenye' onclick='change(this);'\n value='{1}'><a>Next Page</a></li>'''", ".", "format", "(", "''", ",", "fenye_num", "+", "1", ")", "pager_last", "=", "'''<li class=\"{0}\" name='fenye' onclick='change(this);'\n value='{1}'><a>End Page</a></li>'''", ".", "format", "(", "''", ",", "pagination_num", ")", "fenye_str", "+=", "pager_home", "+", "pager_pre", "+", "pager_mid", "+", "pager_next", "+", "pager_last", "fenye_str", "+=", "'</ul>'", "else", ":", "return", "''", "return", "fenye_str" ]

[ "def", "import_ecdsakey_from_public_pem", "(", "pem", ",", "scheme", "=", "'ecdsa-sha2-nistp256'", ")", ":", "# Does 'pem' have the correct format?", "# This check will ensure arguments has the appropriate number", "# of objects and object types, and that all dict keys are properly named.", "# Raise 'securesystemslib.exceptions.FormatError' if the check fails.", "securesystemslib", ".", "formats", ".", "PEMECDSA_SCHEMA", ".", "check_match", "(", "pem", ")", "# Is 'scheme' properly formatted?", "securesystemslib", ".", "formats", ".", "ECDSA_SCHEME_SCHEMA", ".", "check_match", "(", "scheme", ")", "# Ensure the PEM string has a public header and footer. Although a simple", "# validation of 'pem' is performed here, a fully valid PEM string is needed", "# later to successfully verify signatures. Performing stricter validation of", "# PEMs are left to the external libraries that use 'pem'.", "if", "is_pem_public", "(", "pem", ")", ":", "public_pem", "=", "extract_pem", "(", "pem", ",", "private_pem", "=", "False", ")", "else", ":", "raise", "securesystemslib", ".", "exceptions", ".", "FormatError", "(", "'Invalid public'", "' pem: '", "+", "repr", "(", "pem", ")", ")", "# Begin building the ECDSA key dictionary.", "ecdsakey_dict", "=", "{", "}", "keytype", "=", "'ecdsa-sha2-nistp256'", "# Generate the keyid of the ECDSA key. 'key_value' corresponds to the", "# 'keyval' entry of the 'ECDSAKEY_SCHEMA' dictionary. The private key", "# information is not included in the generation of the 'keyid' identifier.", "# Convert any '\\r\\n' (e.g., Windows) newline characters to '\\n' so that a", "# consistent keyid is generated.", "key_value", "=", "{", "'public'", ":", "public_pem", ".", "replace", "(", "'\\r\\n'", ",", "'\\n'", ")", ",", "'private'", ":", "''", "}", "keyid", "=", "_get_keyid", "(", "keytype", ",", "scheme", ",", "key_value", ")", "ecdsakey_dict", "[", "'keytype'", "]", "=", "keytype", "ecdsakey_dict", "[", "'scheme'", "]", "=", "scheme", "ecdsakey_dict", "[", "'keyid'", "]", "=", "keyid", "ecdsakey_dict", "[", "'keyval'", "]", "=", "key_value", "# Add \"keyid_hash_algorithms\" so that equal ECDSA keys with different keyids", "# can be associated using supported keyid_hash_algorithms.", "ecdsakey_dict", "[", "'keyid_hash_algorithms'", "]", "=", "securesystemslib", ".", "settings", ".", "HASH_ALGORITHMS", "return", "ecdsakey_dict" ]

[ "async", "def", "send_activities", "(", "self", ",", "context", ":", "TurnContext", ",", "activities", ":", "List", "[", "Activity", "]", ")", ":", "if", "context", "is", "None", ":", "raise", "TypeError", "(", "'ConsoleAdapter.send_activities(): `context` argument cannot be None.'", ")", "if", "type", "(", "activities", ")", "!=", "list", ":", "raise", "TypeError", "(", "'ConsoleAdapter.send_activities(): `activities` argument must be a list.'", ")", "if", "len", "(", "activities", ")", "==", "0", ":", "raise", "ValueError", "(", "'ConsoleAdapter.send_activities(): `activities` argument cannot have a length of 0.'", ")", "async", "def", "next_activity", "(", "i", ":", "int", ")", ":", "responses", "=", "[", "]", "if", "i", "<", "len", "(", "activities", ")", ":", "responses", ".", "append", "(", "ResourceResponse", "(", ")", ")", "a", "=", "activities", "[", "i", "]", "if", "a", ".", "type", "==", "'delay'", ":", "await", "asyncio", ".", "sleep", "(", "a", ".", "delay", ")", "await", "next_activity", "(", "i", "+", "1", ")", "elif", "a", ".", "type", "==", "ActivityTypes", ".", "message", ":", "if", "a", ".", "attachments", "is", "not", "None", "and", "len", "(", "a", ".", "attachments", ")", ">", "0", ":", "append", "=", "'(1 attachment)'", "if", "len", "(", "a", ".", "attachments", ")", "==", "1", "else", "f'({len(a.attachments)} attachments)'", "print", "(", "f'{a.text} {append}'", ")", "else", ":", "print", "(", "a", ".", "text", ")", "await", "next_activity", "(", "i", "+", "1", ")", "else", ":", "print", "(", "f'[{a.type}]'", ")", "await", "next_activity", "(", "i", "+", "1", ")", "else", ":", "return", "responses", "await", "next_activity", "(", "0", ")" ]

[ "def", "next", "(", "self", ")", ":", "if", "self", ".", "_page", ".", "has_next", "(", ")", ":", "return", "self", ".", "_endless_page", "(", "self", ".", "_page", ".", "next_page_number", "(", ")", ",", "label", "=", "settings", ".", "NEXT_LABEL", ")", "return", "''" ]

[ "def", "unpack_xml", "(", "text", ")", "->", "ET", ".", "ElementTree", ":", "etree", ":", "ET", ".", "ElementTree", "=", "ET", ".", "parse", "(", "io", ".", "StringIO", "(", "text", ")", ")", "_check_for_errors", "(", "etree", ")", "return", "etree" ]

[ "def", "RemoveMultiLineComments", "(", "filename", ",", "lines", ",", "error", ")", ":", "lineix", "=", "0", "while", "lineix", "<", "len", "(", "lines", ")", ":", "lineix_begin", "=", "FindNextMultiLineCommentStart", "(", "lines", ",", "lineix", ")", "if", "lineix_begin", ">=", "len", "(", "lines", ")", ":", "return", "lineix_end", "=", "FindNextMultiLineCommentEnd", "(", "lines", ",", "lineix_begin", ")", "if", "lineix_end", ">=", "len", "(", "lines", ")", ":", "error", "(", "filename", ",", "lineix_begin", "+", "1", ",", "'readability/multiline_comment'", ",", "5", ",", "'Could not find end of multi-line comment'", ")", "return", "RemoveMultiLineCommentsFromRange", "(", "lines", ",", "lineix_begin", ",", "lineix_end", "+", "1", ")", "lineix", "=", "lineix_end", "+", "1" ]

[ "def", "get_module_name", "(", "self", ",", "path_args", ")", ":", "controller_prefix", "=", "self", ".", "controller_prefix", "cset", "=", "self", ".", "module_names", "module_name", "=", "controller_prefix", "mod_name", "=", "module_name", "while", "path_args", ":", "mod_name", "+=", "\".\"", "+", "path_args", "[", "0", "]", "if", "mod_name", "in", "cset", ":", "module_name", "=", "mod_name", "path_args", ".", "pop", "(", "0", ")", "else", ":", "break", "return", "module_name", ",", "path_args" ]

[ "def", "_add_parser_arguments_analyze", "(", "self", ",", "subparsers", ")", ":", "lyze_pars", "=", "subparsers", ".", "add_parser", "(", "\"analyze\"", ",", "help", "=", "\"Perform basic analysis on this catalog.\"", ")", "lyze_pars", ".", "add_argument", "(", "'--count'", ",", "'-c'", ",", "dest", "=", "'count'", ",", "default", "=", "False", ",", "action", "=", "'store_true'", ",", "help", "=", "'Determine counts of entries, files, etc.'", ")", "return", "lyze_pars" ]

[ "def", "wr_dat_files", "(", "self", ",", "expanded", "=", "False", ",", "write_dir", "=", "''", ")", ":", "# Get the set of dat files to be written, and", "# the channels to be written to each file.", "file_names", ",", "dat_channels", "=", "describe_list_indices", "(", "self", ".", "file_name", ")", "# Get the fmt and byte offset corresponding to each dat file", "DAT_FMTS", "=", "{", "}", "dat_offsets", "=", "{", "}", "for", "fn", "in", "file_names", ":", "DAT_FMTS", "[", "fn", "]", "=", "self", ".", "fmt", "[", "dat_channels", "[", "fn", "]", "[", "0", "]", "]", "# byte_offset may not be present", "if", "self", ".", "byte_offset", "is", "None", ":", "dat_offsets", "[", "fn", "]", "=", "0", "else", ":", "dat_offsets", "[", "fn", "]", "=", "self", ".", "byte_offset", "[", "dat_channels", "[", "fn", "]", "[", "0", "]", "]", "# Write the dat files", "if", "expanded", ":", "for", "fn", "in", "file_names", ":", "wr_dat_file", "(", "fn", ",", "DAT_FMTS", "[", "fn", "]", ",", "None", ",", "dat_offsets", "[", "fn", "]", ",", "True", ",", "[", "self", ".", "e_d_signal", "[", "ch", "]", "for", "ch", "in", "dat_channels", "[", "fn", "]", "]", ",", "self", ".", "samps_per_frame", ",", "write_dir", "=", "write_dir", ")", "else", ":", "# Create a copy to prevent overwrite", "dsig", "=", "self", ".", "d_signal", ".", "copy", "(", ")", "for", "fn", "in", "file_names", ":", "wr_dat_file", "(", "fn", ",", "DAT_FMTS", "[", "fn", "]", ",", "dsig", "[", ":", ",", "dat_channels", "[", "fn", "]", "[", "0", "]", ":", "dat_channels", "[", "fn", "]", "[", "-", "1", "]", "+", "1", "]", ",", "dat_offsets", "[", "fn", "]", ",", "write_dir", "=", "write_dir", ")" ]

[ "def", "set_staff_url", "(", "parser", ",", "token", ")", ":", "nodelist", "=", "parser", ".", "parse", "(", "(", "'end_set_staff_url'", ",", ")", ")", "parser", ".", "delete_first_token", "(", ")", "return", "AdminUrlNode", "(", "nodelist", ")" ]

[ "def", "trace_api", "(", "self", ")", ":", "if", "self", ".", "_trace_api", "is", "None", ":", "self", ".", "_trace_api", "=", "make_trace_api", "(", "self", ")", "return", "self", ".", "_trace_api" ]

[ "def", "FilterItems", "(", "self", ",", "filterFn", ",", "key", "=", "None", ")", ":", "with", "self", ".", "_mutex", ":", "if", "key", ":", "if", "key", "in", "self", ".", "_buckets", ":", "return", "self", ".", "_buckets", "[", "key", "]", ".", "FilterItems", "(", "filterFn", ")", "else", ":", "return", "0", "else", ":", "return", "sum", "(", "bucket", ".", "FilterItems", "(", "filterFn", ")", "for", "bucket", "in", "self", ".", "_buckets", ".", "values", "(", ")", ")" ]

[ "def", "_validate_namespaces", "(", "namespaces", ")", ":", "for", "source", ",", "namespace", "in", "namespaces", ".", "items", "(", ")", ":", "target", "=", "namespace", ".", "dest_name", "_validate_namespace", "(", "source", ")", "_validate_namespace", "(", "target", ")", "if", "source", ".", "count", "(", "\"*\"", ")", ">", "1", "or", "target", ".", "count", "(", "\"*\"", ")", ">", "1", ":", "raise", "errors", ".", "InvalidConfiguration", "(", "\"The namespace mapping from '%s' to '%s' cannot contain more \"", "\"than one '*' character.\"", "%", "(", "source", ",", "target", ")", ")", "if", "source", ".", "count", "(", "\"*\"", ")", "!=", "target", ".", "count", "(", "\"*\"", ")", ":", "raise", "errors", ".", "InvalidConfiguration", "(", "\"The namespace mapping from '%s' to '%s' must contain the \"", "\"same number of '*' characters.\"", "%", "(", "source", ",", "target", ")", ")", "if", "\"*\"", "not", "in", "source", ":", "continue", "# Make sure that wildcards are not moved from database name to", "# collection name or vice versa, eg \"db*.foo\" => \"db.foo_*\"", "if", "(", "wildcard_in_db", "(", "source", ")", "and", "not", "wildcard_in_db", "(", "target", ")", "or", "(", "not", "wildcard_in_db", "(", "source", ")", "and", "wildcard_in_db", "(", "target", ")", ")", ")", ":", "raise", "errors", ".", "InvalidConfiguration", "(", "\"The namespace mapping from '%s' to '%s' is invalid. A '*' \"", "\"that appears in the source database name must also appear\"", "\"in the target database name. A '*' that appears in the \"", "\"source collection name must also appear in the target \"", "\"collection name\"", "%", "(", "source", ",", "target", ")", ")", "for", "source1", ",", "source2", "in", "combinations", "(", "namespaces", ".", "keys", "(", ")", ",", "2", ")", ":", "if", "wildcards_overlap", "(", "source1", ",", "source2", ")", ":", "LOG", ".", "warning", "(", "'Namespaces \"%s\" and \"%s\" may match the '", "\"same source namespace.\"", ",", "source1", ",", "source2", ",", ")", "target1", "=", "namespaces", "[", "source1", "]", ".", "dest_name", "target2", "=", "namespaces", "[", "source2", "]", ".", "dest_name", "if", "target1", "==", "target2", ":", "raise", "errors", ".", "InvalidConfiguration", "(", "\"Multiple namespaces cannot be combined into one target \"", "\"namespace. Trying to map '%s' to '%s' but '%s' already \"", "\"corresponds to '%s' in the target system.\"", "%", "(", "source2", ",", "target2", ",", "source1", ",", "target1", ")", ")", "if", "wildcards_overlap", "(", "target1", ",", "target2", ")", ":", "LOG", ".", "warning", "(", "\"Multiple namespaces cannot be combined into one target \"", "\"namespace. Mapping from '%s' to '%s' might overlap \"", "\"with mapping from '%s' to '%s'.\"", "%", "(", "source2", ",", "target2", ",", "source1", ",", "target1", ")", ")" ]

[ "def", "check_job_status", "(", "self", ",", "key", "=", "JobDetails", ".", "topkey", ",", "fail_running", "=", "False", ",", "fail_pending", "=", "False", ",", "force_check", "=", "False", ")", ":", "if", "key", "in", "self", ".", "jobs", ":", "status", "=", "self", ".", "jobs", "[", "key", "]", ".", "status", "if", "status", "in", "[", "JobStatus", ".", "unknown", ",", "JobStatus", ".", "ready", ",", "JobStatus", ".", "pending", ",", "JobStatus", ".", "running", "]", "or", "force_check", ":", "status", "=", "self", ".", "_interface", ".", "check_job", "(", "self", ".", "jobs", "[", "key", "]", ")", "if", "status", "==", "JobStatus", ".", "running", "and", "fail_running", ":", "status", "=", "JobStatus", ".", "failed", "if", "status", "==", "JobStatus", ".", "pending", "and", "fail_pending", ":", "status", "=", "JobStatus", ".", "failed", "self", ".", "jobs", "[", "key", "]", ".", "status", "=", "status", "if", "self", ".", "_job_archive", ":", "self", ".", "_job_archive", ".", "register_job", "(", "self", ".", "jobs", "[", "key", "]", ")", "else", ":", "status", "=", "JobStatus", ".", "no_job", "return", "status" ]

[ "def", "hil_rc_inputs_raw_send", "(", "self", ",", "time_usec", ",", "chan1_raw", ",", "chan2_raw", ",", "chan3_raw", ",", "chan4_raw", ",", "chan5_raw", ",", "chan6_raw", ",", "chan7_raw", ",", "chan8_raw", ",", "chan9_raw", ",", "chan10_raw", ",", "chan11_raw", ",", "chan12_raw", ",", "rssi", ",", "force_mavlink1", "=", "False", ")", ":", "return", "self", ".", "send", "(", "self", ".", "hil_rc_inputs_raw_encode", "(", "time_usec", ",", "chan1_raw", ",", "chan2_raw", ",", "chan3_raw", ",", "chan4_raw", ",", "chan5_raw", ",", "chan6_raw", ",", "chan7_raw", ",", "chan8_raw", ",", "chan9_raw", ",", "chan10_raw", ",", "chan11_raw", ",", "chan12_raw", ",", "rssi", ")", ",", "force_mavlink1", "=", "force_mavlink1", ")" ]

[ "def", "rangeChange", "(", "self", ",", "pw", ",", "ranges", ")", ":", "if", "hasattr", "(", "ranges", ",", "'__iter__'", ")", ":", "# adjust the stim signal so that it falls in the correct range", "yrange_size", "=", "ranges", "[", "1", "]", "[", "1", "]", "-", "ranges", "[", "1", "]", "[", "0", "]", "stim_x", ",", "stim_y", "=", "self", ".", "stimPlot", ".", "getData", "(", ")", "if", "stim_y", "is", "not", "None", ":", "stim_height", "=", "yrange_size", "*", "STIM_HEIGHT", "# take it to 0", "stim_y", "=", "stim_y", "-", "np", ".", "amin", "(", "stim_y", ")", "# normalize", "if", "np", ".", "amax", "(", "stim_y", ")", "!=", "0", ":", "stim_y", "=", "stim_y", "/", "np", ".", "amax", "(", "stim_y", ")", "# scale for new size", "stim_y", "=", "stim_y", "*", "stim_height", "# raise to right place in plot", "stim_y", "=", "stim_y", "+", "(", "ranges", "[", "1", "]", "[", "1", "]", "-", "(", "stim_height", "*", "1.1", "+", "(", "stim_height", "*", "0.2", ")", ")", ")", "self", ".", "stimPlot", ".", "setData", "(", "stim_x", ",", "stim_y", ")", "# rmax = self.rasterTop*yrange_size + ranges[1][0]", "# rmin = self.rasterBottom*yrange_size + ranges[1][0]", "self", ".", "updateRasterBounds", "(", ")" ]

[ "def", "_fix_valid_indices", "(", "cls", ",", "valid_indices", ",", "insertion_index", ",", "dim", ")", ":", "# TODO: make this accept an immutable sequence for valid_indices", "# (a tuple) and return an immutable sequence rather than mutating an", "# argument.", "indices", "=", "np", ".", "array", "(", "sorted", "(", "valid_indices", "[", "dim", "]", ")", ")", "slice_index", "=", "np", ".", "sum", "(", "indices", "<=", "insertion_index", ")", "indices", "[", "slice_index", ":", "]", "+=", "1", "indices", "=", "np", ".", "insert", "(", "indices", ",", "slice_index", ",", "insertion_index", "+", "1", ")", "valid_indices", "[", "dim", "]", "=", "indices", ".", "tolist", "(", ")", "return", "valid_indices" ]

[ "def", "fromPandas", "(", "cls", ",", "df", ")", ":", "assert", "pd", "is", "not", "None", "if", "isinstance", "(", "df", ",", "pd", ".", "Series", ")", ":", "df", "=", "pd", ".", "DataFrame", "(", "df", ")", "else", ":", "assert", "isinstance", "(", "df", ",", "pd", ".", "DataFrame", ")", "keys", "=", "[", "key", "if", "isinstance", "(", "key", ",", "tuple", ")", "else", "(", "key", ",", ")", "for", "key", "in", "df", ".", "index", ".", "tolist", "(", ")", "]", "index", "=", "[", "(", "'index{}'", ".", "format", "(", "i", ")", ",", "cindex", ")", "for", "i", ",", "cindex", "in", "enumerate", "(", "zip", "(", "*", "keys", ")", ")", "]", "columns", "=", "[", "(", "str", "(", "cname", ")", ",", "df", "[", "cname", "]", ".", "tolist", "(", ")", ")", "for", "cname", "in", "df", ".", "columns", ".", "tolist", "(", ")", "]", "return", "cls", "(", "index", "=", "index", ",", "columns", "=", "columns", ")" ]

[ "def", "from_times", "(", "cls", ",", "times", ",", "delta_t", "=", "DEFAULT_OBSERVATION_TIME", ")", ":", "times_arr", "=", "np", ".", "asarray", "(", "times", ".", "jd", "*", "TimeMOC", ".", "DAY_MICRO_SEC", ",", "dtype", "=", "int", ")", "intervals_arr", "=", "np", ".", "vstack", "(", "(", "times_arr", ",", "times_arr", "+", "1", ")", ")", ".", "T", "# degrade the TimeMoc to the order computer from ``delta_t``", "order", "=", "TimeMOC", ".", "time_resolution_to_order", "(", "delta_t", ")", "return", "TimeMOC", "(", "IntervalSet", "(", "intervals_arr", ")", ")", ".", "degrade_to_order", "(", "order", ")" ]

[ "def", "swipe", "(", "self", ",", "x1", ":", "int", ",", "y1", ":", "int", ",", "x2", ":", "int", ",", "y2", ":", "int", ",", "duration", ":", "int", "=", "100", ")", "->", "None", ":", "self", ".", "_execute", "(", "'-s'", ",", "self", ".", "device_sn", ",", "'shell'", ",", "'input'", ",", "'swipe'", ",", "str", "(", "x1", ")", ",", "str", "(", "y1", ")", ",", "str", "(", "x2", ")", ",", "str", "(", "y2", ")", ",", "str", "(", "duration", ")", ")" ]

[ "def", "call", "(", "cls", ",", "method", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "api", "=", "None", "empty_key", "=", "kwargs", ".", "pop", "(", "'empty_key'", ",", "False", ")", "try", ":", "api", "=", "cls", ".", "get_api_connector", "(", ")", "apikey", "=", "cls", ".", "get", "(", "'api.key'", ")", "if", "not", "apikey", "and", "not", "empty_key", ":", "cls", ".", "echo", "(", "\"No apikey found, please use 'gandi setup' \"", "\"command\"", ")", "sys", ".", "exit", "(", "1", ")", "except", "MissingConfiguration", ":", "if", "api", "and", "empty_key", ":", "apikey", "=", "''", "elif", "not", "kwargs", ".", "get", "(", "'safe'", ")", ":", "cls", ".", "echo", "(", "\"No configuration found, please use 'gandi setup' \"", "\"command\"", ")", "sys", ".", "exit", "(", "1", ")", "else", ":", "return", "[", "]", "# make the call", "cls", ".", "debug", "(", "'calling method: %s'", "%", "method", ")", "for", "arg", "in", "args", ":", "cls", ".", "debug", "(", "'with params: %r'", "%", "arg", ")", "try", ":", "resp", "=", "api", ".", "request", "(", "method", ",", "apikey", ",", "*", "args", ",", "*", "*", "{", "'dry_run'", ":", "kwargs", ".", "get", "(", "'dry_run'", ",", "False", ")", ",", "'return_dry_run'", ":", "kwargs", ".", "get", "(", "'return_dry_run'", ",", "False", ")", "}", ")", "cls", ".", "dump", "(", "'responded: %r'", "%", "resp", ")", "return", "resp", "except", "APICallFailed", "as", "err", ":", "if", "kwargs", ".", "get", "(", "'safe'", ")", ":", "return", "[", "]", "if", "err", ".", "code", "==", "530040", ":", "cls", ".", "echo", "(", "\"Error: It appears you haven't purchased any credits \"", "\"yet.\\n\"", "\"Please visit https://www.gandi.net/credit/buy to \"", "\"learn more and buy credits.\"", ")", "sys", ".", "exit", "(", "1", ")", "if", "err", ".", "code", "==", "510150", ":", "cls", ".", "echo", "(", "\"Invalid API key, please use 'gandi setup' command.\"", ")", "sys", ".", "exit", "(", "1", ")", "if", "isinstance", "(", "err", ",", "DryRunException", ")", ":", "if", "kwargs", ".", "get", "(", "'return_dry_run'", ",", "False", ")", ":", "return", "err", ".", "dry_run", "else", ":", "for", "msg", "in", "err", ".", "dry_run", ":", "# TODO use trads with %s", "cls", ".", "echo", "(", "msg", "[", "'reason'", "]", ")", "cls", ".", "echo", "(", "'\\t'", "+", "' '", ".", "join", "(", "msg", "[", "'attr'", "]", ")", ")", "sys", ".", "exit", "(", "1", ")", "error", "=", "UsageError", "(", "err", ".", "errors", ")", "setattr", "(", "error", ",", "'code'", ",", "err", ".", "code", ")", "raise", "error" ]

[ "def", "unescape", "(", "s", ")", ":", "assert", "isinstance", "(", "s", ",", "basestring", ")", "s", "=", "s", ".", "replace", "(", "'\\t'", ",", "','", ")", "s", "=", "s", ".", "replace", "(", "'\\\\,'", ",", "','", ")", "s", "=", "s", ".", "replace", "(", "'\\\\n'", ",", "'\\n'", ")", "s", "=", "s", ".", "replace", "(", "'\\\\\\\\'", ",", "'\\\\'", ")", "return", "s" ]

[ "def", "run", "(", "self", ")", ":", "self", ".", "_start_datetime", "=", "datetime", ".", "now", "(", ")", "if", "not", "self", ".", "_is_ready", ":", "message", "=", "generate_input_error_message", "(", "tr", "(", "'You need to run `prepare` first.'", ")", ",", "m", ".", "Paragraph", "(", "tr", "(", "'In order to run the analysis, you need to call '", "'\"prepare\" before this function.'", ")", ")", ")", "return", "ANALYSIS_FAILED_BAD_INPUT", ",", "message", "try", ":", "self", ".", "reset_state", "(", ")", "clear_prof_data", "(", ")", "self", ".", "_run", "(", ")", "# Get the profiling log", "self", ".", "_performance_log", "=", "profiling_log", "(", ")", "self", ".", "callback", "(", "8", ",", "8", ",", "analysis_steps", "[", "'profiling'", "]", ")", "self", ".", "_profiling_table", "=", "create_profile_layer", "(", "self", ".", "performance_log_message", "(", ")", ")", "result", ",", "name", "=", "self", ".", "datastore", ".", "add_layer", "(", "self", ".", "_profiling_table", ",", "self", ".", "_profiling_table", ".", "keywords", "[", "'title'", "]", ")", "if", "not", "result", ":", "raise", "Exception", "(", "'Something went wrong with the datastore : {error_message}'", ".", "format", "(", "error_message", "=", "name", ")", ")", "self", ".", "_profiling_table", "=", "self", ".", "datastore", ".", "layer", "(", "name", ")", "self", ".", "profiling", ".", "keywords", "[", "'provenance_data'", "]", "=", "self", ".", "provenance", "write_iso19115_metadata", "(", "self", ".", "profiling", ".", "source", "(", ")", ",", "self", ".", "profiling", ".", "keywords", ")", "# Style all output layers.", "self", ".", "style", "(", ")", "# End of the impact function. We need to set this IF not ready.", "self", ".", "_is_ready", "=", "False", "# Set back input layers.", "self", ".", "hazard", "=", "load_layer", "(", "get_provenance", "(", "self", ".", "provenance", ",", "provenance_hazard_layer", ")", ")", "[", "0", "]", "self", ".", "exposure", "=", "load_layer", "(", "get_provenance", "(", "self", ".", "provenance", ",", "provenance_exposure_layer", ")", ")", "[", "0", "]", "aggregation_path", "=", "get_provenance", "(", "self", ".", "provenance", ",", "provenance_aggregation_layer", ")", "LOGGER", ".", "debug", "(", "'Aggregation %s'", "%", "aggregation_path", ")", "if", "aggregation_path", ":", "self", ".", "aggregation", "=", "load_layer", "(", "aggregation_path", ")", "[", "0", "]", "else", ":", "self", ".", "aggregation", "=", "None", "except", "NoFeaturesInExtentError", ":", "warning_heading", "=", "m", ".", "Heading", "(", "tr", "(", "'No features in the extent'", ")", ",", "*", "*", "WARNING_STYLE", ")", "warning_message", "=", "tr", "(", "'There are no features in the analysis extent.'", ")", "suggestion_heading", "=", "m", ".", "Heading", "(", "tr", "(", "'Suggestion'", ")", ",", "*", "*", "SUGGESTION_STYLE", ")", "suggestion", "=", "tr", "(", "'Try zooming in to a bigger area or check your features ('", "'geometry and attribute table). For instance, an empty '", "'geometry or an hazard without value are removed during the '", "'process.'", ")", "message", "=", "m", ".", "Message", "(", ")", "message", ".", "add", "(", "warning_heading", ")", "message", ".", "add", "(", "warning_message", ")", "message", ".", "add", "(", "suggestion_heading", ")", "message", ".", "add", "(", "suggestion", ")", "return", "ANALYSIS_FAILED_BAD_INPUT", ",", "message", "except", "SpatialIndexCreationError", ":", "warning_heading", "=", "m", ".", "Heading", "(", "tr", "(", "'Layer geometry issue'", ")", ",", "*", "*", "WARNING_STYLE", ")", "warning_message", "=", "tr", "(", "'There is a problem while creating the spatial index. '", "'Unfortunately, there is nothing you can do. Maybe try '", "'another area or another aggregation layer.'", ")", "message", "=", "m", ".", "Message", "(", ")", "message", ".", "add", "(", "warning_heading", ")", "message", ".", "add", "(", "warning_message", ")", "return", "ANALYSIS_FAILED_BAD_INPUT", ",", "message", "except", "ProcessingInstallationError", ":", "warning_heading", "=", "m", ".", "Heading", "(", "tr", "(", "'Configuration issue'", ")", ",", "*", "*", "WARNING_STYLE", ")", "warning_message", "=", "tr", "(", "'There is a problem with the Processing plugin.'", ")", "suggestion_heading", "=", "m", ".", "Heading", "(", "tr", "(", "'Suggestion'", ")", ",", "*", "*", "SUGGESTION_STYLE", ")", "suggestion", "=", "tr", "(", "'InaSAFE depends on the QGIS Processing plugin. This is a '", "'core plugin that ships with QGIS. It used to be possible to '", "'install the processing plugin from the QGIS Plugin Manager, '", "'however we advise you not to use these version since the '", "'Plugin Manager version may be incompatible with the '", "'version needed by InaSAFE. To resolve this issue, check in '", "'your (QGIS profile path)/python/plugins directory if you '", "'have a processing folder. If you do, remove the processing '", "'folder and then restart QGIS. If this issue persists, please '", "'report the problem to the InaSAFE team.'", ")", "message", "=", "m", ".", "Message", "(", ")", "message", ".", "add", "(", "warning_heading", ")", "message", ".", "add", "(", "warning_message", ")", "message", ".", "add", "(", "suggestion_heading", ")", "message", ".", "add", "(", "suggestion", ")", "return", "ANALYSIS_FAILED_BAD_INPUT", ",", "message", "except", "InaSAFEError", "as", "e", ":", "message", "=", "get_error_message", "(", "e", ")", "return", "ANALYSIS_FAILED_BAD_CODE", ",", "message", "except", "MemoryError", ":", "warning_heading", "=", "m", ".", "Heading", "(", "tr", "(", "'Memory issue'", ")", ",", "*", "*", "WARNING_STYLE", ")", "warning_message", "=", "tr", "(", "'There is not enough free memory to run this analysis.'", ")", "suggestion_heading", "=", "m", ".", "Heading", "(", "tr", "(", "'Suggestion'", ")", ",", "*", "*", "SUGGESTION_STYLE", ")", "suggestion", "=", "tr", "(", "'Try zooming in to a smaller area or using a raster layer '", "'with a coarser resolution to speed up execution and reduce '", "'memory requirements. You could also try adding more RAM to '", "'your computer.'", ")", "message", "=", "m", ".", "Message", "(", ")", "message", ".", "add", "(", "warning_heading", ")", "message", ".", "add", "(", "warning_message", ")", "message", ".", "add", "(", "suggestion_heading", ")", "message", ".", "add", "(", "suggestion", ")", "return", "ANALYSIS_FAILED_BAD_INPUT", ",", "message", "except", "Exception", "as", "e", ":", "if", "self", ".", "debug_mode", ":", "# We run in debug mode, we do not want to catch the exception.", "# You should download the First Aid plugin for instance.", "raise", "else", ":", "message", "=", "get_error_message", "(", "e", ")", "return", "ANALYSIS_FAILED_BAD_CODE", ",", "message", "else", ":", "return", "ANALYSIS_SUCCESS", ",", "None" ]

[ "def", "read_playlists", "(", "self", ")", ":", "self", ".", "playlists", "=", "[", "]", "self", ".", "selected_playlist", "=", "-", "1", "files", "=", "glob", ".", "glob", "(", "path", ".", "join", "(", "self", ".", "stations_dir", ",", "'*.csv'", ")", ")", "if", "len", "(", "files", ")", "==", "0", ":", "return", "0", ",", "-", "1", "else", ":", "for", "a_file", "in", "files", ":", "a_file_name", "=", "''", ".", "join", "(", "path", ".", "basename", "(", "a_file", ")", ".", "split", "(", "'.'", ")", "[", ":", "-", "1", "]", ")", "a_file_size", "=", "self", ".", "_bytes_to_human", "(", "path", ".", "getsize", "(", "a_file", ")", ")", "a_file_time", "=", "ctime", "(", "path", ".", "getmtime", "(", "a_file", ")", ")", "self", ".", "playlists", ".", "append", "(", "[", "a_file_name", ",", "a_file_time", ",", "a_file_size", ",", "a_file", "]", ")", "self", ".", "playlists", ".", "sort", "(", ")", "for", "i", ",", "a_playlist", "in", "enumerate", "(", "self", ".", "playlists", ")", ":", "if", "a_playlist", "[", "-", "1", "]", "==", "self", ".", "stations_file", ":", "self", ".", "selected_playlist", "=", "i", "break", "return", "len", "(", "self", ".", "playlists", ")", ",", "self", ".", "selected_playlist" ]

[ "def", "_volume_command", "(", "ramp", ",", "volume", ")", ":", "if", "volume", "is", "not", "None", ":", "ramp", ".", "set_volume", "(", "float", "(", "volume", ")", ")", "else", ":", "print", "ramp", ".", "volume" ]

[ "def", "log_variable_sizes", "(", "var_list", ",", "tag", ",", "verbose", "=", "True", ",", "mesh_to_impl", "=", "None", ")", ":", "if", "not", "var_list", ":", "return", "name_to_var", "=", "{", "v", ".", "name", ":", "v", "for", "v", "in", "var_list", "}", "total_size", "=", "0", "total_slice_size", "=", "0", "for", "v_name", "in", "sorted", "(", "list", "(", "name_to_var", ")", ")", ":", "v", "=", "name_to_var", "[", "v_name", "]", "v_size", "=", "v", ".", "shape", ".", "size", "if", "mesh_to_impl", "is", "not", "None", ":", "slice_size", "=", "mesh_to_impl", "[", "v", ".", "mesh", "]", ".", "slice_size", "(", "v", ".", "shape", ")", "else", ":", "slice_size", "=", "0", "total_slice_size", "+=", "slice_size", "if", "verbose", ":", "tf", ".", "logging", ".", "info", "(", "\"Variable %s size %s slice_size %s %s\"", ",", "v", ".", "name", ".", "ljust", "(", "60", ")", ",", "str", "(", "v_size", ")", ".", "ljust", "(", "12", ")", ",", "str", "(", "slice_size", ")", ".", "ljust", "(", "12", ")", ",", "str", "(", "v", ".", "shape", ")", ".", "ljust", "(", "60", ")", ")", "if", "isinstance", "(", "v", ",", "StackedVariable", ")", ":", "for", "n", "in", "v", ".", "original_names", ":", "tf", ".", "logging", ".", "info", "(", "\" \"", "+", "n", ")", "total_size", "+=", "v_size", "tf", ".", "logging", ".", "info", "(", "\"%s count: %s Total size: %s Total slice_size: %s\"", ",", "tag", ".", "ljust", "(", "30", ")", ",", "str", "(", "len", "(", "var_list", ")", ")", ".", "ljust", "(", "6", ")", ",", "str", "(", "total_size", ")", ".", "ljust", "(", "15", ")", ",", "str", "(", "total_slice_size", ")", ".", "ljust", "(", "15", ")", ")" ]

[ "def", "_update_pending_document_state", "(", "cursor", ",", "document_id", ",", "is_license_accepted", ",", "are_roles_accepted", ")", ":", "args", "=", "(", "bool", "(", "is_license_accepted", ")", ",", "bool", "(", "are_roles_accepted", ")", ",", "document_id", ",", ")", "cursor", ".", "execute", "(", "\"\"\"\\\nUPDATE pending_documents\nSET (license_accepted, roles_accepted) = (%s, %s)\nWHERE id = %s\"\"\"", ",", "args", ")" ]

[ "def", "population_variant_regions", "(", "items", ",", "merged", "=", "False", ")", ":", "def", "_get_variant_regions", "(", "data", ")", ":", "out", "=", "dd", ".", "get_variant_regions", "(", "data", ")", "or", "dd", ".", "get_sample_callable", "(", "data", ")", "# Only need to merge for variant region inputs, not callable BED regions which don't overlap", "if", "merged", "and", "dd", ".", "get_variant_regions", "(", "data", ")", ":", "merged_out", "=", "dd", ".", "get_variant_regions_merged", "(", "data", ")", "if", "merged_out", ":", "out", "=", "merged_out", "else", ":", "out", "=", "merge_overlaps", "(", "out", ",", "data", ")", "return", "out", "import", "pybedtools", "if", "len", "(", "items", ")", "==", "1", ":", "return", "_get_variant_regions", "(", "items", "[", "0", "]", ")", "else", ":", "paired", "=", "vcfutils", ".", "get_paired", "(", "items", ")", "if", "paired", ":", "return", "_get_variant_regions", "(", "paired", ".", "tumor_data", ")", "else", ":", "vrs", "=", "[", "]", "for", "data", "in", "items", ":", "vr_bed", "=", "_get_variant_regions", "(", "data", ")", "if", "vr_bed", ":", "vrs", ".", "append", "(", "(", "pybedtools", ".", "BedTool", "(", "vr_bed", ")", ".", "total_coverage", "(", ")", ",", "vr_bed", ")", ")", "vrs", ".", "sort", "(", "reverse", "=", "True", ")", "if", "vrs", ":", "return", "vrs", "[", "0", "]", "[", "1", "]" ]

[ "def", "populate", "(", "self", ",", "priority", ",", "address", ",", "rtr", ",", "data", ")", ":", "assert", "isinstance", "(", "data", ",", "bytes", ")", "self", ".", "needs_high_priority", "(", "priority", ")", "self", ".", "needs_no_rtr", "(", "rtr", ")", "self", ".", "needs_data", "(", "data", ",", "3", ")", "self", ".", "set_attributes", "(", "priority", ",", "address", ",", "rtr", ")", "self", ".", "closed", "=", "self", ".", "byte_to_channels", "(", "data", "[", "0", "]", ")", "self", ".", "opened", "=", "self", ".", "byte_to_channels", "(", "data", "[", "1", "]", ")", "self", ".", "closed_long", "=", "self", ".", "byte_to_channels", "(", "data", "[", "2", "]", ")" ]

[ "def", "length", "(", "self", ")", ":", "span", "=", "self", ".", "_stop", "-", "self", ".", "_start", "length", ",", "modulo", "=", "divmod", "(", "span", ",", "self", ".", "_step", ")", "if", "length", "<", "0", ":", "return", "0", "if", "modulo", "!=", "0", ":", "return", "length", "+", "1", "return", "length" ]

[ "def", "tracebacks_from_file", "(", "fileobj", ",", "reverse", "=", "False", ")", ":", "if", "reverse", ":", "lines", "=", "deque", "(", ")", "for", "line", "in", "BackwardsReader", "(", "fileobj", ")", ":", "lines", ".", "appendleft", "(", "line", ")", "if", "tb_head", "in", "line", ":", "yield", "next", "(", "tracebacks_from_lines", "(", "lines", ")", ")", "lines", ".", "clear", "(", ")", "else", ":", "for", "traceback", "in", "tracebacks_from_lines", "(", "fileobj", ")", ":", "yield", "traceback" ]

[ "def", "_if", "(", "ctx", ",", "logical_test", ",", "value_if_true", "=", "0", ",", "value_if_false", "=", "False", ")", ":", "return", "value_if_true", "if", "conversions", ".", "to_boolean", "(", "logical_test", ",", "ctx", ")", "else", "value_if_false" ]

[ "def", "to_drake_step", "(", "inputs", ",", "output", ")", ":", "i", "=", "[", "output", ".", "_yaml_filename", "]", "i", ".", "extend", "(", "map", "(", "lambda", "i", ":", "i", ".", "_target_filename", ",", "list", "(", "inputs", ")", ")", ")", "i", ".", "extend", "(", "output", ".", "dependencies", ")", "# add source file of output and its non-target inputs", "# if they're not in the drain library", "objects", "=", "get_inputs", "(", "output", ",", "target", "=", "False", ")", "objects", ".", "add", "(", "output", ")", "sources", "=", "set", "(", "[", "os", ".", "path", ".", "abspath", "(", "inspect", ".", "getsourcefile", "(", "o", ".", "__class__", ")", ")", "for", "o", "in", "objects", "]", ")", "i", ".", "extend", "(", "[", "s", "for", "s", "in", "sources", "if", "not", "s", ".", "startswith", "(", "os", ".", "path", ".", "dirname", "(", "__file__", ")", ")", "]", ")", "output_str", "=", "'%'", "+", "output", ".", "__class__", ".", "__name__", "if", "output", ".", "name", ":", "output_str", "+=", "', %'", "+", "output", ".", "name", "if", "output", ".", "target", ":", "output_str", "+=", "', '", "+", "os", ".", "path", ".", "join", "(", "output", ".", "_target_filename", ")", "return", "'{output} <- {inputs} [method:drain]\\n\\n'", ".", "format", "(", "output", "=", "output_str", ",", "inputs", "=", "str", ".", "join", "(", "', '", ",", "i", ")", ")" ]

[ "def", "left_outer", "(", "self", ")", ":", "self", ".", "get_collections_data", "(", ")", "left_outer_join", "=", "self", ".", "merge_join_docs", "(", "set", "(", "self", ".", "collections_data", "[", "'left'", "]", ".", "keys", "(", ")", ")", ")", "return", "left_outer_join" ]

[ "def", "is_typing_handler", "(", "stream", ")", ":", "while", "True", ":", "packet", "=", "yield", "from", "stream", ".", "get", "(", ")", "session_id", "=", "packet", ".", "get", "(", "'session_key'", ")", "user_opponent", "=", "packet", ".", "get", "(", "'username'", ")", "typing", "=", "packet", ".", "get", "(", "'typing'", ")", "if", "session_id", "and", "user_opponent", "and", "typing", "is", "not", "None", ":", "user_owner", "=", "get_user_from_session", "(", "session_id", ")", "if", "user_owner", ":", "opponent_socket", "=", "ws_connections", ".", "get", "(", "(", "user_opponent", ",", "user_owner", ".", "username", ")", ")", "if", "typing", "and", "opponent_socket", ":", "yield", "from", "target_message", "(", "opponent_socket", ",", "{", "'type'", ":", "'opponent-typing'", ",", "'username'", ":", "user_opponent", "}", ")", "else", ":", "pass", "# invalid session id\r", "else", ":", "pass" ]

[ "def", "__collapse_stranded", "(", "s", ",", "proc_strands", ",", "names", "=", "False", ",", "verbose", "=", "False", ")", ":", "def", "get_first_matching_index", "(", "s", ",", "proc_strands", ")", ":", "for", "i", "in", "range", "(", "0", ",", "len", "(", "s", ")", ")", ":", "if", "s", "[", "i", "]", ".", "strand", "in", "proc_strands", ":", "return", "i", "return", "None", "if", "proc_strands", "not", "in", "[", "set", "(", "\"+\"", ")", ",", "set", "(", "\"-\"", ")", ",", "set", "(", "[", "\"+\"", ",", "\"-\"", "]", ")", "]", ":", "raise", "GenomicIntervalError", "(", "\"failed collapsing intervals on strands '\"", "+", "\",\"", ".", "join", "(", "proc_strands", ")", "+", "\"''; unrecognised \"", "+", "\"strand symbols\"", ")", "first_index", "=", "get_first_matching_index", "(", "s", ",", "proc_strands", ")", "if", "first_index", "is", "None", ":", "return", "[", "]", "res", "=", "[", "]", "current", "=", "copy", ".", "copy", "(", "s", "[", "first_index", "]", ")", "current", ".", "strand", "=", "'+'", "if", "(", "proc_strands", "==", "set", "(", "\"+\"", ")", "or", "proc_strands", "==", "set", "(", "[", "\"+\"", ",", "\"-\"", "]", ")", ")", "else", "'-'", "current", ".", "score", "=", "0", "current", ".", "name", "=", "\"X\"", "if", "not", "names", "else", "set", "(", "s", "[", "first_index", "]", ".", "name", ")", "for", "i", "in", "range", "(", "first_index", "+", "1", ",", "len", "(", "s", ")", ")", ":", "if", "s", "[", "i", "]", ".", "strand", "not", "in", "proc_strands", ":", "continue", "# make sure things are sorted..", "if", "(", "s", "[", "i", "]", ".", "chrom", "<", "s", "[", "i", "-", "1", "]", ".", "chrom", ")", "or", "(", "s", "[", "i", "]", ".", "chrom", "==", "s", "[", "i", "-", "1", "]", ".", "chrom", "and", "s", "[", "i", "]", ".", "start", "<", "s", "[", "i", "-", "1", "]", ".", "start", ")", ":", "raise", "GenomicIntervalError", "(", "\"collapsing regions failed. saw this \"", "+", "\"region: \"", "+", "str", "(", "s", "[", "i", "-", "1", "]", ")", "+", "\" before this \"", "+", "\"one: \"", "+", "str", "(", "s", "[", "i", "]", ")", ")", "# because of sorting order, we know that nothing else exists with", "# start less than s[i] which we haven't already seen.", "if", "s", "[", "i", "]", ".", "start", ">", "current", ".", "end", "or", "s", "[", "i", "]", ".", "chrom", "!=", "current", ".", "chrom", ":", "if", "names", ":", "current", ".", "name", "=", "\";\"", ".", "join", "(", "current", ".", "name", ")", "res", ".", "append", "(", "current", ")", "current", "=", "copy", ".", "copy", "(", "s", "[", "i", "]", ")", "current", ".", "strand", "=", "'+'", "if", "(", "proc_strands", "==", "set", "(", "\"+\"", ")", "or", "proc_strands", "==", "set", "(", "[", "\"+\"", ",", "\"-\"", "]", ")", ")", "else", "'-'", "current", ".", "score", "=", "0", "current", ".", "name", "=", "\"X\"", "if", "not", "names", "else", "set", "(", "s", "[", "i", "]", ".", "name", ")", "else", ":", "current", ".", "end", "=", "max", "(", "s", "[", "i", "]", ".", "end", ",", "current", ".", "end", ")", "if", "names", ":", "current", ".", "name", ".", "add", "(", "s", "[", "i", "]", ".", "name", ")", "# don't forget the last one...", "if", "names", ":", "current", ".", "name", "=", "\";\"", ".", "join", "(", "current", ".", "name", ")", "res", ".", "append", "(", "current", ")", "return", "res" ]

[ "def", "visit_index", "(", "self", ",", "node", ",", "parent", ")", ":", "newnode", "=", "nodes", ".", "Index", "(", "parent", "=", "parent", ")", "newnode", ".", "postinit", "(", "self", ".", "visit", "(", "node", ".", "value", ",", "newnode", ")", ")", "return", "newnode" ]

[ "def", "power_off", "(", "self", ")", ":", "status", "=", "self", ".", "status", "(", ")", "if", "status", "[", "'power'", "]", ":", "# Setting power off when it is already off can cause hangs", "self", ".", "_send", "(", "self", ".", "CMD_POWERSAVE", "+", "self", ".", "CMD_OFF", ")" ]

[ "def", "get_assign_groups", "(", "line", ",", "ops", "=", "ops", ")", ":", "group", "=", "[", "]", "for", "item", "in", "line", ":", "group", ".", "append", "(", "item", ")", "if", "item", "in", "ops", ":", "yield", "group", "group", "=", "[", "]", "yield", "group" ]

[ "def", "_connect", "(", "self", ")", ":", "timeout", "=", "None", "if", "self", ".", "_options", "is", "not", "None", "and", "'timeout'", "in", "self", ".", "_options", ":", "timeout", "=", "self", ".", "_options", "[", "'timeout'", "]", "if", "self", ".", "_client", ".", "_credentials", ":", "self", ".", "_connection", "=", "self", ".", "_connection_class", "(", "host", "=", "self", ".", "_node", ".", "host", ",", "port", "=", "self", ".", "_node", ".", "http_port", ",", "credentials", "=", "self", ".", "_client", ".", "_credentials", ",", "timeout", "=", "timeout", ")", "else", ":", "self", ".", "_connection", "=", "self", ".", "_connection_class", "(", "host", "=", "self", ".", "_node", ".", "host", ",", "port", "=", "self", ".", "_node", ".", "http_port", ",", "timeout", "=", "timeout", ")", "# Forces the population of stats and resources before any", "# other requests are made.", "self", ".", "server_version" ]

[ "def", "give_str_indented", "(", "self", ",", "tags", "=", "False", ")", ":", "args", "=", "self", ".", "_args", "[", ":", "]", "kwargs", "=", "self", ".", "_kwargs", "rv", "=", "self", ".", "_give_str_indented", "(", "args", ",", "kwargs", ",", "tags", ")", "if", "not", "tags", ":", "rv", "=", "self", ".", "strip_color_tags", "(", "rv", ")", "return", "rv" ]

[ "def", "moran_cultural", "(", "network", ")", ":", "if", "not", "network", ".", "transmissions", "(", ")", ":", "# first step, replacer is a source", "replacer", "=", "random", ".", "choice", "(", "network", ".", "nodes", "(", "type", "=", "Source", ")", ")", "replacer", ".", "transmit", "(", ")", "else", ":", "replacer", "=", "random", ".", "choice", "(", "network", ".", "nodes", "(", "type", "=", "Agent", ")", ")", "replaced", "=", "random", ".", "choice", "(", "replacer", ".", "neighbors", "(", "direction", "=", "\"to\"", ",", "type", "=", "Agent", ")", ")", "from", "operator", "import", "attrgetter", "replacer", ".", "transmit", "(", "what", "=", "max", "(", "replacer", ".", "infos", "(", ")", ",", "key", "=", "attrgetter", "(", "'creation_time'", ")", ")", ",", "to_whom", "=", "replaced", ")" ]

[ "def", "init_app", "(", "self", ",", "app", "=", "None", ",", "blueprint", "=", "None", ",", "additional_blueprints", "=", "None", ")", ":", "if", "app", "is", "not", "None", ":", "self", ".", "app", "=", "app", "if", "blueprint", "is", "not", "None", ":", "self", ".", "blueprint", "=", "blueprint", "for", "resource", "in", "self", ".", "resources", ":", "self", ".", "route", "(", "resource", "[", "'resource'", "]", ",", "resource", "[", "'view'", "]", ",", "*", "resource", "[", "'urls'", "]", ",", "url_rule_options", "=", "resource", "[", "'url_rule_options'", "]", ")", "if", "self", ".", "blueprint", "is", "not", "None", ":", "self", ".", "app", ".", "register_blueprint", "(", "self", ".", "blueprint", ")", "if", "additional_blueprints", "is", "not", "None", ":", "for", "blueprint", "in", "additional_blueprints", ":", "self", ".", "app", ".", "register_blueprint", "(", "blueprint", ")", "self", ".", "app", ".", "config", ".", "setdefault", "(", "'PAGE_SIZE'", ",", "30", ")" ]

[ "def", "_get_keycache", "(", "self", ",", "parentity", ",", "branch", ",", "turn", ",", "tick", ",", "*", ",", "forward", ")", ":", "lru_append", "(", "self", ".", "keycache", ",", "self", ".", "_kc_lru", ",", "(", "parentity", "+", "(", "branch", ",", ")", ",", "turn", ",", "tick", ")", ",", "KEYCACHE_MAXSIZE", ")", "return", "self", ".", "_get_keycachelike", "(", "self", ".", "keycache", ",", "self", ".", "keys", ",", "self", ".", "_get_adds_dels", ",", "parentity", ",", "branch", ",", "turn", ",", "tick", ",", "forward", "=", "forward", ")" ]

[ "def", "getVC", "(", "self", ")", ":", "_Cr", "=", "decompose_GxE", "(", "self", ".", "full", "[", "'Cr'", "]", ")", "RV", "=", "{", "}", "for", "key", "in", "list", "(", "_Cr", ".", "keys", "(", ")", ")", ":", "RV", "[", "'var_%s'", "%", "key", "]", "=", "sp", ".", "array", "(", "[", "var_CoXX", "(", "_Cr", "[", "key", "]", ",", "self", ".", "Xr", ")", "]", ")", "RV", "[", "'var_c'", "]", "=", "self", ".", "full", "[", "'var_c'", "]", "RV", "[", "'var_n'", "]", "=", "self", ".", "full", "[", "'var_n'", "]", "return", "RV" ]

[ "def", "load", "(", "self", ",", "content", ")", ":", "# Try parsing the YAML with global tags", "try", ":", "config", "=", "yaml", ".", "load", "(", "content", ",", "Loader", "=", "self", ".", "_loader", "(", "self", ".", "_global_tags", ")", ")", "except", "yaml", ".", "YAMLError", ":", "raise", "InvalidConfigError", "(", "_", "(", "\"Config is not valid yaml.\"", ")", ")", "# Try extracting just the tool portion", "try", ":", "config", "=", "config", "[", "self", ".", "tool", "]", "except", "(", "TypeError", ",", "KeyError", ")", ":", "return", "None", "# If no scopes, just apply global default", "if", "not", "isinstance", "(", "config", ",", "dict", ")", ":", "config", "=", "self", ".", "_apply_default", "(", "config", ",", "self", ".", "_global_default", ")", "else", ":", "# Figure out what scopes exist", "scoped_keys", "=", "set", "(", "key", "for", "key", "in", "self", ".", "_scopes", ")", "# For every scope", "for", "key", "in", "config", ":", "# If scope has custom tags, apply", "if", "key", "in", "scoped_keys", ":", "# local tags, and local default", "tags", ",", "default", "=", "self", ".", "_scopes", "[", "key", "]", "# Inherit global default if no local default", "if", "not", "default", ":", "default", "=", "self", ".", "_global_default", "config", "[", "key", "]", "=", "self", ".", "_apply_default", "(", "config", "[", "key", "]", ",", "default", ")", "self", ".", "_apply_scope", "(", "config", "[", "key", "]", ",", "tags", ")", "# Otherwise just apply global default", "else", ":", "config", "[", "key", "]", "=", "self", ".", "_apply_default", "(", "config", "[", "key", "]", ",", "self", ".", "_global_default", ")", "self", ".", "_validate", "(", "config", ")", "return", "config" ]

[ "def", "unsubscribe", "(", "self", ",", "client", ")", ":", "if", "client", "in", "self", ".", "clients", ":", "self", ".", "clients", ".", "remove", "(", "client", ")", "log", "(", "\"Unsubscribed client {} from channel {}\"", ".", "format", "(", "client", ",", "self", ".", "name", ")", ")" ]

[ "def", "create_Container", "(", "client", ",", "id", ")", ":", "print", "(", "\"\\n2.1 Create Collection - Basic\"", ")", "try", ":", "client", ".", "CreateContainer", "(", "database_link", ",", "{", "\"id\"", ":", "id", "}", ")", "print", "(", "'Collection with id \\'{0}\\' created'", ".", "format", "(", "id", ")", ")", "except", "errors", ".", "HTTPFailure", "as", "e", ":", "if", "e", ".", "status_code", "==", "409", ":", "print", "(", "'A collection with id \\'{0}\\' already exists'", ".", "format", "(", "id", ")", ")", "else", ":", "raise", "errors", ".", "HTTPFailure", "(", "e", ".", "status_code", ")", "print", "(", "\"\\n2.2 Create Collection - With custom index policy\"", ")", "try", ":", "coll", "=", "{", "\"id\"", ":", "\"collection_custom_index_policy\"", ",", "\"indexingPolicy\"", ":", "{", "\"indexingMode\"", ":", "\"lazy\"", ",", "\"automatic\"", ":", "False", "}", "}", "collection", "=", "client", ".", "CreateContainer", "(", "database_link", ",", "coll", ")", "print", "(", "'Collection with id \\'{0}\\' created'", ".", "format", "(", "collection", "[", "'id'", "]", ")", ")", "print", "(", "'IndexPolicy Mode - \\'{0}\\''", ".", "format", "(", "collection", "[", "'indexingPolicy'", "]", "[", "'indexingMode'", "]", ")", ")", "print", "(", "'IndexPolicy Automatic - \\'{0}\\''", ".", "format", "(", "collection", "[", "'indexingPolicy'", "]", "[", "'automatic'", "]", ")", ")", "except", "errors", ".", "CosmosError", "as", "e", ":", "if", "e", ".", "status_code", "==", "409", ":", "print", "(", "'A collection with id \\'{0}\\' already exists'", ".", "format", "(", "collection", "[", "'id'", "]", ")", ")", "else", ":", "raise", "errors", ".", "HTTPFailure", "(", "e", ".", "status_code", ")", "print", "(", "\"\\n2.3 Create Collection - With custom offer throughput\"", ")", "try", ":", "coll", "=", "{", "\"id\"", ":", "\"collection_custom_throughput\"", "}", "collection_options", "=", "{", "'offerThroughput'", ":", "400", "}", "collection", "=", "client", ".", "CreateContainer", "(", "database_link", ",", "coll", ",", "collection_options", ")", "print", "(", "'Collection with id \\'{0}\\' created'", ".", "format", "(", "collection", "[", "'id'", "]", ")", ")", "except", "errors", ".", "HTTPFailure", "as", "e", ":", "if", "e", ".", "status_code", "==", "409", ":", "print", "(", "'A collection with id \\'{0}\\' already exists'", ".", "format", "(", "collection", "[", "'id'", "]", ")", ")", "else", ":", "raise", "errors", ".", "HTTPFailure", "(", "e", ".", "status_code", ")", "print", "(", "\"\\n2.4 Create Collection - With Unique keys\"", ")", "try", ":", "coll", "=", "{", "\"id\"", ":", "\"collection_unique_keys\"", ",", "'uniqueKeyPolicy'", ":", "{", "'uniqueKeys'", ":", "[", "{", "'paths'", ":", "[", "'/field1/field2'", ",", "'/field3'", "]", "}", "]", "}", "}", "collection_options", "=", "{", "'offerThroughput'", ":", "400", "}", "collection", "=", "client", ".", "CreateContainer", "(", "database_link", ",", "coll", ",", "collection_options", ")", "unique_key_paths", "=", "collection", "[", "'uniqueKeyPolicy'", "]", "[", "'uniqueKeys'", "]", "[", "0", "]", "[", "'paths'", "]", "print", "(", "'Collection with id \\'{0}\\' created'", ".", "format", "(", "collection", "[", "'id'", "]", ")", ")", "print", "(", "'Unique Key Paths - \\'{0}\\', \\'{1}\\''", ".", "format", "(", "unique_key_paths", "[", "0", "]", ",", "unique_key_paths", "[", "1", "]", ")", ")", "except", "errors", ".", "HTTPFailure", "as", "e", ":", "if", "e", ".", "status_code", "==", "409", ":", "print", "(", "'A collection with id \\'{0}\\' already exists'", ".", "format", "(", "collection", "[", "'id'", "]", ")", ")", "else", ":", "raise", "errors", ".", "HTTPFailure", "(", "e", ".", "status_code", ")", "print", "(", "\"\\n2.5 Create Collection - With Partition key\"", ")", "try", ":", "coll", "=", "{", "\"id\"", ":", "\"collection_partition_key\"", ",", "\"partitionKey\"", ":", "{", "\"paths\"", ":", "[", "\"/field1\"", "]", ",", "\"kind\"", ":", "\"Hash\"", "}", "}", "collection", "=", "client", ".", "CreateContainer", "(", "database_link", ",", "coll", ")", "print", "(", "'Collection with id \\'{0}\\' created'", ".", "format", "(", "collection", "[", "'id'", "]", ")", ")", "except", "errors", ".", "CosmosError", "as", "e", ":", "if", "e", ".", "status_code", "==", "409", ":", "print", "(", "'A collection with id \\'{0}\\' already exists'", ".", "format", "(", "collection", "[", "'id'", "]", ")", ")", "else", ":", "raise", "errors", ".", "HTTPFailure", "(", "e", ".", "status_code", ")" ]

[ "def", "make_gromacs", "(", "simulation", ",", "directory", ",", "clean", "=", "False", ")", ":", "if", "clean", "is", "False", "and", "os", ".", "path", ".", "exists", "(", "directory", ")", ":", "raise", "ValueError", "(", "'Cannot override {}, use option clean=True'", ".", "format", "(", "directory", ")", ")", "else", ":", "shutil", ".", "rmtree", "(", "directory", ",", "ignore_errors", "=", "True", ")", "os", ".", "mkdir", "(", "directory", ")", "# Check custom simulation potential", "if", "simulation", ".", "potential", ".", "intermolecular", ".", "type", "==", "'custom'", ":", "for", "pair", "in", "simulation", ".", "potential", ".", "intermolecular", ".", "special_pairs", ":", "table", "=", "to_table", "(", "simulation", ".", "potential", ".", "intermolecular", ".", "pair_interaction", "(", "*", "pair", ")", ",", "simulation", ".", "cutoff", ")", "fname1", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "'table_{}_{}.xvg'", ".", "format", "(", "pair", "[", "0", "]", ",", "pair", "[", "1", "]", ")", ")", "fname2", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "'table_{}_{}.xvg'", ".", "format", "(", "pair", "[", "1", "]", ",", "pair", "[", "0", "]", ")", ")", "with", "open", "(", "fname1", ",", "'w'", ")", "as", "fd", ":", "fd", ".", "write", "(", "table", ")", "with", "open", "(", "fname2", ",", "'w'", ")", "as", "fd", ":", "fd", ".", "write", "(", "table", ")", "ndx", "=", "{", "'System'", ":", "np", ".", "arange", "(", "simulation", ".", "system", ".", "n_atoms", ",", "dtype", "=", "'int'", ")", "}", "for", "particle", "in", "simulation", ".", "potential", ".", "intermolecular", ".", "particles", ":", "idx", "=", "simulation", ".", "system", ".", "where", "(", "atom_name", "=", "particle", ")", "[", "'atom'", "]", ".", "nonzero", "(", ")", "[", "0", "]", "ndx", "[", "particle", "]", "=", "idx", "with", "open", "(", "os", ".", "path", ".", "join", "(", "directory", ",", "'index.ndx'", ")", ",", "'w'", ")", "as", "fd", ":", "fd", ".", "write", "(", "to_ndx", "(", "ndx", ")", ")", "# Parameter file", "mdpfile", "=", "to_mdp", "(", "simulation", ")", "with", "open", "(", "os", ".", "path", ".", "join", "(", "directory", ",", "'grompp.mdp'", ")", ",", "'w'", ")", "as", "fd", ":", "fd", ".", "write", "(", "mdpfile", ")", "# Topology file", "topfile", "=", "to_top", "(", "simulation", ".", "system", ",", "simulation", ".", "potential", ")", "with", "open", "(", "os", ".", "path", ".", "join", "(", "directory", ",", "'topol.top'", ")", ",", "'w'", ")", "as", "fd", ":", "fd", ".", "write", "(", "topfile", ")", "# Simulation file", "datafile", "(", "os", ".", "path", ".", "join", "(", "directory", ",", "'conf.gro'", ")", ",", "'w'", ")", ".", "write", "(", "'system'", ",", "simulation", ".", "system", ")", "return", "directory" ]

[ "def", "from_xarray", "(", "cls", ",", "arr", ":", "\"xarray.Dataset\"", ")", "->", "\"Histogram1D\"", ":", "kwargs", "=", "{", "'frequencies'", ":", "arr", "[", "\"frequencies\"", "]", ",", "'binning'", ":", "arr", "[", "\"bins\"", "]", ",", "'errors2'", ":", "arr", "[", "\"errors2\"", "]", ",", "'overflow'", ":", "arr", ".", "attrs", "[", "\"overflow\"", "]", ",", "'underflow'", ":", "arr", ".", "attrs", "[", "\"underflow\"", "]", ",", "'keep_missed'", ":", "arr", ".", "attrs", "[", "\"keep_missed\"", "]", "}", "# TODO: Add stats", "return", "cls", "(", "*", "*", "kwargs", ")" ]

[ "def", "normalized_mean_square_error", "(", "output", ",", "target", ",", "name", "=", "\"normalized_mean_squared_error_loss\"", ")", ":", "# with tf.name_scope(\"normalized_mean_squared_error_loss\"):", "if", "output", ".", "get_shape", "(", ")", ".", "ndims", "==", "2", ":", "# [batch_size, n_feature]", "nmse_a", "=", "tf", ".", "sqrt", "(", "tf", ".", "reduce_sum", "(", "tf", ".", "squared_difference", "(", "output", ",", "target", ")", ",", "axis", "=", "1", ")", ")", "nmse_b", "=", "tf", ".", "sqrt", "(", "tf", ".", "reduce_sum", "(", "tf", ".", "square", "(", "target", ")", ",", "axis", "=", "1", ")", ")", "elif", "output", ".", "get_shape", "(", ")", ".", "ndims", "==", "3", ":", "# [batch_size, w, h]", "nmse_a", "=", "tf", ".", "sqrt", "(", "tf", ".", "reduce_sum", "(", "tf", ".", "squared_difference", "(", "output", ",", "target", ")", ",", "axis", "=", "[", "1", ",", "2", "]", ")", ")", "nmse_b", "=", "tf", ".", "sqrt", "(", "tf", ".", "reduce_sum", "(", "tf", ".", "square", "(", "target", ")", ",", "axis", "=", "[", "1", ",", "2", "]", ")", ")", "elif", "output", ".", "get_shape", "(", ")", ".", "ndims", "==", "4", ":", "# [batch_size, w, h, c]", "nmse_a", "=", "tf", ".", "sqrt", "(", "tf", ".", "reduce_sum", "(", "tf", ".", "squared_difference", "(", "output", ",", "target", ")", ",", "axis", "=", "[", "1", ",", "2", ",", "3", "]", ")", ")", "nmse_b", "=", "tf", ".", "sqrt", "(", "tf", ".", "reduce_sum", "(", "tf", ".", "square", "(", "target", ")", ",", "axis", "=", "[", "1", ",", "2", ",", "3", "]", ")", ")", "nmse", "=", "tf", ".", "reduce_mean", "(", "nmse_a", "/", "nmse_b", ",", "name", "=", "name", ")", "return", "nmse" ]

[ "def", "_increment_flaky_attribute", "(", "cls", ",", "test_item", ",", "flaky_attribute", ")", ":", "cls", ".", "_set_flaky_attribute", "(", "test_item", ",", "flaky_attribute", ",", "cls", ".", "_get_flaky_attribute", "(", "test_item", ",", "flaky_attribute", ")", "+", "1", ")" ]

[ "def", "set_names", "(", "self", ",", "names", ")", ":", "assert_is_type", "(", "names", ",", "[", "str", "]", ")", "assert_satisfies", "(", "names", ",", "len", "(", "names", ")", "==", "self", ".", "ncol", ")", "self", ".", "_ex", "=", "ExprNode", "(", "\"colnames=\"", ",", "self", ",", "range", "(", "self", ".", "ncol", ")", ",", "names", ")", "# Update-in-place, but still lazy", "return", "self" ]

[ "def", "get_cds_time", "(", "days", ",", "msecs", ")", ":", "return", "datetime", "(", "1958", ",", "1", ",", "1", ")", "+", "timedelta", "(", "days", "=", "float", "(", "days", ")", ",", "milliseconds", "=", "float", "(", "msecs", ")", ")" ]

[ "def", "update_score_summary", "(", "sender", ",", "*", "*", "kwargs", ")", ":", "score", "=", "kwargs", "[", "'instance'", "]", "try", ":", "score_summary", "=", "ScoreSummary", ".", "objects", ".", "get", "(", "student_item", "=", "score", ".", "student_item", ")", "score_summary", ".", "latest", "=", "score", "# A score with the \"reset\" flag set will always replace the current highest score", "if", "score", ".", "reset", ":", "score_summary", ".", "highest", "=", "score", "# The conversion to a float may return None if points possible is zero", "# In Python, None is always less than an integer, so any score", "# with non-null points possible will take precedence.", "elif", "score", ".", "to_float", "(", ")", ">", "score_summary", ".", "highest", ".", "to_float", "(", ")", ":", "score_summary", ".", "highest", "=", "score", "score_summary", ".", "save", "(", ")", "except", "ScoreSummary", ".", "DoesNotExist", ":", "ScoreSummary", ".", "objects", ".", "create", "(", "student_item", "=", "score", ".", "student_item", ",", "highest", "=", "score", ",", "latest", "=", "score", ",", ")", "except", "DatabaseError", "as", "err", ":", "logger", ".", "exception", "(", "u\"Error while updating score summary for student item {}\"", ".", "format", "(", "score", ".", "student_item", ")", ")" ]

[ "def", "scene_remove", "(", "frames", ")", ":", "# \"scene.rm\" <scene_id>", "reader", "=", "MessageReader", "(", "frames", ")", "results", "=", "reader", ".", "string", "(", "\"command\"", ")", ".", "uint32", "(", "\"scene_id\"", ")", ".", "assert_end", "(", ")", ".", "get", "(", ")", "if", "results", ".", "command", "!=", "\"scene.rm\"", ":", "raise", "MessageParserError", "(", "\"Command is not 'scene.rm'\"", ")", "return", "(", "results", ".", "scene_id", ",", ")" ]

[ "def", "check_edge", "(", "self", ",", "name1", ",", "name2", ")", ":", "if", "self", ".", "graph_type", "is", "DIRECTED_GRAPH", ":", "return", "(", "name1", ",", "name2", ")", "in", "self", ".", "edge_attr", "else", ":", "return", "(", "(", "name1", ",", "name2", ")", "in", "self", ".", "edge_attr", "or", "(", "name2", ",", "name1", ")", "in", "self", ".", "edge_attr", ")" ]

[ "def", "plot_txn_time_hist", "(", "transactions", ",", "bin_minutes", "=", "5", ",", "tz", "=", "'America/New_York'", ",", "ax", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "ax", "is", "None", ":", "ax", "=", "plt", ".", "gca", "(", ")", "txn_time", "=", "transactions", ".", "copy", "(", ")", "txn_time", ".", "index", "=", "txn_time", ".", "index", ".", "tz_convert", "(", "pytz", ".", "timezone", "(", "tz", ")", ")", "txn_time", ".", "index", "=", "txn_time", ".", "index", ".", "map", "(", "lambda", "x", ":", "x", ".", "hour", "*", "60", "+", "x", ".", "minute", ")", "txn_time", "[", "'trade_value'", "]", "=", "(", "txn_time", ".", "amount", "*", "txn_time", ".", "price", ")", ".", "abs", "(", ")", "txn_time", "=", "txn_time", ".", "groupby", "(", "level", "=", "0", ")", ".", "sum", "(", ")", ".", "reindex", "(", "index", "=", "range", "(", "570", ",", "961", ")", ")", "txn_time", ".", "index", "=", "(", "txn_time", ".", "index", "/", "bin_minutes", ")", ".", "astype", "(", "int", ")", "*", "bin_minutes", "txn_time", "=", "txn_time", ".", "groupby", "(", "level", "=", "0", ")", ".", "sum", "(", ")", "txn_time", "[", "'time_str'", "]", "=", "txn_time", ".", "index", ".", "map", "(", "lambda", "x", ":", "str", "(", "datetime", ".", "time", "(", "int", "(", "x", "/", "60", ")", ",", "x", "%", "60", ")", ")", "[", ":", "-", "3", "]", ")", "trade_value_sum", "=", "txn_time", ".", "trade_value", ".", "sum", "(", ")", "txn_time", ".", "trade_value", "=", "txn_time", ".", "trade_value", ".", "fillna", "(", "0", ")", "/", "trade_value_sum", "ax", ".", "bar", "(", "txn_time", ".", "index", ",", "txn_time", ".", "trade_value", ",", "width", "=", "bin_minutes", ",", "*", "*", "kwargs", ")", "ax", ".", "set_xlim", "(", "570", ",", "960", ")", "ax", ".", "set_xticks", "(", "txn_time", ".", "index", "[", ":", ":", "int", "(", "30", "/", "bin_minutes", ")", "]", ")", "ax", ".", "set_xticklabels", "(", "txn_time", ".", "time_str", "[", ":", ":", "int", "(", "30", "/", "bin_minutes", ")", "]", ")", "ax", ".", "set_title", "(", "'Transaction time distribution'", ")", "ax", ".", "set_ylabel", "(", "'Proportion'", ")", "ax", ".", "set_xlabel", "(", "''", ")", "return", "ax" ]

[ "def", "_wrap", "(", "self", ",", "line", ":", "str", ")", "->", "str", ":", "wrap_mode", "=", "self", ".", "config", "[", "'multi_line_output'", "]", "if", "len", "(", "line", ")", ">", "self", ".", "config", "[", "'line_length'", "]", "and", "wrap_mode", "!=", "WrapModes", ".", "NOQA", ":", "line_without_comment", "=", "line", "comment", "=", "None", "if", "'#'", "in", "line", ":", "line_without_comment", ",", "comment", "=", "line", ".", "split", "(", "'#'", ",", "1", ")", "for", "splitter", "in", "(", "\"import \"", ",", "\".\"", ",", "\"as \"", ")", ":", "exp", "=", "r\"\\b\"", "+", "re", ".", "escape", "(", "splitter", ")", "+", "r\"\\b\"", "if", "re", ".", "search", "(", "exp", ",", "line_without_comment", ")", "and", "not", "line_without_comment", ".", "strip", "(", ")", ".", "startswith", "(", "splitter", ")", ":", "line_parts", "=", "re", ".", "split", "(", "exp", ",", "line_without_comment", ")", "if", "comment", ":", "line_parts", "[", "-", "1", "]", "=", "'{0}#{1}'", ".", "format", "(", "line_parts", "[", "-", "1", "]", ",", "comment", ")", "next_line", "=", "[", "]", "while", "(", "len", "(", "line", ")", "+", "2", ")", ">", "(", "self", ".", "config", "[", "'wrap_length'", "]", "or", "self", ".", "config", "[", "'line_length'", "]", ")", "and", "line_parts", ":", "next_line", ".", "append", "(", "line_parts", ".", "pop", "(", ")", ")", "line", "=", "splitter", ".", "join", "(", "line_parts", ")", "if", "not", "line", ":", "line", "=", "next_line", ".", "pop", "(", ")", "cont_line", "=", "self", ".", "_wrap", "(", "self", ".", "config", "[", "'indent'", "]", "+", "splitter", ".", "join", "(", "next_line", ")", ".", "lstrip", "(", ")", ")", "if", "self", ".", "config", "[", "'use_parentheses'", "]", ":", "output", "=", "\"{0}{1}({2}{3}{4}{5})\"", ".", "format", "(", "line", ",", "splitter", ",", "self", ".", "line_separator", ",", "cont_line", ",", "\",\"", "if", "self", ".", "config", "[", "'include_trailing_comma'", "]", "else", "\"\"", ",", "self", ".", "line_separator", "if", "wrap_mode", "in", "{", "WrapModes", ".", "VERTICAL_HANGING_INDENT", ",", "WrapModes", ".", "VERTICAL_GRID_GROUPED", "}", "else", "\"\"", ")", "lines", "=", "output", ".", "split", "(", "self", ".", "line_separator", ")", "if", "self", ".", "config", "[", "'comment_prefix'", "]", "in", "lines", "[", "-", "1", "]", "and", "lines", "[", "-", "1", "]", ".", "endswith", "(", "')'", ")", ":", "line", ",", "comment", "=", "lines", "[", "-", "1", "]", ".", "split", "(", "self", ".", "config", "[", "'comment_prefix'", "]", ",", "1", ")", "lines", "[", "-", "1", "]", "=", "line", "+", "')'", "+", "self", ".", "config", "[", "'comment_prefix'", "]", "+", "comment", "[", ":", "-", "1", "]", "return", "self", ".", "line_separator", ".", "join", "(", "lines", ")", "return", "\"{0}{1}\\\\{2}{3}\"", ".", "format", "(", "line", ",", "splitter", ",", "self", ".", "line_separator", ",", "cont_line", ")", "elif", "len", "(", "line", ")", ">", "self", ".", "config", "[", "'line_length'", "]", "and", "wrap_mode", "==", "settings", ".", "WrapModes", ".", "NOQA", ":", "if", "\"# NOQA\"", "not", "in", "line", ":", "return", "\"{0}{1} NOQA\"", ".", "format", "(", "line", ",", "self", ".", "config", "[", "'comment_prefix'", "]", ")", "return", "line" ]

[ "def", "discard", "(", "self", ",", "key", ")", ":", "if", "key", "in", "self", ".", "map", ":", "key", ",", "prev", ",", "next_item", "=", "self", ".", "map", ".", "pop", "(", "key", ")", "prev", "[", "2", "]", "=", "next_item", "next_item", "[", "1", "]", "=", "prev" ]

[ "def", "connect", "(", "self", ",", "f", ",", "t", ")", ":", "if", "t", "not", "in", "self", ".", "_vertices", ":", "raise", "KeyError", "(", "t", ")", "self", ".", "_forwards", "[", "f", "]", ".", "add", "(", "t", ")", "self", ".", "_backwards", "[", "t", "]", ".", "add", "(", "f", ")" ]

[ "def", "predict", "(", "self", ",", "test_data", ",", "custom_metric", "=", "None", ",", "custom_metric_func", "=", "None", ")", ":", "# Upload evaluation function into DKV", "if", "custom_metric", ":", "assert_satisfies", "(", "custom_metric_func", ",", "custom_metric_func", "is", "None", ",", "\"The argument 'eval_func_ref' cannot be specified when eval_func is specified, \"", ")", "eval_func_ref", "=", "h2o", ".", "upload_custom_metric", "(", "custom_metric", ")", "if", "not", "isinstance", "(", "test_data", ",", "h2o", ".", "H2OFrame", ")", ":", "raise", "ValueError", "(", "\"test_data must be an instance of H2OFrame\"", ")", "j", "=", "H2OJob", "(", "h2o", ".", "api", "(", "\"POST /4/Predictions/models/%s/frames/%s\"", "%", "(", "self", ".", "model_id", ",", "test_data", ".", "frame_id", ")", ",", "data", "=", "{", "'custom_metric_func'", ":", "custom_metric_func", "}", ")", ",", "self", ".", "_model_json", "[", "\"algo\"", "]", "+", "\" prediction\"", ")", "j", ".", "poll", "(", ")", "return", "h2o", ".", "get_frame", "(", "j", ".", "dest_key", ")" ]

[ "def", "formfield_for_manytomany", "(", "self", ",", "db_field", ",", "request", ",", "*", "*", "kwargs", ")", ":", "if", "db_field", ".", "name", "==", "'authors'", ":", "kwargs", "[", "'queryset'", "]", "=", "Author", ".", "objects", ".", "filter", "(", "Q", "(", "is_staff", "=", "True", ")", "|", "Q", "(", "entries__isnull", "=", "False", ")", ")", ".", "distinct", "(", ")", "return", "super", "(", "EntryAdmin", ",", "self", ")", ".", "formfield_for_manytomany", "(", "db_field", ",", "request", ",", "*", "*", "kwargs", ")" ]

[ "def", "patch", "(", "*", "module_names", ")", ":", "if", "not", "module_names", ":", "module_names", "=", "_patchers", ".", "keys", "(", ")", "log", ".", "info", "(", "\"monkey-patching in-place (%d modules)\"", "%", "len", "(", "module_names", ")", ")", "for", "module_name", "in", "module_names", ":", "if", "module_name", "not", "in", "_patchers", ":", "raise", "ValueError", "(", "\"'%s' is not greenhouse-patchable\"", "%", "module_name", ")", "for", "module_name", "in", "module_names", ":", "if", "module_name", "in", "sys", ".", "modules", ":", "module", "=", "sys", ".", "modules", "[", "module_name", "]", "else", ":", "module", "=", "__import__", "(", "module_name", ",", "{", "}", ",", "{", "}", ",", "module_name", ".", "rsplit", "(", "\".\"", ",", "1", ")", "[", "0", "]", ")", "for", "attr", ",", "patch", "in", "_patchers", "[", "module_name", "]", ".", "items", "(", ")", ":", "setattr", "(", "module", ",", "attr", ",", "patch", ")" ]

[ "def", "istextfile", "(", "fname", ",", "blocksize", "=", "512", ")", ":", "with", "open", "(", "fname", ",", "\"rb\"", ")", "as", "fobj", ":", "block", "=", "fobj", ".", "read", "(", "blocksize", ")", "if", "not", "block", ":", "# An empty file is considered a valid text file", "return", "True", "if", "b\"\\x00\"", "in", "block", ":", "# Files with null bytes are binary", "return", "False", "# Use translate's 'deletechars' argument to efficiently remove all", "# occurrences of TEXT_CHARS from the block", "nontext", "=", "block", ".", "translate", "(", "None", ",", "TEXT_CHARS", ")", "return", "float", "(", "len", "(", "nontext", ")", ")", "/", "len", "(", "block", ")", "<=", "0.30" ]

[ "def", "command_help_long", "(", "self", ")", ":", "indent", "=", "\" \"", "*", "2", "# replace with current_indent", "help", "=", "\"Command must be one of:\\n\"", "for", "action_name", "in", "self", ".", "parser", ".", "valid_commands", ":", "help", "+=", "\"%s%-10s %-70s\\n\"", "%", "(", "indent", ",", "action_name", ",", "self", ".", "parser", ".", "commands", "[", "action_name", "]", ".", "desc_short", ".", "capitalize", "(", ")", ")", "help", "+=", "'\\nSee \\'%s help COMMAND\\' for help and information on a command'", "%", "self", ".", "parser", ".", "prog", "return", "help" ]

[ "def", "lint_fileset", "(", "*", "dirnames", ",", "*", "*", "kwargs", ")", ":", "try", ":", "rc_filename", "=", "kwargs", "[", "'rc_filename'", "]", "description", "=", "kwargs", "[", "'description'", "]", "if", "len", "(", "kwargs", ")", "!=", "2", ":", "raise", "KeyError", "except", "KeyError", ":", "raise", "KeyError", "(", "_LINT_FILESET_MSG", ")", "pylint_shell_command", "=", "[", "'pylint'", ",", "'--rcfile'", ",", "rc_filename", "]", "pylint_shell_command", ".", "extend", "(", "dirnames", ")", "status_code", "=", "subprocess", ".", "call", "(", "pylint_shell_command", ")", "if", "status_code", "!=", "0", ":", "error_message", "=", "_ERROR_TEMPLATE", ".", "format", "(", "description", ",", "status_code", ")", "print", "(", "error_message", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "status_code", ")" ]

[ "def", "getAsWkt", "(", "self", ",", "session", ")", ":", "statement", "=", "\"\"\"\n SELECT ST_AsText({0}) AS wkt\n FROM {1}\n WHERE id={2};\n \"\"\"", ".", "format", "(", "self", ".", "geometryColumnName", ",", "self", ".", "tableName", ",", "self", ".", "id", ")", "result", "=", "session", ".", "execute", "(", "statement", ")", "for", "row", "in", "result", ":", "return", "row", ".", "wkt" ]

[ "def", "clone", "(", "self", ",", "choices", ")", ":", "return", "self", ".", "__class__", "(", "self", ".", "name", ",", "choices", ",", "self", ".", "label", ",", "self", ".", "description", ",", "self", ".", "multiple", ",", "self", ".", "viewFactory", ")" ]

[ "def", "kernel_matrix_xX", "(", "svm_model", ",", "original_x", ",", "original_X", ")", ":", "if", "(", "svm_model", ".", "svm_kernel", "==", "'polynomial_kernel'", "or", "svm_model", ".", "svm_kernel", "==", "'soft_polynomial_kernel'", ")", ":", "K", "=", "(", "svm_model", ".", "zeta", "+", "svm_model", ".", "gamma", "*", "np", ".", "dot", "(", "original_x", ",", "original_X", ".", "T", ")", ")", "**", "svm_model", ".", "Q", "elif", "(", "svm_model", ".", "svm_kernel", "==", "'gaussian_kernel'", "or", "svm_model", ".", "svm_kernel", "==", "'soft_gaussian_kernel'", ")", ":", "K", "=", "np", ".", "exp", "(", "-", "svm_model", ".", "gamma", "*", "(", "cdist", "(", "original_X", ",", "np", ".", "atleast_2d", "(", "original_x", ")", ",", "'euclidean'", ")", ".", "T", "**", "2", ")", ")", ".", "ravel", "(", ")", "return", "K" ]

[ "def", "long_banner", "(", "self", ")", ":", "# Default banner", "try", ":", "from", "IPython", ".", "core", ".", "usage", "import", "quick_guide", "except", "Exception", ":", "quick_guide", "=", "''", "banner_parts", "=", "[", "'Python %s\\n'", "%", "self", ".", "interpreter_versions", "[", "'python_version'", "]", ",", "'Type \"copyright\", \"credits\" or \"license\" for more information.\\n\\n'", ",", "'IPython %s -- An enhanced Interactive Python.\\n'", "%", "self", ".", "interpreter_versions", "[", "'ipython_version'", "]", ",", "quick_guide", "]", "banner", "=", "''", ".", "join", "(", "banner_parts", ")", "# Pylab additions", "pylab_o", "=", "self", ".", "additional_options", "[", "'pylab'", "]", "autoload_pylab_o", "=", "self", ".", "additional_options", "[", "'autoload_pylab'", "]", "mpl_installed", "=", "programs", ".", "is_module_installed", "(", "'matplotlib'", ")", "if", "mpl_installed", "and", "(", "pylab_o", "and", "autoload_pylab_o", ")", ":", "pylab_message", "=", "(", "\"\\nPopulating the interactive namespace from \"", "\"numpy and matplotlib\\n\"", ")", "banner", "=", "banner", "+", "pylab_message", "# Sympy additions", "sympy_o", "=", "self", ".", "additional_options", "[", "'sympy'", "]", "if", "sympy_o", ":", "lines", "=", "\"\"\"\nThese commands were executed:\n>>> from __future__ import division\n>>> from sympy import *\n>>> x, y, z, t = symbols('x y z t')\n>>> k, m, n = symbols('k m n', integer=True)\n>>> f, g, h = symbols('f g h', cls=Function)\n\"\"\"", "banner", "=", "banner", "+", "lines", "if", "(", "pylab_o", "and", "sympy_o", ")", ":", "lines", "=", "\"\"\"\nWarning: pylab (numpy and matplotlib) and symbolic math (sympy) are both \nenabled at the same time. Some pylab functions are going to be overrided by \nthe sympy module (e.g. plot)\n\"\"\"", "banner", "=", "banner", "+", "lines", "return", "banner" ]

[ "def", "add_scalebar", "(", "ax", ",", "matchx", "=", "True", ",", "matchy", "=", "True", ",", "hidex", "=", "True", ",", "hidey", "=", "True", ",", "unitsx", "=", "''", ",", "unitsy", "=", "''", ",", "scalex", "=", "1", ",", "scaley", "=", "1", ",", "*", "*", "kwargs", ")", ":", "def", "f", "(", "axis", ")", ":", "l", "=", "axis", ".", "get_majorticklocs", "(", ")", "return", "len", "(", "l", ")", ">", "1", "and", "(", "l", "[", "1", "]", "-", "l", "[", "0", "]", ")", "if", "matchx", ":", "kwargs", "[", "'sizex'", "]", "=", "f", "(", "ax", ".", "xaxis", ")", "if", "matchy", ":", "kwargs", "[", "'sizey'", "]", "=", "f", "(", "ax", ".", "yaxis", ")", "if", "'labelx'", "not", "in", "kwargs", "or", "kwargs", "[", "'labelx'", "]", "is", "None", ":", "kwargs", "[", "'labelx'", "]", "=", "'%.3g %s'", "%", "(", "kwargs", "[", "'sizex'", "]", "*", "scalex", ",", "unitsx", ")", "if", "'labely'", "not", "in", "kwargs", "or", "kwargs", "[", "'labely'", "]", "is", "None", ":", "kwargs", "[", "'labely'", "]", "=", "'%.3g %s'", "%", "(", "kwargs", "[", "'sizey'", "]", "*", "scaley", ",", "unitsy", ")", "sb", "=", "AnchoredScaleBar", "(", "ax", ".", "transData", ",", "*", "*", "kwargs", ")", "ax", ".", "add_artist", "(", "sb", ")", "if", "hidex", ":", "ax", ".", "xaxis", ".", "set_visible", "(", "False", ")", "if", "hidey", ":", "ax", ".", "yaxis", ".", "set_visible", "(", "False", ")", "if", "hidex", "and", "hidey", ":", "ax", ".", "set_frame_on", "(", "False", ")", "return", "sb" ]

[ "def", "get_option_type", "(", "self", ",", "key", ",", "subkey", ")", ":", "key", ",", "subkey", "=", "_lower_keys", "(", "key", ",", "subkey", ")", "_entry_must_exist", "(", "self", ".", "gc", ",", "key", ",", "subkey", ")", "return", "self", ".", "gc", "[", "(", "self", ".", "gc", "[", "\"k1\"", "]", "==", "key", ")", "&", "(", "self", ".", "gc", "[", "\"k2\"", "]", "==", "subkey", ")", "]", "[", "\"type\"", "]", ".", "values", "[", "0", "]" ]

[ "def", "convert", "(", "self", ",", "value", ",", "param", ",", "ctx", ")", ":", "self", ".", "gandi", "=", "ctx", ".", "obj", "value", "=", "click", ".", "Choice", ".", "convert", "(", "self", ",", "value", ",", "param", ",", "ctx", ")", "return", "int", "(", "value", ")" ]

[ "def", "derivative_factory", "(", "name", ")", ":", "if", "name", "==", "'sin'", ":", "def", "derivative", "(", "self", ",", "point", ")", ":", "\"\"\"Return the derivative operator.\"\"\"", "return", "MultiplyOperator", "(", "cos", "(", "self", ".", "domain", ")", "(", "point", ")", ")", "elif", "name", "==", "'cos'", ":", "def", "derivative", "(", "self", ",", "point", ")", ":", "\"\"\"Return the derivative operator.\"\"\"", "point", "=", "self", ".", "domain", ".", "element", "(", "point", ")", "return", "MultiplyOperator", "(", "-", "sin", "(", "self", ".", "domain", ")", "(", "point", ")", ")", "elif", "name", "==", "'tan'", ":", "def", "derivative", "(", "self", ",", "point", ")", ":", "\"\"\"Return the derivative operator.\"\"\"", "return", "MultiplyOperator", "(", "1", "+", "self", "(", "point", ")", "**", "2", ")", "elif", "name", "==", "'sqrt'", ":", "def", "derivative", "(", "self", ",", "point", ")", ":", "\"\"\"Return the derivative operator.\"\"\"", "return", "MultiplyOperator", "(", "0.5", "/", "self", "(", "point", ")", ")", "elif", "name", "==", "'square'", ":", "def", "derivative", "(", "self", ",", "point", ")", ":", "\"\"\"Return the derivative operator.\"\"\"", "point", "=", "self", ".", "domain", ".", "element", "(", "point", ")", "return", "MultiplyOperator", "(", "2.0", "*", "point", ")", "elif", "name", "==", "'log'", ":", "def", "derivative", "(", "self", ",", "point", ")", ":", "\"\"\"Return the derivative operator.\"\"\"", "point", "=", "self", ".", "domain", ".", "element", "(", "point", ")", "return", "MultiplyOperator", "(", "1.0", "/", "point", ")", "elif", "name", "==", "'exp'", ":", "def", "derivative", "(", "self", ",", "point", ")", ":", "\"\"\"Return the derivative operator.\"\"\"", "return", "MultiplyOperator", "(", "self", "(", "point", ")", ")", "elif", "name", "==", "'reciprocal'", ":", "def", "derivative", "(", "self", ",", "point", ")", ":", "\"\"\"Return the derivative operator.\"\"\"", "point", "=", "self", ".", "domain", ".", "element", "(", "point", ")", "return", "MultiplyOperator", "(", "-", "self", "(", "point", ")", "**", "2", ")", "elif", "name", "==", "'sinh'", ":", "def", "derivative", "(", "self", ",", "point", ")", ":", "\"\"\"Return the derivative operator.\"\"\"", "point", "=", "self", ".", "domain", ".", "element", "(", "point", ")", "return", "MultiplyOperator", "(", "cosh", "(", "self", ".", "domain", ")", "(", "point", ")", ")", "elif", "name", "==", "'cosh'", ":", "def", "derivative", "(", "self", ",", "point", ")", ":", "\"\"\"Return the derivative operator.\"\"\"", "return", "MultiplyOperator", "(", "sinh", "(", "self", ".", "domain", ")", "(", "point", ")", ")", "else", ":", "# Fallback to default", "derivative", "=", "Operator", ".", "derivative", "return", "derivative" ]

[ "def", "_ensure_annotations", "(", "dashboard", ")", ":", "if", "'annotation_tags'", "not", "in", "dashboard", ":", "return", "tags", "=", "dashboard", "[", "'annotation_tags'", "]", "annotations", "=", "{", "'enable'", ":", "True", ",", "'list'", ":", "[", "]", ",", "}", "for", "tag", "in", "tags", ":", "annotations", "[", "'list'", "]", ".", "append", "(", "{", "'datasource'", ":", "\"graphite\"", ",", "'enable'", ":", "False", ",", "'iconColor'", ":", "\"#C0C6BE\"", ",", "'iconSize'", ":", "13", ",", "'lineColor'", ":", "\"rgba(255, 96, 96, 0.592157)\"", ",", "'name'", ":", "tag", ",", "'showLine'", ":", "True", ",", "'tags'", ":", "tag", ",", "}", ")", "del", "dashboard", "[", "'annotation_tags'", "]", "dashboard", "[", "'annotations'", "]", "=", "annotations" ]

[ "def", "find_file_match", "(", "folder_path", ",", "regex", "=", "''", ")", ":", "outlist", "=", "[", "]", "for", "root", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "folder_path", ")", ":", "outlist", ".", "extend", "(", "[", "os", ".", "path", ".", "join", "(", "root", ",", "f", ")", "for", "f", "in", "files", "if", "re", ".", "match", "(", "regex", ",", "f", ")", "]", ")", "return", "outlist" ]

[ "def", "split_grads_by_size", "(", "threshold_size", ",", "device_grads", ")", ":", "small_grads", "=", "[", "]", "large_grads", "=", "[", "]", "for", "dl", "in", "device_grads", ":", "small_dl", "=", "[", "]", "large_dl", "=", "[", "]", "for", "(", "g", ",", "v", ")", "in", "dl", ":", "tensor_size", "=", "g", ".", "get_shape", "(", ")", ".", "num_elements", "(", ")", "if", "tensor_size", "<=", "threshold_size", ":", "small_dl", ".", "append", "(", "[", "g", ",", "v", "]", ")", "else", ":", "large_dl", ".", "append", "(", "[", "g", ",", "v", "]", ")", "if", "small_dl", ":", "small_grads", ".", "append", "(", "small_dl", ")", "if", "large_dl", ":", "large_grads", ".", "append", "(", "large_dl", ")", "return", "small_grads", ",", "large_grads" ]

[ "def", "mod_run_check", "(", "cmd_kwargs", ",", "onlyif", ",", "unless", ",", "creates", ")", ":", "# never use VT for onlyif/unless executions because this will lead", "# to quote problems", "cmd_kwargs", "=", "copy", ".", "deepcopy", "(", "cmd_kwargs", ")", "cmd_kwargs", "[", "'use_vt'", "]", "=", "False", "cmd_kwargs", "[", "'bg'", "]", "=", "False", "if", "onlyif", "is", "not", "None", ":", "if", "isinstance", "(", "onlyif", ",", "six", ".", "string_types", ")", ":", "cmd", "=", "__salt__", "[", "'cmd.retcode'", "]", "(", "onlyif", ",", "ignore_retcode", "=", "True", ",", "python_shell", "=", "True", ",", "*", "*", "cmd_kwargs", ")", "log", ".", "debug", "(", "'Last command return code: %s'", ",", "cmd", ")", "if", "cmd", "!=", "0", ":", "return", "{", "'comment'", ":", "'onlyif condition is false'", ",", "'skip_watch'", ":", "True", ",", "'result'", ":", "True", "}", "elif", "isinstance", "(", "onlyif", ",", "list", ")", ":", "for", "entry", "in", "onlyif", ":", "cmd", "=", "__salt__", "[", "'cmd.retcode'", "]", "(", "entry", ",", "ignore_retcode", "=", "True", ",", "python_shell", "=", "True", ",", "*", "*", "cmd_kwargs", ")", "log", ".", "debug", "(", "'Last command \\'%s\\' return code: %s'", ",", "entry", ",", "cmd", ")", "if", "cmd", "!=", "0", ":", "return", "{", "'comment'", ":", "'onlyif condition is false: {0}'", ".", "format", "(", "entry", ")", ",", "'skip_watch'", ":", "True", ",", "'result'", ":", "True", "}", "elif", "not", "isinstance", "(", "onlyif", ",", "six", ".", "string_types", ")", ":", "if", "not", "onlyif", ":", "log", ".", "debug", "(", "'Command not run: onlyif did not evaluate to string_type'", ")", "return", "{", "'comment'", ":", "'onlyif condition is false'", ",", "'skip_watch'", ":", "True", ",", "'result'", ":", "True", "}", "if", "unless", "is", "not", "None", ":", "if", "isinstance", "(", "unless", ",", "six", ".", "string_types", ")", ":", "cmd", "=", "__salt__", "[", "'cmd.retcode'", "]", "(", "unless", ",", "ignore_retcode", "=", "True", ",", "python_shell", "=", "True", ",", "*", "*", "cmd_kwargs", ")", "log", ".", "debug", "(", "'Last command return code: %s'", ",", "cmd", ")", "if", "cmd", "==", "0", ":", "return", "{", "'comment'", ":", "'unless condition is true'", ",", "'skip_watch'", ":", "True", ",", "'result'", ":", "True", "}", "elif", "isinstance", "(", "unless", ",", "list", ")", ":", "cmd", "=", "[", "]", "for", "entry", "in", "unless", ":", "cmd", ".", "append", "(", "__salt__", "[", "'cmd.retcode'", "]", "(", "entry", ",", "ignore_retcode", "=", "True", ",", "python_shell", "=", "True", ",", "*", "*", "cmd_kwargs", ")", ")", "log", ".", "debug", "(", "'Last command return code: %s'", ",", "cmd", ")", "if", "all", "(", "[", "c", "==", "0", "for", "c", "in", "cmd", "]", ")", ":", "return", "{", "'comment'", ":", "'unless condition is true'", ",", "'skip_watch'", ":", "True", ",", "'result'", ":", "True", "}", "elif", "not", "isinstance", "(", "unless", ",", "six", ".", "string_types", ")", ":", "if", "unless", ":", "log", ".", "debug", "(", "'Command not run: unless did not evaluate to string_type'", ")", "return", "{", "'comment'", ":", "'unless condition is true'", ",", "'skip_watch'", ":", "True", ",", "'result'", ":", "True", "}", "if", "isinstance", "(", "creates", ",", "six", ".", "string_types", ")", "and", "os", ".", "path", ".", "exists", "(", "creates", ")", ":", "return", "{", "'comment'", ":", "'{0} exists'", ".", "format", "(", "creates", ")", ",", "'result'", ":", "True", "}", "elif", "isinstance", "(", "creates", ",", "list", ")", "and", "all", "(", "[", "os", ".", "path", ".", "exists", "(", "path", ")", "for", "path", "in", "creates", "]", ")", ":", "return", "{", "'comment'", ":", "'All files in creates exist'", ",", "'result'", ":", "True", "}", "# No reason to stop, return True", "return", "True" ]

[ "def", "compute_grouped_sigma", "(", "ungrouped_sigma", ",", "group_matrix", ")", ":", "group_matrix", "=", "np", ".", "array", "(", "group_matrix", ",", "dtype", "=", "np", ".", "bool", ")", "sigma_masked", "=", "np", ".", "ma", ".", "masked_array", "(", "ungrouped_sigma", "*", "group_matrix", ".", "T", ",", "mask", "=", "(", "group_matrix", "^", "1", ")", ".", "T", ")", "sigma_agg", "=", "np", ".", "ma", ".", "mean", "(", "sigma_masked", ",", "axis", "=", "1", ")", "sigma", "=", "np", ".", "zeros", "(", "group_matrix", ".", "shape", "[", "1", "]", ",", "dtype", "=", "np", ".", "float", ")", "np", ".", "copyto", "(", "sigma", ",", "sigma_agg", ",", "where", "=", "group_matrix", ".", "sum", "(", "axis", "=", "0", ")", "==", "1", ")", "np", ".", "copyto", "(", "sigma", ",", "np", ".", "NAN", ",", "where", "=", "group_matrix", ".", "sum", "(", "axis", "=", "0", ")", "!=", "1", ")", "return", "sigma" ]

[ "def", "parse_cli_args_into", "(", ")", ":", "cli_arg_parser", "=", "argparse", ".", "ArgumentParser", "(", "parents", "=", "[", "AWSArgumentParser", "(", "default_role_session_name", "=", "'aws-autodiscovery-templater'", ")", "]", ")", "main_parser", "=", "cli_arg_parser", ".", "add_argument_group", "(", "'AWS Autodiscovery Templater'", ")", "# template_location = main_parser.add_mutually_exclusive_group(required=True)", "main_parser", ".", "add_argument", "(", "'--template-path'", ",", "help", "=", "'Path to the template to fill variables into.'", ",", "required", "=", "True", ")", "# template_location.add_argument('--template-s3-uri', help='S3 URI to the template to fill variables into.')", "# output = main_parser.add_mutually_exclusive_group(required=True)", "# output.add_argument('--destination-path',", "# help='Destination for the source once the template has been rendered.')", "main_parser", ".", "add_argument", "(", "'--stdout'", ",", "help", "=", "'Prints a json object containing the retrieves resources'", ",", "action", "=", "'store_true'", ",", "default", "=", "False", ",", "required", "=", "True", ")", "main_parser", ".", "add_argument", "(", "'--vpc-ids'", ",", "help", "=", "(", "'Optionally restrict the filtering to a particular list of IPs. '", "'Comma seperated list of vpc-ids.'", ")", ",", "action", "=", "'store_true'", ",", "default", "=", "None", ")", "main_parser", ".", "add_argument", "(", "'--filter'", ",", "help", "=", "(", "'Filter for ec2 instances as defined in http://boto3.readthedocs.org/en/latest/'", "'reference/services/ec2.html#EC2.Client.describe_instances'", ")", ",", "default", "=", "None", ",", "nargs", "=", "'+'", ")", "main_parser", ".", "add_argument", "(", "'--filter-empty'", ",", "help", "=", "(", "'By default, missing values are returned as null to keep private/public ip/hostname'", "'sets of equal length. This removes null values from the filter'", ")", ",", "action", "=", "'store_true'", ",", "default", "=", "False", ")", "return", "cli_arg_parser", ".", "parse_args", "(", "namespace", "=", "TemplateCommand", "(", ")", ")" ]

[ "def", "energy", "(", "self", ",", "strand", ",", "dotparens", ",", "temp", "=", "37.0", ",", "pseudo", "=", "False", ",", "material", "=", "None", ",", "dangles", "=", "'some'", ",", "sodium", "=", "1.0", ",", "magnesium", "=", "0.0", ")", ":", "# Set the material (will be used to set command material flag)", "material", "=", "self", ".", "_set_material", "(", "strand", ",", "material", ")", "# Set up command flags", "cmd_args", "=", "self", ".", "_prep_cmd_args", "(", "temp", ",", "dangles", ",", "material", ",", "pseudo", ",", "sodium", ",", "magnesium", ",", "multi", "=", "False", ")", "# Set up the input file and run the command. Note: no STDOUT", "lines", "=", "[", "str", "(", "strand", ")", ",", "dotparens", "]", "stdout", "=", "self", ".", "_run", "(", "'energy'", ",", "cmd_args", ",", "lines", ")", ".", "split", "(", "'\\n'", ")", "# Return the energy", "return", "float", "(", "stdout", "[", "-", "2", "]", ")" ]

[ "def", "finalize", "(", "self", ",", "*", "*", "kwargs", ")", ":", "self", ".", "set_title", "(", "\"TSNE Projection of {} Documents\"", ".", "format", "(", "self", ".", "n_instances_", ")", ")", "# Remove the ticks", "self", ".", "ax", ".", "set_yticks", "(", "[", "]", ")", "self", ".", "ax", ".", "set_xticks", "(", "[", "]", ")", "# Add the legend outside of the figure box.", "if", "not", "all", "(", "self", ".", "classes_", "==", "np", ".", "array", "(", "[", "self", ".", "NULL_CLASS", "]", ")", ")", ":", "box", "=", "self", ".", "ax", ".", "get_position", "(", ")", "self", ".", "ax", ".", "set_position", "(", "[", "box", ".", "x0", ",", "box", ".", "y0", ",", "box", ".", "width", "*", "0.8", ",", "box", ".", "height", "]", ")", "manual_legend", "(", "self", ",", "self", ".", "classes_", ",", "self", ".", "color_values_", ",", "loc", "=", "'center left'", ",", "bbox_to_anchor", "=", "(", "1", ",", "0.5", ")", ")" ]

[ "def", "H_n", "(", "self", ",", "n", ",", "x", ")", ":", "if", "not", "self", ".", "_interpolation", ":", "n_array", "=", "np", ".", "zeros", "(", "n", "+", "1", ")", "n_array", "[", "n", "]", "=", "1", "return", "self", ".", "hermval", "(", "x", ",", "n_array", ",", "tensor", "=", "False", ")", "# attention, this routine calculates every single hermite polynomial and multiplies it with zero (exept the right one)", "else", ":", "return", "np", ".", "interp", "(", "x", ",", "self", ".", "x_grid", ",", "self", ".", "H_interp", "[", "n", "]", ")" ]

[ "def", "pre_release", "(", "version", ")", ":", "announce", "(", "version", ")", "regen", "(", ")", "changelog", "(", "version", ",", "write_out", "=", "True", ")", "fix_formatting", "(", ")", "msg", "=", "\"Preparing release version {}\"", ".", "format", "(", "version", ")", "check_call", "(", "[", "\"git\"", ",", "\"commit\"", ",", "\"-a\"", ",", "\"-m\"", ",", "msg", "]", ")", "print", "(", ")", "print", "(", "f\"{Fore.CYAN}[generate.pre_release] {Fore.GREEN}All done!\"", ")", "print", "(", ")", "print", "(", "f\"Please push your branch and open a PR.\"", ")" ]

[ "def", "parse_rst_params", "(", "doc", ")", ":", "param_re", "=", "re", ".", "compile", "(", "r\"\"\"^([ \\t]*):param\\ \n (?P<param>\\w+):\\ \n (?P<body>.*\\n(\\1[ \\t]+\\w.*\\n)*)\"\"\"", ",", "re", ".", "MULTILINE", "|", "re", ".", "VERBOSE", ")", "params", "=", "{", "}", "for", "match", "in", "param_re", ".", "finditer", "(", "doc", ")", ":", "parts", "=", "match", ".", "groupdict", "(", ")", "body_lines", "=", "parts", "[", "'body'", "]", ".", "strip", "(", ")", ".", "split", "(", "'\\n'", ")", "params", "[", "parts", "[", "'param'", "]", "]", "=", "' '", ".", "join", "(", "s", ".", "strip", "(", ")", "for", "s", "in", "body_lines", ")", "return", "params" ]

[ "def", "render_flow", "(", "self", ",", "data", ")", ":", "self", ".", "render_tree", "(", "data", ")", "# then reconstruct a new ODT document with the generated content", "for", "status", "in", "self", ".", "__save_output", "(", ")", ":", "yield", "status" ]

[ "def", "dgrep", "(", "pat", ",", "*", "opts", ")", ":", "return", "grep", "(", "pat", ",", "dir", "(", "__main__", ")", "+", "dir", "(", "__main__", ".", "__builtins__", ")", ",", "*", "opts", ")" ]

[ "def", "filter_savitzky_golay", "(", "y", ",", "window_size", "=", "5", ",", "order", "=", "2", ",", "deriv", "=", "0", ",", "rate", "=", "1", ")", ":", "try", ":", "window_size", "=", "np", ".", "abs", "(", "np", ".", "int", "(", "window_size", ")", ")", "order", "=", "np", ".", "abs", "(", "np", ".", "int", "(", "order", ")", ")", "except", "ValueError", ":", "raise", "ValueError", "(", "'window_size and order must be integers'", ")", "if", "window_size", "%", "2", "!=", "1", "or", "window_size", "<", "1", ":", "raise", "ValueError", "(", "'window_size size must be a positive odd number'", ")", "if", "window_size", "<", "order", "+", "2", ":", "raise", "ValueError", "(", "'window_size is too small for the polynomials order'", ")", "order_range", "=", "range", "(", "order", "+", "1", ")", "half_window", "=", "(", "window_size", "-", "1", ")", "//", "2", "# precompute limits", "minimum", "=", "np", ".", "min", "(", "y", ")", "maximum", "=", "np", ".", "max", "(", "y", ")", "# precompute coefficients", "b", "=", "np", ".", "mat", "(", "[", "[", "k", "**", "i", "for", "i", "in", "order_range", "]", "for", "k", "in", "range", "(", "-", "half_window", ",", "half_window", "+", "1", ")", "]", ")", "m", "=", "np", ".", "linalg", ".", "pinv", "(", "b", ")", ".", "A", "[", "deriv", "]", "*", "rate", "**", "deriv", "*", "math", ".", "factorial", "(", "deriv", ")", "# pad the signal at the extremes with values taken from the original signal", "firstvals", "=", "y", "[", "0", "]", "-", "np", ".", "abs", "(", "y", "[", "1", ":", "half_window", "+", "1", "]", "[", ":", ":", "-", "1", "]", "-", "y", "[", "0", "]", ")", "lastvals", "=", "y", "[", "-", "1", "]", "+", "np", ".", "abs", "(", "y", "[", "-", "half_window", "-", "1", ":", "-", "1", "]", "[", ":", ":", "-", "1", "]", "-", "y", "[", "-", "1", "]", ")", "y", "=", "np", ".", "concatenate", "(", "(", "firstvals", ",", "y", ",", "lastvals", ")", ")", "return", "np", ".", "clip", "(", "np", ".", "convolve", "(", "m", "[", ":", ":", "-", "1", "]", ",", "y", ",", "mode", "=", "'valid'", ")", ",", "minimum", ",", "maximum", ",", ")" ]

[ "def", "bottleneck_block_v1", "(", "cnn", ",", "depth", ",", "depth_bottleneck", ",", "stride", ")", ":", "input_layer", "=", "cnn", ".", "top_layer", "in_size", "=", "cnn", ".", "top_size", "name_key", "=", "\"resnet_v1\"", "name", "=", "name_key", "+", "str", "(", "cnn", ".", "counts", "[", "name_key", "]", ")", "cnn", ".", "counts", "[", "name_key", "]", "+=", "1", "with", "tf", ".", "variable_scope", "(", "name", ")", ":", "if", "depth", "==", "in_size", ":", "if", "stride", "==", "1", ":", "shortcut", "=", "input_layer", "else", ":", "shortcut", "=", "cnn", ".", "apool", "(", "1", ",", "1", ",", "stride", ",", "stride", ",", "input_layer", "=", "input_layer", ",", "num_channels_in", "=", "in_size", ")", "else", ":", "shortcut", "=", "cnn", ".", "conv", "(", "depth", ",", "1", ",", "1", ",", "stride", ",", "stride", ",", "activation", "=", "None", ",", "use_batch_norm", "=", "True", ",", "input_layer", "=", "input_layer", ",", "num_channels_in", "=", "in_size", ",", "bias", "=", "None", ")", "cnn", ".", "conv", "(", "depth_bottleneck", ",", "1", ",", "1", ",", "stride", ",", "stride", ",", "input_layer", "=", "input_layer", ",", "num_channels_in", "=", "in_size", ",", "use_batch_norm", "=", "True", ",", "bias", "=", "None", ")", "cnn", ".", "conv", "(", "depth_bottleneck", ",", "3", ",", "3", ",", "1", ",", "1", ",", "mode", "=", "\"SAME_RESNET\"", ",", "use_batch_norm", "=", "True", ",", "bias", "=", "None", ")", "res", "=", "cnn", ".", "conv", "(", "depth", ",", "1", ",", "1", ",", "1", ",", "1", ",", "activation", "=", "None", ",", "use_batch_norm", "=", "True", ",", "bias", "=", "None", ")", "output", "=", "tf", ".", "nn", ".", "relu", "(", "shortcut", "+", "res", ")", "cnn", ".", "top_layer", "=", "output", "cnn", ".", "top_size", "=", "depth" ]

[ "def", "add_info_widget", "(", "self", ",", "widget", ")", ":", "index", "=", "widget", ".", "get_index", "(", ")", "while", "index", "in", "self", ".", "info_widgets", ".", "keys", "(", ")", ":", "index", "+=", "1", "self", ".", "info_widgets", "[", "widget", ".", "get_index", "(", ")", "]", "=", "widget" ]

[ "def", "set", "(", "self", ",", "key", ",", "val", ")", ":", "return", "self", ".", "evolver", "(", ")", ".", "set", "(", "key", ",", "val", ")", ".", "persistent", "(", ")" ]

[ "def", "on_unexpected_error", "(", "e", ")", ":", "# pragma: no cover", "sys", ".", "stderr", ".", "write", "(", "'Unexpected error: {} ({})\\n'", ".", "format", "(", "str", "(", "e", ")", ",", "e", ".", "__class__", ".", "__name__", ")", ")", "sys", ".", "stderr", ".", "write", "(", "'See file slam_error.log for additional details.\\n'", ")", "sys", ".", "exit", "(", "1", ")" ]

[ "def", "make_node", "(", "cls", ",", "id_", ",", "arglist", ",", "lineno", ")", ":", "assert", "isinstance", "(", "arglist", ",", "SymbolARGLIST", ")", "variable", "=", "gl", ".", "SYMBOL_TABLE", ".", "access_array", "(", "id_", ",", "lineno", ")", "if", "variable", "is", "None", ":", "return", "None", "if", "len", "(", "variable", ".", "bounds", ")", "!=", "len", "(", "arglist", ")", ":", "syntax_error", "(", "lineno", ",", "\"Array '%s' has %i dimensions, not %i\"", "%", "(", "variable", ".", "name", ",", "len", "(", "variable", ".", "bounds", ")", ",", "len", "(", "arglist", ")", ")", ")", "return", "None", "# Checks for array subscript range if the subscript is constant", "# e.g. A(1) is a constant subscript access", "for", "i", ",", "b", "in", "zip", "(", "arglist", ",", "variable", ".", "bounds", ")", ":", "btype", "=", "gl", ".", "SYMBOL_TABLE", ".", "basic_types", "[", "gl", ".", "BOUND_TYPE", "]", "lower_bound", "=", "NUMBER", "(", "b", ".", "lower", ",", "type_", "=", "btype", ",", "lineno", "=", "lineno", ")", "i", ".", "value", "=", "BINARY", ".", "make_node", "(", "'MINUS'", ",", "TYPECAST", ".", "make_node", "(", "btype", ",", "i", ".", "value", ",", "lineno", ")", ",", "lower_bound", ",", "lineno", ",", "func", "=", "lambda", "x", ",", "y", ":", "x", "-", "y", ",", "type_", "=", "btype", ")", "if", "is_number", "(", "i", ".", "value", ")", "or", "is_const", "(", "i", ".", "value", ")", ":", "val", "=", "i", ".", "value", ".", "value", "if", "val", "<", "0", "or", "val", ">", "b", ".", "count", ":", "warning", "(", "lineno", ",", "\"Array '%s' subscript out of range\"", "%", "id_", ")", "# Returns the variable entry and the node", "return", "cls", "(", "variable", ",", "arglist", ",", "lineno", ")" ]

[ "def", "delete", "(", "cls", ",", "group", ",", "admin", ")", ":", "with", "db", ".", "session", ".", "begin_nested", "(", ")", ":", "obj", "=", "cls", ".", "query", ".", "filter", "(", "cls", ".", "admin", "==", "admin", ",", "cls", ".", "group", "==", "group", ")", ".", "one", "(", ")", "db", ".", "session", ".", "delete", "(", "obj", ")" ]

[ "def", "trace_incoming_web_request", "(", "self", ",", "webapp_info", ",", "url", ",", "method", ",", "headers", "=", "None", ",", "remote_address", "=", "None", ",", "str_tag", "=", "None", ",", "byte_tag", "=", "None", ")", ":", "assert", "isinstance", "(", "webapp_info", ",", "WebapplicationInfoHandle", ")", "result", "=", "tracers", ".", "IncomingWebRequestTracer", "(", "self", ".", "_nsdk", ",", "self", ".", "_nsdk", ".", "incomingwebrequesttracer_create", "(", "webapp_info", ".", "handle", ",", "url", ",", "method", ")", ")", "if", "not", "result", ":", "return", "result", "try", ":", "if", "headers", ":", "self", ".", "_nsdk", ".", "incomingwebrequesttracer_add_request_headers", "(", "result", ".", "handle", ",", "*", "_get_kvc", "(", "headers", ")", ")", "if", "remote_address", ":", "self", ".", "_nsdk", ".", "incomingwebrequesttracer_set_remote_address", "(", "result", ".", "handle", ",", "remote_address", ")", "self", ".", "_applytag", "(", "result", ",", "str_tag", ",", "byte_tag", ")", "except", ":", "result", ".", "end", "(", ")", "raise", "return", "result" ]

[ "def", "difference", "(", "self", ",", "other", ")", ":", "if", "self", ".", "everything", ":", "raise", "ValueError", "(", "\"Can not remove from everything\"", ")", "elif", "other", ".", "everything", ":", "return", "DiscreteSet", "(", "[", "]", ")", "else", ":", "return", "DiscreteSet", "(", "self", ".", "elements", ".", "difference", "(", "other", ".", "elements", ")", ")" ]

[ "def", "_extract_table_root", "(", "d", ",", "current", ",", "pc", ")", ":", "logger_ts", ".", "info", "(", "\"enter extract_table_root\"", ")", "try", ":", "for", "k", ",", "v", "in", "d", ".", "items", "(", ")", ":", "if", "isinstance", "(", "v", ",", "str", ")", ":", "current", "[", "pc", "+", "'_'", "+", "k", "]", "=", "v", "except", "Exception", "as", "e", ":", "logger_ts", ".", "error", "(", "\"extract_table_root: {}\"", ".", "format", "(", "e", ")", ")", "return", "current" ]