Datasets:

kejian

/

codesearchnet-python-rebalanced

like 1

[ "def", "_inverse_permutation_indices", "(", "positions", ")", ":", "if", "not", "positions", ":", "return", "None", "if", "isinstance", "(", "positions", "[", "0", "]", ",", "slice", ")", ":", "positions", "=", "_consolidate_slices", "(", "positions", ")", "if", "positions", "==", "slice", "(", "None", ")", ":", "return", "None", "positions", "=", "[", "np", ".", "arange", "(", "sl", ".", "start", ",", "sl", ".", "stop", ",", "sl", ".", "step", ")", "for", "sl", "in", "positions", "]", "indices", "=", "nputils", ".", "inverse_permutation", "(", "np", ".", "concatenate", "(", "positions", ")", ")", "return", "indices" ]

[ "def", "_next_partition", "(", "self", ",", "topic", ",", "key", "=", "None", ")", ":", "# check if the client has metadata for the topic", "while", "self", ".", "client", ".", "metadata_error_for_topic", "(", "topic", ")", ":", "# client doesn't have good metadata for topic. ask to fetch...", "# check if we have request attempts left", "if", "self", ".", "_req_attempts", ">=", "self", ".", "_max_attempts", ":", "# No, no attempts left, so raise the error", "_check_error", "(", "self", ".", "client", ".", "metadata_error_for_topic", "(", "topic", ")", ")", "yield", "self", ".", "client", ".", "load_metadata_for_topics", "(", "topic", ")", "if", "not", "self", ".", "client", ".", "metadata_error_for_topic", "(", "topic", ")", ":", "break", "self", ".", "_req_attempts", "+=", "1", "d", "=", "Deferred", "(", ")", "self", ".", "client", ".", "reactor", ".", "callLater", "(", "self", ".", "_retry_interval", ",", "d", ".", "callback", ",", "True", ")", "self", ".", "_retry_interval", "*=", "self", ".", "RETRY_INTERVAL_FACTOR", "yield", "d", "# Ok, should be safe to get the partitions now...", "partitions", "=", "self", ".", "client", ".", "topic_partitions", "[", "topic", "]", "# Do we have a partitioner for this topic already?", "if", "topic", "not", "in", "self", ".", "partitioners", ":", "# No, create a new paritioner for topic, partitions", "self", ".", "partitioners", "[", "topic", "]", "=", "self", ".", "partitioner_class", "(", "topic", ",", "partitions", ")", "# Lookup the next partition", "partition", "=", "self", ".", "partitioners", "[", "topic", "]", ".", "partition", "(", "key", ",", "partitions", ")", "returnValue", "(", "partition", ")" ]

[ "def", "Builder", "(", "*", "*", "kw", ")", ":", "composite", "=", "None", "if", "'generator'", "in", "kw", ":", "if", "'action'", "in", "kw", ":", "raise", "UserError", "(", "\"You must not specify both an action and a generator.\"", ")", "kw", "[", "'action'", "]", "=", "SCons", ".", "Action", ".", "CommandGeneratorAction", "(", "kw", "[", "'generator'", "]", ",", "{", "}", ")", "del", "kw", "[", "'generator'", "]", "elif", "'action'", "in", "kw", ":", "source_ext_match", "=", "kw", ".", "get", "(", "'source_ext_match'", ",", "1", ")", "if", "'source_ext_match'", "in", "kw", ":", "del", "kw", "[", "'source_ext_match'", "]", "if", "SCons", ".", "Util", ".", "is_Dict", "(", "kw", "[", "'action'", "]", ")", ":", "composite", "=", "DictCmdGenerator", "(", "kw", "[", "'action'", "]", ",", "source_ext_match", ")", "kw", "[", "'action'", "]", "=", "SCons", ".", "Action", ".", "CommandGeneratorAction", "(", "composite", ",", "{", "}", ")", "kw", "[", "'src_suffix'", "]", "=", "composite", ".", "src_suffixes", "(", ")", "else", ":", "kw", "[", "'action'", "]", "=", "SCons", ".", "Action", ".", "Action", "(", "kw", "[", "'action'", "]", ")", "if", "'emitter'", "in", "kw", ":", "emitter", "=", "kw", "[", "'emitter'", "]", "if", "SCons", ".", "Util", ".", "is_String", "(", "emitter", ")", ":", "# This allows users to pass in an Environment", "# variable reference (like \"$FOO\") as an emitter.", "# We will look in that Environment variable for", "# a callable to use as the actual emitter.", "var", "=", "SCons", ".", "Util", ".", "get_environment_var", "(", "emitter", ")", "if", "not", "var", ":", "raise", "UserError", "(", "\"Supplied emitter '%s' does not appear to refer to an Environment variable\"", "%", "emitter", ")", "kw", "[", "'emitter'", "]", "=", "EmitterProxy", "(", "var", ")", "elif", "SCons", ".", "Util", ".", "is_Dict", "(", "emitter", ")", ":", "kw", "[", "'emitter'", "]", "=", "DictEmitter", "(", "emitter", ")", "elif", "SCons", ".", "Util", ".", "is_List", "(", "emitter", ")", ":", "kw", "[", "'emitter'", "]", "=", "ListEmitter", "(", "emitter", ")", "result", "=", "BuilderBase", "(", "*", "*", "kw", ")", "if", "not", "composite", "is", "None", ":", "result", "=", "CompositeBuilder", "(", "result", ",", "composite", ")", "return", "result" ]

[ "def", "_remove_qualifiers", "(", "obj", ")", ":", "assert", "isinstance", "(", "obj", ",", "(", "CIMInstance", ",", "CIMClass", ")", ")", "obj", ".", "qualifiers", "=", "NocaseDict", "(", ")", "for", "prop", "in", "obj", ".", "properties", ":", "obj", ".", "properties", "[", "prop", "]", ".", "qualifiers", "=", "NocaseDict", "(", ")", "if", "isinstance", "(", "obj", ",", "CIMClass", ")", ":", "for", "method", "in", "obj", ".", "methods", ":", "obj", ".", "methods", "[", "method", "]", ".", "qualifiers", "=", "NocaseDict", "(", ")", "for", "param", "in", "obj", ".", "methods", "[", "method", "]", ".", "parameters", ":", "obj", ".", "methods", "[", "method", "]", ".", "parameters", "[", "param", "]", ".", "qualifiers", "=", "NocaseDict", "(", ")" ]

[ "def", "taper", "(", "self", ",", "side", "=", "'leftright'", ")", ":", "# check window properties", "if", "side", "not", "in", "(", "'left'", ",", "'right'", ",", "'leftright'", ")", ":", "raise", "ValueError", "(", "\"side must be one of 'left', 'right', \"", "\"or 'leftright'\"", ")", "out", "=", "self", ".", "copy", "(", ")", "# identify the second stationary point away from each boundary,", "# else default to half the TimeSeries width", "nleft", ",", "nright", "=", "0", ",", "0", "mini", ",", "=", "signal", ".", "argrelmin", "(", "out", ".", "value", ")", "maxi", ",", "=", "signal", ".", "argrelmax", "(", "out", ".", "value", ")", "if", "'left'", "in", "side", ":", "nleft", "=", "max", "(", "mini", "[", "0", "]", ",", "maxi", "[", "0", "]", ")", "nleft", "=", "min", "(", "nleft", ",", "self", ".", "size", "/", "2", ")", "if", "'right'", "in", "side", ":", "nright", "=", "out", ".", "size", "-", "min", "(", "mini", "[", "-", "1", "]", ",", "maxi", "[", "-", "1", "]", ")", "nright", "=", "min", "(", "nright", ",", "self", ".", "size", "/", "2", ")", "out", "*=", "planck", "(", "out", ".", "size", ",", "nleft", "=", "nleft", ",", "nright", "=", "nright", ")", "return", "out" ]

[ "def", "on_data", "(", "self", ",", "ws", ",", "message", ",", "message_type", ",", "fin", ")", ":", "try", ":", "json_object", "=", "json", ".", "loads", "(", "message", ")", "except", "Exception", ":", "self", ".", "on_error", "(", "ws", ",", "'Unable to parse received message.'", ")", "if", "'error'", "in", "json_object", ":", "# Only call on_error() if a real error occurred. The STT service sends", "# {\"error\" : \"No speech detected for 5s\"} for valid timeouts, configured by", "# options.inactivity_timeout", "error", "=", "json_object", "[", "'error'", "]", "if", "error", ".", "startswith", "(", "TIMEOUT_PREFIX", ")", ":", "self", ".", "callback", ".", "on_inactivity_timeout", "(", "error", ")", "else", ":", "self", ".", "on_error", "(", "ws", ",", "error", ")", "# if uninitialized, receive the initialization response from the server", "elif", "'state'", "in", "json_object", ":", "if", "not", "self", ".", "isListening", ":", "self", ".", "isListening", "=", "True", "self", ".", "callback", ".", "on_listening", "(", ")", "self", ".", "send_audio", "(", "ws", ")", "else", ":", "# close the connection", "self", ".", "callback", ".", "on_close", "(", ")", "ws", ".", "close", "(", ")", "# if in streaming", "elif", "'results'", "in", "json_object", "or", "'speaker_labels'", "in", "json_object", ":", "hypothesis", "=", "''", "if", "'results'", "in", "json_object", ":", "hypothesis", "=", "json_object", "[", "'results'", "]", "[", "0", "]", "[", "'alternatives'", "]", "[", "0", "]", "[", "'transcript'", "]", "b_final", "=", "(", "json_object", "[", "'results'", "]", "[", "0", "]", "[", "'final'", "]", "is", "True", ")", "transcripts", "=", "self", ".", "extract_transcripts", "(", "json_object", "[", "'results'", "]", "[", "0", "]", "[", "'alternatives'", "]", ")", "if", "b_final", ":", "self", ".", "callback", ".", "on_transcription", "(", "transcripts", ")", "self", ".", "callback", ".", "on_hypothesis", "(", "hypothesis", ")", "self", ".", "callback", ".", "on_data", "(", "json_object", ")" ]

[ "def", "remove_wirevector", "(", "self", ",", "wirevector", ")", ":", "self", ".", "wirevector_set", ".", "remove", "(", "wirevector", ")", "del", "self", ".", "wirevector_by_name", "[", "wirevector", ".", "name", "]" ]

[ "def", "get_scrim", "(", "path", "=", "None", ",", "auto_write", "=", "None", ",", "shell", "=", "None", ",", "script", "=", "None", ",", "cache", "=", "{", "}", ")", ":", "args", "=", "(", "path", ",", "auto_write", ",", "shell", ",", "script", ")", "if", "args", "not", "in", "cache", ":", "cache", "[", "args", "]", "=", "Scrim", "(", "*", "args", ")", "return", "cache", "[", "args", "]" ]

[ "def", "make_choice_validator", "(", "choices", ",", "default_key", "=", "None", ",", "normalizer", "=", "None", ")", ":", "def", "normalize_all", "(", "_choices", ")", ":", "# normalize all the keys for easier comparison", "if", "normalizer", ":", "_choices", "=", "[", "(", "normalizer", "(", "key", ")", ",", "value", ")", "for", "key", ",", "value", "in", "choices", "]", "return", "_choices", "choices", "=", "normalize_all", "(", "choices", ")", "def", "choice_validator", "(", "value", ")", ":", "if", "normalizer", ":", "value", "=", "normalizer", "(", "value", ")", "if", "not", "value", "and", "default_key", ":", "value", "=", "choices", "[", "default_key", "]", "[", "0", "]", "results", "=", "[", "]", "for", "choice", ",", "mapped", "in", "choices", ":", "if", "value", "==", "choice", ":", "return", "mapped", "if", "choice", ".", "startswith", "(", "value", ")", ":", "results", ".", "append", "(", "(", "choice", ",", "mapped", ")", ")", "if", "len", "(", "results", ")", "==", "1", ":", "return", "results", "[", "0", "]", "[", "1", "]", "elif", "not", "results", ":", "raise", "ValueError", "(", "'Invalid choice.'", ")", "else", ":", "raise", "ValueError", "(", "'Choice ambiguous between (%s)'", "%", "', '", ".", "join", "(", "k", "for", "k", ",", "v", "in", "normalize_all", "(", "results", ")", ")", ")", "return", "choice_validator" ]

[ "def", "default", "(", "self", ",", "obj", ")", ":", "if", "isinstance", "(", "obj", ",", "np", ".", "ndarray", ")", ":", "if", "obj", ".", "flags", "[", "'C_CONTIGUOUS'", "]", ":", "obj_data", "=", "obj", ".", "data", "else", ":", "cont_obj", "=", "np", ".", "ascontiguousarray", "(", "obj", ")", "assert", "(", "cont_obj", ".", "flags", "[", "'C_CONTIGUOUS'", "]", ")", "obj_data", "=", "cont_obj", ".", "data", "data_b64", "=", "base64", ".", "b64encode", "(", "obj_data", ")", "return", "dict", "(", "__ndarray__", "=", "data_b64", ",", "dtype", "=", "str", "(", "obj", ".", "dtype", ")", ",", "shape", "=", "obj", ".", "shape", ")", "elif", "isinstance", "(", "obj", ",", "np", ".", "generic", ")", ":", "return", "np", ".", "asscalar", "(", "obj", ")", "# Let the base class default method raise the TypeError", "return", "json", ".", "JSONEncoder", "(", "self", ",", "obj", ")" ]

[ "def", "UV_H", "(", "Hg", ",", "gw", ")", ":", "lefts", "=", "set", "(", ")", "K", "=", "[", "]", "UV", "=", "[", "]", "p", "=", "Hwidth", "(", "gw", ")", "pp", "=", "2", "**", "p", "while", "p", ":", "pp", "=", "pp", ">>", "1", "p", "=", "p", "-", "1", "if", "Hg", "&", "pp", ":", "y", "=", "istr", "(", "p", ",", "3", ",", "gw", ")", "yy", "=", "y", ".", "replace", "(", "'1'", ",", "'0'", ")", "if", "yy", "not", "in", "lefts", ":", "if", "y", ".", "find", "(", "'1'", ")", "==", "-", "1", ":", "#y∈{0,2}^n", "K", ".", "append", "(", "y", ")", "else", ":", "UV", ".", "append", "(", "y", ")", "lefts", ".", "add", "(", "yy", ")", "return", "(", "UV", ",", "K", ")" ]

[ "def", "cli_check_normalize_args", "(", "args", ")", ":", "args_keys", "=", "vars", "(", "args", ")", ".", "keys", "(", ")", "# What args we have", "args_copy", "=", "copy", ".", "copy", "(", "args", ")", "if", "'data_dir'", "in", "args_keys", ":", "args_copy", ".", "data_dir", "=", "_cli_check_data_dir", "(", "args", ".", "data_dir", ")", "if", "'basis'", "in", "args", ":", "args_copy", ".", "basis", "=", "_cli_check_basis", "(", "args", ".", "basis", ",", "args", ".", "data_dir", ")", "if", "'basis1'", "in", "args_keys", ":", "args_copy", ".", "basis1", "=", "_cli_check_basis", "(", "args", ".", "basis1", ",", "args", ".", "data_dir", ")", "if", "'basis2'", "in", "args_keys", ":", "args_copy", ".", "basis2", "=", "_cli_check_basis", "(", "args", ".", "basis2", ",", "args", ".", "data_dir", ")", "if", "'fmt'", "in", "args_keys", ":", "args_copy", ".", "fmt", "=", "_cli_check_format", "(", "args", ".", "fmt", ")", "if", "'reffmt'", "in", "args_keys", ":", "args_copy", ".", "reffmt", "=", "_cli_check_ref_format", "(", "args", ".", "reffmt", ")", "if", "'role'", "in", "args_keys", ":", "args_copy", ".", "role", "=", "_cli_check_role", "(", "args", ".", "role", ")", "if", "'family'", "in", "args_keys", ":", "args_copy", ".", "family", "=", "_cli_check_family", "(", "args", ".", "family", ",", "args", ".", "data_dir", ")", "if", "'readfmt1'", "in", "args_keys", ":", "args_copy", ".", "readfmt1", "=", "_cli_check_readfmt", "(", "args", ".", "readfmt1", ")", "if", "'readfmt2'", "in", "args_keys", ":", "args_copy", ".", "readfmt2", "=", "_cli_check_readfmt", "(", "args", ".", "readfmt2", ")", "return", "args_copy" ]

[ "def", "to_str", "(", "obj", ",", "encoding", "=", "'utf-8'", ",", "*", "*", "encode_args", ")", ":", "# Note: On py3, ``b'x'.__str__()`` returns ``\"b'x'\"``, so we need to do the", "# explicit check first.", "if", "isinstance", "(", "obj", ",", "binary_type", ")", ":", "return", "obj", "# We coerce to unicode if '__unicode__' is available because there is no", "# way to specify encoding when calling ``str(obj)``, so, eg,", "# ``str(Exception(u'\\u1234'))`` will explode.", "if", "isinstance", "(", "obj", ",", "text_type", ")", "or", "hasattr", "(", "obj", ",", "text_type_magicmethod", ")", ":", "# Note: unicode(u'foo') is O(1) (by experimentation)", "return", "text_type", "(", "obj", ")", ".", "encode", "(", "encoding", ",", "*", "*", "encode_args", ")", "return", "binary_type", "(", "obj", ")" ]

[ "def", "ranking_game", "(", "n", ",", "steps", "=", "10", ",", "random_state", "=", "None", ")", ":", "payoff_arrays", "=", "tuple", "(", "np", ".", "empty", "(", "(", "n", ",", "n", ")", ")", "for", "i", "in", "range", "(", "2", ")", ")", "random_state", "=", "check_random_state", "(", "random_state", ")", "scores", "=", "random_state", ".", "randint", "(", "1", ",", "steps", "+", "1", ",", "size", "=", "(", "2", ",", "n", ")", ")", "scores", ".", "cumsum", "(", "axis", "=", "1", ",", "out", "=", "scores", ")", "costs", "=", "np", ".", "empty", "(", "(", "2", ",", "n", "-", "1", ")", ")", "costs", "[", ":", "]", "=", "random_state", ".", "randint", "(", "1", ",", "steps", "+", "1", ",", "size", "=", "(", "2", ",", "n", "-", "1", ")", ")", "costs", ".", "cumsum", "(", "axis", "=", "1", ",", "out", "=", "costs", ")", "costs", "[", ":", "]", "/=", "(", "n", "*", "steps", ")", "_populate_ranking_payoff_arrays", "(", "payoff_arrays", ",", "scores", ",", "costs", ")", "g", "=", "NormalFormGame", "(", "[", "Player", "(", "payoff_array", ")", "for", "payoff_array", "in", "payoff_arrays", "]", ")", "return", "g" ]

[ "def", "_handle_read_chunk", "(", "self", ")", ":", "new_data", "=", "b''", "buffer_length", "=", "len", "(", "self", ".", "read_buffer", ")", "try", ":", "while", "buffer_length", "<", "self", ".", "MAX_BUFFER_SIZE", ":", "try", ":", "piece", "=", "self", ".", "recv", "(", "4096", ")", "except", "OSError", "as", "e", ":", "if", "e", ".", "errno", "==", "errno", ".", "EAGAIN", ":", "# End of the available data", "break", "elif", "e", ".", "errno", "==", "errno", ".", "EIO", "and", "new_data", ":", "# Hopefully we could read an error message before the", "# actual termination", "break", "else", ":", "raise", "if", "not", "piece", ":", "# A closed connection is indicated by signaling a read", "# condition, and having recv() return 0.", "break", "new_data", "+=", "piece", "buffer_length", "+=", "len", "(", "piece", ")", "finally", ":", "new_data", "=", "new_data", ".", "replace", "(", "b'\\r'", ",", "b'\\n'", ")", "self", ".", "read_buffer", "+=", "new_data", "return", "new_data" ]

[ "def", "guess_file_name_stream_type_header", "(", "args", ")", ":", "ftype", "=", "None", "fheader", "=", "None", "if", "isinstance", "(", "args", ",", "(", "tuple", ",", "list", ")", ")", ":", "if", "len", "(", "args", ")", "==", "2", ":", "fname", ",", "fstream", "=", "args", "elif", "len", "(", "args", ")", "==", "3", ":", "fname", ",", "fstream", ",", "ftype", "=", "args", "else", ":", "fname", ",", "fstream", ",", "ftype", ",", "fheader", "=", "args", "else", ":", "fname", ",", "fstream", "=", "guess_filename_stream", "(", "args", ")", "ftype", "=", "guess_content_type", "(", "fname", ")", "if", "isinstance", "(", "fstream", ",", "(", "str", ",", "bytes", ",", "bytearray", ")", ")", ":", "fdata", "=", "fstream", "else", ":", "fdata", "=", "fstream", ".", "read", "(", ")", "return", "fname", ",", "fdata", ",", "ftype", ",", "fheader" ]

[ "def", "isNumber", "(", "self", ",", "value", ")", ":", "try", ":", "str", "(", "value", ")", "float", "(", "value", ")", "return", "True", "except", "ValueError", ":", "return", "False" ]

[ "def", "get_all_tasks", "(", "conf", ")", ":", "db", "=", "HamsterDB", "(", "conf", ")", "fact_list", "=", "db", ".", "all_facts_id", "security_days", "=", "int", "(", "conf", ".", "get_option", "(", "'tasks.security_days'", ")", ")", "today", "=", "datetime", ".", "today", "(", ")", "tasks", "=", "{", "}", "for", "fact_id", "in", "fact_list", ":", "ht", "=", "HamsterTask", "(", "fact_id", ",", "conf", ",", "db", ")", "if", "ht", ".", "end_time", ":", "end_time", "=", "ht", ".", "get_object_dates", "(", ")", "[", "1", "]", "if", "today", "-", "timedelta", "(", "security_days", ")", "<=", "end_time", ":", "rt", "=", "ht", ".", "get_remote_task", "(", ")", "tasks", "[", "rt", ".", "task_id", "]", "=", "rt", "db", ".", "close_connection", "(", ")", "print", "'Obtained %d tasks'", "%", "len", "(", "tasks", ")", "return", "tasks" ]

[ "def", "purge_key", "(", "surrogate_key", ",", "service_id", ",", "api_key", ")", ":", "logger", "=", "logging", ".", "getLogger", "(", "__name__", ")", "api_root", "=", "'https://api.fastly.com'", "path", "=", "'/service/{service}/purge/{surrogate_key}'", ".", "format", "(", "service", "=", "service_id", ",", "surrogate_key", "=", "surrogate_key", ")", "logger", ".", "info", "(", "'Fastly purge {0}'", ".", "format", "(", "path", ")", ")", "r", "=", "requests", ".", "post", "(", "api_root", "+", "path", ",", "headers", "=", "{", "'Fastly-Key'", ":", "api_key", ",", "'Accept'", ":", "'application/json'", "}", ")", "if", "r", ".", "status_code", "!=", "200", ":", "raise", "FastlyError", "(", "r", ".", "json", ")" ]

[ "def", "handler", "(", "self", ")", ":", "return", "ft", ".", "partial", "(", "self", ".", "base", ".", "handler", ",", "parameter", "=", "self", ".", "parameter", ")", "if", "self", ".", "parameter", "else", "self", ".", "base", ".", "handler" ]

[ "def", "as_dictionary", "(", "self", ",", "is_proof", "=", "True", ")", ":", "if", "self", ".", "_created", "is", "None", ":", "self", ".", "_created", "=", "DDO", ".", "_get_timestamp", "(", ")", "data", "=", "{", "'@context'", ":", "DID_DDO_CONTEXT_URL", ",", "'id'", ":", "self", ".", "_did", ",", "'created'", ":", "self", ".", "_created", ",", "}", "if", "self", ".", "_public_keys", ":", "values", "=", "[", "]", "for", "public_key", "in", "self", ".", "_public_keys", ":", "values", ".", "append", "(", "public_key", ".", "as_dictionary", "(", ")", ")", "data", "[", "'publicKey'", "]", "=", "values", "if", "self", ".", "_authentications", ":", "values", "=", "[", "]", "for", "authentication", "in", "self", ".", "_authentications", ":", "values", ".", "append", "(", "authentication", ")", "data", "[", "'authentication'", "]", "=", "values", "if", "self", ".", "_services", ":", "values", "=", "[", "]", "for", "service", "in", "self", ".", "_services", ":", "values", ".", "append", "(", "service", ".", "as_dictionary", "(", ")", ")", "data", "[", "'service'", "]", "=", "values", "if", "self", ".", "_proof", "and", "is_proof", ":", "data", "[", "'proof'", "]", "=", "self", ".", "_proof", "return", "data" ]

[ "def", "reduce_by", "(", "self", ",", "package_request", ")", ":", "self", ".", "solver", ".", "reduction_broad_tests_count", "+=", "1", "if", "self", ".", "package_request", ".", "conflict", ":", "# conflict scopes don't reduce. Instead, other scopes will be", "# reduced against a conflict scope.", "return", "(", "self", ",", "[", "]", ")", "# perform the reduction", "new_slice", ",", "reductions", "=", "self", ".", "variant_slice", ".", "reduce_by", "(", "package_request", ")", "# there was total reduction", "if", "new_slice", "is", "None", ":", "self", ".", "solver", ".", "reductions_count", "+=", "1", "if", "self", ".", "pr", ":", "reqstr", "=", "_short_req_str", "(", "package_request", ")", "self", ".", "pr", "(", "\"%s was reduced to nothing by %s\"", ",", "self", ",", "reqstr", ")", "self", ".", "pr", ".", "br", "(", ")", "return", "(", "None", ",", "reductions", ")", "# there was some reduction", "if", "new_slice", "is", "not", "self", ".", "variant_slice", ":", "self", ".", "solver", ".", "reductions_count", "+=", "1", "scope", "=", "self", ".", "_copy", "(", "new_slice", ")", "if", "self", ".", "pr", ":", "reqstr", "=", "_short_req_str", "(", "package_request", ")", "self", ".", "pr", "(", "\"%s was reduced to %s by %s\"", ",", "self", ",", "scope", ",", "reqstr", ")", "self", ".", "pr", ".", "br", "(", ")", "return", "(", "scope", ",", "reductions", ")", "# there was no reduction", "return", "(", "self", ",", "[", "]", ")" ]

[ "def", "create_task_log", "(", "self", ",", "task_id", ",", "case_task_log", ")", ":", "req", "=", "self", ".", "url", "+", "\"/api/case/task/{}/log\"", ".", "format", "(", "task_id", ")", "data", "=", "{", "'_json'", ":", "json", ".", "dumps", "(", "{", "\"message\"", ":", "case_task_log", ".", "message", "}", ")", "}", "if", "case_task_log", ".", "file", ":", "f", "=", "{", "'attachment'", ":", "(", "os", ".", "path", ".", "basename", "(", "case_task_log", ".", "file", ")", ",", "open", "(", "case_task_log", ".", "file", ",", "'rb'", ")", ",", "magic", ".", "Magic", "(", "mime", "=", "True", ")", ".", "from_file", "(", "case_task_log", ".", "file", ")", ")", "}", "try", ":", "return", "requests", ".", "post", "(", "req", ",", "data", "=", "data", ",", "files", "=", "f", ",", "proxies", "=", "self", ".", "proxies", ",", "auth", "=", "self", ".", "auth", ",", "verify", "=", "self", ".", "cert", ")", "except", "requests", ".", "exceptions", ".", "RequestException", "as", "e", ":", "raise", "CaseTaskException", "(", "\"Case task log create error: {}\"", ".", "format", "(", "e", ")", ")", "else", ":", "try", ":", "return", "requests", ".", "post", "(", "req", ",", "headers", "=", "{", "'Content-Type'", ":", "'application/json'", "}", ",", "data", "=", "json", ".", "dumps", "(", "{", "'message'", ":", "case_task_log", ".", "message", "}", ")", ",", "proxies", "=", "self", ".", "proxies", ",", "auth", "=", "self", ".", "auth", ",", "verify", "=", "self", ".", "cert", ")", "except", "requests", ".", "exceptions", ".", "RequestException", "as", "e", ":", "raise", "CaseTaskException", "(", "\"Case task log create error: {}\"", ".", "format", "(", "e", ")", ")" ]

[ "def", "fbank", "(", "wav_path", ",", "flat", "=", "True", ")", ":", "(", "rate", ",", "sig", ")", "=", "wav", ".", "read", "(", "wav_path", ")", "if", "len", "(", "sig", ")", "==", "0", ":", "logger", ".", "warning", "(", "\"Empty wav: {}\"", ".", "format", "(", "wav_path", ")", ")", "fbank_feat", "=", "python_speech_features", ".", "logfbank", "(", "sig", ",", "rate", ",", "nfilt", "=", "40", ")", "energy", "=", "extract_energy", "(", "rate", ",", "sig", ")", "feat", "=", "np", ".", "hstack", "(", "[", "energy", ",", "fbank_feat", "]", ")", "delta_feat", "=", "python_speech_features", ".", "delta", "(", "feat", ",", "2", ")", "delta_delta_feat", "=", "python_speech_features", ".", "delta", "(", "delta_feat", ",", "2", ")", "all_feats", "=", "[", "feat", ",", "delta_feat", ",", "delta_delta_feat", "]", "if", "not", "flat", ":", "all_feats", "=", "np", ".", "array", "(", "all_feats", ")", "# Make time the first dimension for easy length normalization padding", "# later.", "all_feats", "=", "np", ".", "swapaxes", "(", "all_feats", ",", "0", ",", "1", ")", "all_feats", "=", "np", ".", "swapaxes", "(", "all_feats", ",", "1", ",", "2", ")", "else", ":", "all_feats", "=", "np", ".", "concatenate", "(", "all_feats", ",", "axis", "=", "1", ")", "# Log Mel Filterbank, with delta, and double delta", "feat_fn", "=", "wav_path", "[", ":", "-", "3", "]", "+", "\"fbank.npy\"", "np", ".", "save", "(", "feat_fn", ",", "all_feats", ")" ]

[ "def", "delete_record", "(", "table", ",", "sys_id", ")", ":", "client", "=", "_get_client", "(", ")", "client", ".", "table", "=", "table", "response", "=", "client", ".", "delete", "(", "sys_id", ")", "return", "response" ]

[ "def", "diagonalize_collision_matrix", "(", "collision_matrices", ",", "i_sigma", "=", "None", ",", "i_temp", "=", "None", ",", "pinv_solver", "=", "0", ",", "log_level", "=", "0", ")", ":", "start", "=", "time", ".", "time", "(", ")", "# Matrix size of collision matrix to be diagonalized.", "# The following value is expected:", "# ir-colmat: num_ir_grid_points * num_band * 3", "# red-colmat: num_mesh_points * num_band", "shape", "=", "collision_matrices", ".", "shape", "if", "len", "(", "shape", ")", "==", "6", ":", "size", "=", "shape", "[", "2", "]", "*", "shape", "[", "3", "]", "assert", "size", "==", "shape", "[", "4", "]", "*", "shape", "[", "5", "]", "elif", "len", "(", "shape", ")", "==", "8", ":", "size", "=", "np", ".", "prod", "(", "shape", "[", "2", ":", "5", "]", ")", "assert", "size", "==", "np", ".", "prod", "(", "shape", "[", "5", ":", "8", "]", ")", "elif", "len", "(", "shape", ")", "==", "2", ":", "size", "=", "shape", "[", "0", "]", "assert", "size", "==", "shape", "[", "1", "]", "solver", "=", "_select_solver", "(", "pinv_solver", ")", "# [1] dsyev: safer and slower than dsyevd and smallest memory usage", "# [2] dsyevd: faster than dsyev and largest memory usage", "if", "solver", "in", "[", "1", ",", "2", "]", ":", "if", "log_level", ":", "routine", "=", "[", "'dsyev'", ",", "'dsyevd'", "]", "[", "solver", "-", "1", "]", "sys", ".", "stdout", ".", "write", "(", "\"Diagonalizing by lapacke %s... \"", "%", "routine", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "import", "phono3py", ".", "_phono3py", "as", "phono3c", "w", "=", "np", ".", "zeros", "(", "size", ",", "dtype", "=", "'double'", ")", "if", "i_sigma", "is", "None", ":", "_i_sigma", "=", "0", "else", ":", "_i_sigma", "=", "i_sigma", "if", "i_temp", "is", "None", ":", "_i_temp", "=", "0", "else", ":", "_i_temp", "=", "i_temp", "phono3c", ".", "diagonalize_collision_matrix", "(", "collision_matrices", ",", "w", ",", "_i_sigma", ",", "_i_temp", ",", "0.0", ",", "(", "solver", "+", "1", ")", "%", "2", ",", "0", ")", "# only diagonalization", "elif", "solver", "==", "3", ":", "# np.linalg.eigh depends on dsyevd.", "if", "log_level", ":", "sys", ".", "stdout", ".", "write", "(", "\"Diagonalizing by np.linalg.eigh... \"", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "col_mat", "=", "collision_matrices", "[", "i_sigma", ",", "i_temp", "]", ".", "reshape", "(", "size", ",", "size", ")", "w", ",", "col_mat", "[", ":", "]", "=", "np", ".", "linalg", ".", "eigh", "(", "col_mat", ")", "elif", "solver", "==", "4", ":", "# fully scipy dsyev", "if", "log_level", ":", "sys", ".", "stdout", ".", "write", "(", "\"Diagonalizing by \"", "\"scipy.linalg.lapack.dsyev... \"", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "import", "scipy", ".", "linalg", "col_mat", "=", "collision_matrices", "[", "i_sigma", ",", "i_temp", "]", ".", "reshape", "(", "size", ",", "size", ")", "w", ",", "_", ",", "info", "=", "scipy", ".", "linalg", ".", "lapack", ".", "dsyev", "(", "col_mat", ".", "T", ",", "overwrite_a", "=", "1", ")", "elif", "solver", "==", "5", ":", "# fully scipy dsyevd", "if", "log_level", ":", "sys", ".", "stdout", ".", "write", "(", "\"Diagonalizing by \"", "\"scipy.linalg.lapack.dsyevd... \"", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "import", "scipy", ".", "linalg", "col_mat", "=", "collision_matrices", "[", "i_sigma", ",", "i_temp", "]", ".", "reshape", "(", "size", ",", "size", ")", "w", ",", "_", ",", "info", "=", "scipy", ".", "linalg", ".", "lapack", ".", "dsyevd", "(", "col_mat", ".", "T", ",", "overwrite_a", "=", "1", ")", "if", "log_level", ":", "print", "(", "\"[%.3fs]\"", "%", "(", "time", ".", "time", "(", ")", "-", "start", ")", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "return", "w" ]

[ "def", "filter_intensity", "(", "df", ",", "label", "=", "\"\"", ",", "with_multiplicity", "=", "False", ")", ":", "label", "+=", "\".*__\\d\"", "if", "with_multiplicity", "else", "\"\"", "dft", "=", "df", ".", "filter", "(", "regex", "=", "\"^(?!Intensity).*$\"", ")", "dfi", "=", "df", ".", "filter", "(", "regex", "=", "'^(.*Intensity.*%s.*__\\d)$'", "%", "label", ")", "return", "pd", ".", "concat", "(", "[", "dft", ",", "dfi", "]", ",", "axis", "=", "1", ")" ]

[ "def", "create_append", "(", "filename", ":", "str", ",", "layers", ":", "Union", "[", "np", ".", "ndarray", ",", "Dict", "[", "str", ",", "np", ".", "ndarray", "]", ",", "loompy", ".", "LayerManager", "]", ",", "row_attrs", ":", "Dict", "[", "str", ",", "np", ".", "ndarray", "]", ",", "col_attrs", ":", "Dict", "[", "str", ",", "np", ".", "ndarray", "]", ",", "*", ",", "file_attrs", ":", "Dict", "[", "str", ",", "str", "]", "=", "None", ",", "fill_values", ":", "Dict", "[", "str", ",", "np", ".", "ndarray", "]", "=", "None", ")", "->", "None", ":", "deprecated", "(", "\"'create_append' is deprecated. See https://github.com/linnarsson-lab/loompy/issues/42\"", ")", "if", "os", ".", "path", ".", "exists", "(", "filename", ")", ":", "with", "connect", "(", "filename", ")", "as", "ds", ":", "ds", ".", "add_columns", "(", "layers", ",", "col_attrs", ",", "fill_values", "=", "fill_values", ")", "else", ":", "create", "(", "filename", ",", "layers", ",", "row_attrs", ",", "col_attrs", ",", "file_attrs", "=", "file_attrs", ")" ]

[ "def", "cbpdnmd_xstep", "(", "k", ")", ":", "YU0", "=", "mp_Z_Y0", "[", "k", "]", "+", "mp_S", "[", "k", "]", "-", "mp_Z_U0", "[", "k", "]", "YU1", "=", "mp_Z_Y1", "[", "k", "]", "-", "mp_Z_U1", "[", "k", "]", "if", "mp_cri", ".", "Cd", "==", "1", ":", "b", "=", "np", ".", "conj", "(", "mp_Df", ")", "*", "sl", ".", "rfftn", "(", "YU0", ",", "None", ",", "mp_cri", ".", "axisN", ")", "+", "sl", ".", "rfftn", "(", "YU1", ",", "None", ",", "mp_cri", ".", "axisN", ")", "Xf", "=", "sl", ".", "solvedbi_sm", "(", "mp_Df", ",", "1.0", ",", "b", ",", "axis", "=", "mp_cri", ".", "axisM", ")", "else", ":", "b", "=", "sl", ".", "inner", "(", "np", ".", "conj", "(", "mp_Df", ")", ",", "sl", ".", "rfftn", "(", "YU0", ",", "None", ",", "mp_cri", ".", "axisN", ")", ",", "axis", "=", "mp_cri", ".", "axisC", ")", "+", "sl", ".", "rfftn", "(", "YU1", ",", "None", ",", "mp_cri", ".", "axisN", ")", "Xf", "=", "sl", ".", "solvemdbi_ism", "(", "mp_Df", ",", "1.0", ",", "b", ",", "mp_cri", ".", "axisM", ",", "mp_cri", ".", "axisC", ")", "mp_Z_X", "[", "k", "]", "=", "sl", ".", "irfftn", "(", "Xf", ",", "mp_cri", ".", "Nv", ",", "mp_cri", ".", "axisN", ")", "mp_DX", "[", "k", "]", "=", "sl", ".", "irfftn", "(", "sl", ".", "inner", "(", "mp_Df", ",", "Xf", ")", ",", "mp_cri", ".", "Nv", ",", "mp_cri", ".", "axisN", ")" ]

[ "def", "_hash", "(", "self", ",", "iv", ",", "value", ")", ":", "return", "hmac", ".", "new", "(", "self", ".", "key", ",", "msg", "=", "iv", "+", "value", ",", "digestmod", "=", "hashlib", ".", "sha256", ")", ".", "hexdigest", "(", ")" ]

[ "def", "roles", "(", "self", ")", ":", "guild", "=", "self", ".", "guild", "if", "guild", "is", "None", ":", "return", "[", "]", "return", "[", "role", "for", "role", "in", "guild", ".", "roles", "if", "self", ".", "_roles", ".", "has", "(", "role", ".", "id", ")", "]" ]

[ "def", "qgis_composer_extractor", "(", "impact_report", ",", "component_metadata", ")", ":", "# QGIS Composer needed certain context to generate the output", "# - Map Settings", "# - Substitution maps", "# - Element settings, such as icon for picture file or image source", "# Generate map settings", "qgis_context", "=", "impact_report", ".", "qgis_composition_context", "inasafe_context", "=", "impact_report", ".", "inasafe_context", "provenance", "=", "impact_report", ".", "impact_function", ".", "provenance", "extra_args", "=", "component_metadata", ".", "extra_args", "context", "=", "QGISComposerContext", "(", ")", "# Set default image elements to replace", "image_elements", "=", "[", "{", "'id'", ":", "'safe-logo'", ",", "'path'", ":", "inasafe_context", ".", "inasafe_logo", "}", ",", "{", "'id'", ":", "'black-inasafe-logo'", ",", "'path'", ":", "inasafe_context", ".", "black_inasafe_logo", "}", ",", "{", "'id'", ":", "'white-inasafe-logo'", ",", "'path'", ":", "inasafe_context", ".", "white_inasafe_logo", "}", ",", "{", "'id'", ":", "'north-arrow'", ",", "'path'", ":", "inasafe_context", ".", "north_arrow", "}", ",", "{", "'id'", ":", "'organisation-logo'", ",", "'path'", ":", "inasafe_context", ".", "organisation_logo", "}", ",", "{", "'id'", ":", "'supporters_logo'", ",", "'path'", ":", "inasafe_context", ".", "supporters_logo", "}", "]", "context", ".", "image_elements", "=", "image_elements", "# Set default HTML Frame elements to replace", "html_frame_elements", "=", "[", "{", "'id'", ":", "'impact-report'", ",", "'mode'", ":", "'text'", ",", "# another mode is url", "'text'", ":", "''", ",", "# TODO: get impact summary table", "}", "]", "context", ".", "html_frame_elements", "=", "html_frame_elements", "\"\"\"Define the layers for the impact map.\"\"\"", "project", "=", "QgsProject", ".", "instance", "(", ")", "layers", "=", "[", "]", "exposure_summary_layers", "=", "[", "]", "if", "impact_report", ".", "multi_exposure_impact_function", ":", "for", "impact_function", "in", "(", "impact_report", ".", "multi_exposure_impact_function", ".", "impact_functions", ")", ":", "impact_layer", "=", "impact_function", ".", "exposure_summary", "or", "(", "impact_function", ".", "aggregate_hazard_impacted", ")", "exposure_summary_layers", ".", "append", "(", "impact_layer", ")", "# use custom ordered layer if any", "if", "impact_report", ".", "ordered_layers", ":", "for", "layer", "in", "impact_report", ".", "ordered_layers", ":", "layers", ".", "append", "(", "layer", ")", "# We are keeping this if we want to enable below behaviour again.", "# Currently realtime might have layer order without impact layer in it.", "# # make sure at least there is an impact layer", "# if impact_report.multi_exposure_impact_function:", "# additional_layers = [] # for exposure summary layers", "# impact_layer_found = False", "# impact_functions = (", "# impact_report.multi_exposure_impact_function.impact_functions)", "# # check for impact layer occurrences", "# for analysis in impact_functions:", "# impact_layer = analysis.exposure_summary or (", "# analysis.aggregate_hazard_impacted)", "# for index, layer in enumerate(layers):", "# if impact_layer.source() == layer.source():", "# add_impact_layers_to_canvas(analysis)", "# layers[index] = impact_layer", "# impact_layer_found = True", "# if not impact_layer_found:", "# for analysis in impact_functions:", "# add_impact_layers_to_canvas(analysis)", "# impact_layer = analysis.exposure_summary or (", "# analysis.aggregate_hazard_impacted)", "# layer_uri = full_layer_uri(impact_layer)", "# layer = load_layer_from_registry(layer_uri)", "# additional_layers.append(layer)", "# layers = additional_layers + layers", "# else:", "# impact_layer = (", "# impact_report.impact_function.exposure_summary or (", "# impact_report.impact_function.aggregate_hazard_impacted))", "# if impact_layer not in layers:", "# layers.insert(0, impact_layer)", "# use default layer order if no custom ordered layer found", "else", ":", "if", "not", "impact_report", ".", "multi_exposure_impact_function", ":", "# single IF", "layers", "=", "[", "impact_report", ".", "impact", "]", "+", "impact_report", ".", "extra_layers", "else", ":", "# multi-exposure IF", "layers", "=", "[", "]", "+", "impact_report", ".", "extra_layers", "add_supplementary_layers", "=", "(", "not", "impact_report", ".", "multi_exposure_impact_function", "or", "not", "(", "impact_report", ".", "multi_exposure_impact_function", ".", "output_layers_ordered", ")", ")", "if", "add_supplementary_layers", ":", "# Check show only impact.", "show_only_impact", "=", "setting", "(", "'set_show_only_impact_on_report'", ",", "expected_type", "=", "bool", ")", "if", "not", "show_only_impact", ":", "hazard_layer", "=", "project", ".", "mapLayers", "(", ")", ".", "get", "(", "provenance", "[", "'hazard_layer_id'", "]", ",", "None", ")", "aggregation_layer_id", "=", "provenance", "[", "'aggregation_layer_id'", "]", "if", "aggregation_layer_id", ":", "aggregation_layer", "=", "project", ".", "mapLayers", "(", ")", ".", "get", "(", "aggregation_layer_id", ",", "None", ")", "layers", ".", "append", "(", "aggregation_layer", ")", "layers", ".", "append", "(", "hazard_layer", ")", "# check hide exposure settings", "hide_exposure_flag", "=", "setting", "(", "'setHideExposureFlag'", ",", "expected_type", "=", "bool", ")", "if", "not", "hide_exposure_flag", ":", "exposure_layers_id", "=", "[", "]", "if", "provenance", ".", "get", "(", "provenance_exposure_layer_id", "[", "'provenance_key'", "]", ")", ":", "exposure_layers_id", ".", "append", "(", "provenance", ".", "get", "(", "provenance_exposure_layer_id", "[", "'provenance_key'", "]", ")", ")", "elif", "provenance", ".", "get", "(", "provenance_multi_exposure_layers_id", "[", "'provenance_key'", "]", ")", ":", "exposure_layers_id", "=", "provenance", ".", "get", "(", "provenance_multi_exposure_layers_id", "[", "'provenance_key'", "]", ")", "# place exposure at the bottom", "for", "layer_id", "in", "exposure_layers_id", ":", "exposure_layer", "=", "project", ".", "mapLayers", "(", ")", ".", "get", "(", "layer_id", ")", "layers", ".", "append", "(", "exposure_layer", ")", "# default extent is analysis extent", "if", "not", "qgis_context", ".", "extent", ":", "qgis_context", ".", "extent", "=", "impact_report", ".", "impact_function", ".", "analysis_extent", "map_elements", "=", "[", "{", "'id'", ":", "'impact-map'", ",", "'extent'", ":", "qgis_context", ".", "extent", ",", "'grid_split_count'", ":", "5", ",", "'layers'", ":", "layers", ",", "}", "]", "context", ".", "map_elements", "=", "map_elements", "# calculate map_legends, only show the legend for impact layer", "if", "impact_report", ".", "legend_layers", ":", "# use requested legend if any", "layers", "=", "impact_report", ".", "legend_layers", "elif", "impact_report", ".", "multi_exposure_impact_function", ":", "# multi-exposure IF", "layers", "=", "exposure_summary_layers", "else", ":", "# single IF", "layers", "=", "[", "impact_report", ".", "impact", "]", "symbol_count", "=", "0", "for", "l", "in", "layers", ":", "layer", "=", "l", "\"\"\":type: qgis.core.QgsMapLayer\"\"\"", "try", ":", "symbol_count", "+=", "len", "(", "layer", ".", "legendSymbologyItems", "(", ")", ")", "continue", "except", "Exception", ":", "# pylint: disable=broad-except", "pass", "try", ":", "symbol_count", "+=", "len", "(", "layer", ".", "renderer", "(", ")", ".", "legendSymbolItems", "(", ")", ")", "continue", "except", "Exception", ":", "# pylint: disable=broad-except", "pass", "symbol_count", "+=", "1", "legend_title", "=", "provenance", ".", "get", "(", "'map_legend_title'", ")", "or", "''", "map_legends", "=", "[", "{", "'id'", ":", "'impact-legend'", ",", "'title'", ":", "legend_title", ",", "'layers'", ":", "layers", ",", "'symbol_count'", ":", "symbol_count", ",", "# 'column_count': 2, # the number of column in legend display", "}", "]", "context", ".", "map_legends", "=", "map_legends", "# process substitution map", "start_datetime", "=", "provenance", "[", "'start_datetime'", "]", "\"\"\":type: datetime.datetime\"\"\"", "date_format", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'date-format'", ")", "time_format", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'time-format'", ")", "if", "isinstance", "(", "start_datetime", ",", "datetime", ".", "datetime", ")", ":", "date", "=", "start_datetime", ".", "strftime", "(", "date_format", ")", "time", "=", "start_datetime", ".", "strftime", "(", "time_format", ")", "else", ":", "date", "=", "''", "time", "=", "''", "long_version", "=", "get_version", "(", ")", "tokens", "=", "long_version", ".", "split", "(", "'.'", ")", "version", "=", "'%s.%s.%s'", "%", "(", "tokens", "[", "0", "]", ",", "tokens", "[", "1", "]", ",", "tokens", "[", "2", "]", ")", "# Get title of the layer", "title", "=", "provenance", ".", "get", "(", "'map_title'", ")", "or", "''", "# Set source", "unknown_source_text", "=", "resolve_from_dictionary", "(", "extra_args", ",", "[", "'defaults'", ",", "'unknown_source'", "]", ")", "aggregation_not_used", "=", "resolve_from_dictionary", "(", "extra_args", ",", "[", "'defaults'", ",", "'aggregation_not_used'", "]", ")", "hazard_source", "=", "(", "provenance", ".", "get", "(", "'hazard_keywords'", ",", "{", "}", ")", ".", "get", "(", "'source'", ")", "or", "unknown_source_text", ")", "exposure_source", "=", "(", "provenance", ".", "get", "(", "'exposure_keywords'", ",", "{", "}", ")", ".", "get", "(", "'source'", ")", "or", "unknown_source_text", ")", "if", "provenance", "[", "'aggregation_layer'", "]", ":", "aggregation_source", "=", "(", "provenance", "[", "'aggregation_keywords'", "]", ".", "get", "(", "'source'", ")", "or", "unknown_source_text", ")", "else", ":", "aggregation_source", "=", "aggregation_not_used", "spatial_reference_format", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'spatial-reference-format'", ")", "reference_name", "=", "spatial_reference_format", ".", "format", "(", "crs", "=", "impact_report", ".", "impact_function", ".", "crs", ".", "authid", "(", ")", ")", "analysis_layer", "=", "impact_report", ".", "analysis", "analysis_name", "=", "value_from_field_name", "(", "analysis_name_field", "[", "'field_name'", "]", ",", "analysis_layer", ")", "# Prepare the substitution map", "version_title", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'version-title'", ")", "disclaimer_title", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'disclaimer-title'", ")", "date_title", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'date-title'", ")", "time_title", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'time-title'", ")", "caution_title", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'caution-title'", ")", "caution_text", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'caution-text'", ")", "version_text", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'version-text'", ")", "legend_section_title", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'legend-title'", ")", "information_title", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'information-title'", ")", "supporters_title", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'supporters-title'", ")", "source_title", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'source-title'", ")", "analysis_title", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'analysis-title'", ")", "reference_title", "=", "resolve_from_dictionary", "(", "extra_args", ",", "'spatial-reference-title'", ")", "substitution_map", "=", "{", "'impact-title'", ":", "title", ",", "'date'", ":", "date", ",", "'time'", ":", "time", ",", "'safe-version'", ":", "version", ",", "# deprecated", "'disclaimer'", ":", "inasafe_context", ".", "disclaimer", ",", "# These added in 3.2", "'version-title'", ":", "version_title", ",", "'inasafe-version'", ":", "version", ",", "'disclaimer-title'", ":", "disclaimer_title", ",", "'date-title'", ":", "date_title", ",", "'time-title'", ":", "time_title", ",", "'caution-title'", ":", "caution_title", ",", "'caution-text'", ":", "caution_text", ",", "'version-text'", ":", "version_text", ".", "format", "(", "version", "=", "version", ")", ",", "'legend-title'", ":", "legend_section_title", ",", "'information-title'", ":", "information_title", ",", "'supporters-title'", ":", "supporters_title", ",", "'source-title'", ":", "source_title", ",", "'analysis-title'", ":", "analysis_title", ",", "'analysis-name'", ":", "analysis_name", ",", "'reference-title'", ":", "reference_title", ",", "'reference-name'", ":", "reference_name", ",", "'hazard-source'", ":", "hazard_source", ",", "'exposure-source'", ":", "exposure_source", ",", "'aggregation-source'", ":", "aggregation_source", ",", "}", "context", ".", "substitution_map", "=", "substitution_map", "return", "context" ]

[ "def", "namespace", "(", "self", ",", "elem", "=", "None", ")", ":", "if", "elem", "is", "None", ":", "elem", "=", "self", ".", "root", "return", "XML", ".", "tag_namespace", "(", "elem", ".", "tag", ")" ]

[ "def", "add_child", "(", "self", ",", "name", ",", "child", ")", ":", "if", "name", "in", "self", ".", "children", ":", "raise", "ValueError", "(", "\"{} has already a child named {}\"", ".", "format", "(", "self", ".", "name", ",", "name", ")", ")", "if", "not", "(", "isinstance", "(", "child", ",", "ParameterNode", ")", "or", "isinstance", "(", "child", ",", "Parameter", ")", "or", "isinstance", "(", "child", ",", "Scale", ")", ")", ":", "raise", "TypeError", "(", "\"child must be of type ParameterNode, Parameter, or Scale. Instead got {}\"", ".", "format", "(", "type", "(", "child", ")", ")", ")", "self", ".", "children", "[", "name", "]", "=", "child", "setattr", "(", "self", ",", "name", ",", "child", ")" ]

[ "def", "binOp", "(", "op", ",", "indx", ",", "amap", ",", "bmap", ",", "fill_vec", ")", ":", "def", "op_or_missing", "(", "id", ")", ":", "va", "=", "amap", ".", "get", "(", "id", ",", "None", ")", "vb", "=", "bmap", ".", "get", "(", "id", ",", "None", ")", "if", "va", "is", "None", "or", "vb", "is", "None", ":", "# This should create as many elements as the number of columns!?\r", "result", "=", "fill_vec", "else", ":", "try", ":", "result", "=", "op", "(", "va", ",", "vb", ")", "except", "Exception", ":", "result", "=", "None", "if", "result", "is", "None", ":", "result", "=", "fill_vec", "return", "result", "seq_arys", "=", "map", "(", "op_or_missing", ",", "indx", ")", "data", "=", "np", ".", "vstack", "(", "seq_arys", ")", "return", "data" ]

[ "def", "read_atoms", "(", "fn", ",", "cycfn", "=", "None", ",", "pos_only", "=", "False", ",", "conv", "=", "1.0", ")", ":", "f", "=", "paropen", "(", "fn", ",", "\"r\"", ")", "l", "=", "f", ".", "readline", "(", ")", ".", "lstrip", "(", ")", "while", "len", "(", "l", ")", ">", "0", "and", "(", "l", "[", "0", "]", "==", "'#'", "or", "l", "[", "0", "]", "==", "'<'", ")", ":", "l", "=", "f", ".", "readline", "(", ")", ".", "lstrip", "(", ")", "n_atoms", "=", "int", "(", "l", ")", "l", "=", "f", ".", "readline", "(", ")", ".", "lstrip", "(", ")", "while", "len", "(", "l", ")", ">", "0", "and", "(", "l", "[", "0", "]", "==", "'#'", "or", "l", "[", "0", "]", "==", "'<'", ")", ":", "l", "=", "f", ".", "readline", "(", ")", ".", "lstrip", "(", ")", "l", "=", "f", ".", "readline", "(", ")", ".", "lstrip", "(", ")", "while", "len", "(", "l", ")", ">", "0", "and", "(", "l", "[", "0", "]", "==", "'#'", "or", "l", "[", "0", "]", "==", "'<'", ")", ":", "l", "=", "f", ".", "readline", "(", ")", ".", "lstrip", "(", ")", "#", "# Read positions", "#", "forces", "=", "np", ".", "zeros", "(", "[", "n_atoms", ",", "3", "]", ")", "groups", "=", "np", ".", "zeros", "(", "[", "n_atoms", "]", ")", "gamma", "=", "np", ".", "zeros", "(", "[", "n_atoms", "]", ")", "T", "=", "np", ".", "zeros", "(", "[", "n_atoms", "]", ")", "ats", "=", "[", "]", "for", "i", "in", "range", "(", "n_atoms", ")", ":", "s", "=", "l", ".", "split", "(", ")", "# type x y z", "sym", "=", "None", "try", ":", "Z", "=", "int", "(", "s", "[", "0", "]", ")", "sym", "=", "ase", ".", "data", ".", "chemical_symbols", "[", "Z", "]", "except", ":", "sym", "=", "s", "[", "0", "]", "a", "=", "ase", ".", "Atom", "(", "sym", ",", "(", "float", "(", "s", "[", "2", "]", ")", "*", "conv", ",", "float", "(", "s", "[", "3", "]", ")", "*", "conv", ",", "float", "(", "s", "[", "4", "]", ")", "*", "conv", ")", ")", "groups", "[", "i", "]", "=", "int", "(", "s", "[", "5", "]", ")", "gamma", "[", "i", "]", "=", "float", "(", "s", "[", "6", "]", ")", "T", "[", "i", "]", "=", "float", "(", "s", "[", "7", "]", ")", "ats", "+=", "[", "a", "]", "l", "=", "f", ".", "readline", "(", ")", "this", "=", "ase", ".", "Atoms", "(", "ats", ",", "pbc", "=", "True", ")", "if", "not", "pos_only", ":", "while", "l", "and", "l", "==", "\"\"", ":", "l", "=", "f", ".", "readline", "(", ")", ".", "strip", "(", ")", "while", "l", ":", "key", "=", "l", ".", "strip", "(", "\" <-#\\r\\n\"", ")", "if", "key", ".", "upper", "(", ")", "==", "\"VELOCITIES\"", ":", "for", "i", "in", "range", "(", "n_atoms", ")", ":", "s", "=", "f", ".", "readline", "(", ")", ".", "split", "(", ")", "m", "=", "this", "[", "i", "]", ".", "mass", "if", "m", "is", "None", ":", "m", "=", "ase", ".", "data", ".", "atomic_masses", "[", "ase", ".", "data", ".", "chemical_symbols", ".", "index", "(", "this", "[", "i", "]", ".", "symbol", ")", "]", "this", "[", "i", "]", ".", "momentum", "=", "(", "m", "*", "float", "(", "s", "[", "0", "]", ")", ",", "m", "*", "float", "(", "s", "[", "1", "]", ")", ",", "m", "*", "float", "(", "s", "[", "2", "]", ")", ")", "l", "=", "None", "elif", "key", ".", "upper", "(", ")", "==", "\"FORCES\"", ":", "for", "i", "in", "range", "(", "n_atoms", ")", ":", "s", "=", "f", ".", "readline", "(", ")", ".", "split", "(", ")", "forces", "[", "i", "]", "=", "np", ".", "array", "(", "[", "float", "(", "s", "[", "0", "]", ")", ",", "float", "(", "s", "[", "1", "]", ")", ",", "float", "(", "s", "[", "2", "]", ")", "]", ")", "l", "=", "None", "elif", "key", ".", "upper", "(", ")", "==", "\"CHARGES\"", ":", "for", "i", "in", "this", ":", "l", "=", "f", ".", "readline", "(", ")", "if", "l", "and", "len", "(", "l", ".", "split", "(", ")", ")", "==", "1", ":", "i", ".", "charge", "=", "float", "(", "l", ")", "l", "=", "None", "elif", "key", ".", "upper", "(", ")", "==", "\"CELL\"", "or", "key", ".", "upper", "(", ")", ".", "split", "(", ")", "[", "0", ":", "2", "]", "==", "(", "\"BOX\"", ",", "\"VECTORS\"", ")", ":", "l1", "=", "f", ".", "readline", "(", ")", "l2", "=", "f", ".", "readline", "(", ")", "l3", "=", "f", ".", "readline", "(", ")", "this", ".", "set_cell", "(", "[", "[", "float", "(", "x", ")", "for", "x", "in", "l1", ".", "split", "(", ")", "]", ",", "[", "float", "(", "x", ")", "for", "x", "in", "l2", ".", "split", "(", ")", "]", ",", "[", "float", "(", "x", ")", "for", "x", "in", "l3", ".", "split", "(", ")", "]", "]", ")", "l", "=", "None", "else", ":", "aux", "=", "[", "]", "l", "=", "f", ".", "readline", "(", ")", ".", "strip", "(", ")", "while", "l", "and", "l", "[", "0", "]", "not", "in", "[", "'<'", ",", "'#'", "]", ":", "s", "=", "l", ".", "split", "(", ")", "aux", "+=", "[", "[", "float", "(", "x", ")", "for", "x", "in", "s", "]", "]", "l", "=", "f", ".", "readline", "(", ")", ".", "strip", "(", ")", "if", "len", "(", "aux", ")", "==", "n_atoms", ":", "this", ".", "set_array", "(", "key", ",", "np", ".", "asarray", "(", "aux", ")", ")", "else", ":", "print", "(", "\"Warning: Encountered field '%s' which does not seem to be per-atom data.\"", "%", "key", ")", "if", "l", "is", "None", ":", "l", "=", "f", ".", "readline", "(", ")", ".", "strip", "(", ")", "while", "l", "and", "l", "==", "\"\"", ":", "l", "=", "f", ".", "readline", "(", ")", ".", "strip", "(", ")", "f", ".", "close", "(", ")", "this", ".", "set_array", "(", "\"forces\"", ",", "forces", ")", "this", ".", "set_array", "(", "\"groups\"", ",", "groups", ")", "this", ".", "set_array", "(", "\"gamma\"", ",", "gamma", ")", "this", ".", "set_array", "(", "\"T\"", ",", "T", ")", "if", "cycfn", ":", "read_cyc", "(", "this", ",", "cycfn", ",", "conv", "=", "conv", ")", "return", "this" ]

[ "def", "paste_format", "(", "self", ")", ":", "row", ",", "col", ",", "tab", "=", "self", ".", "grid", ".", "actions", ".", "cursor", "selection", "=", "self", ".", "get_selection", "(", ")", "if", "selection", ":", "# Use selection rather than cursor for top left cell if present", "row", ",", "col", "=", "[", "tl", "if", "tl", "is", "not", "None", "else", "0", "for", "tl", "in", "selection", ".", "get_bbox", "(", ")", "[", "0", "]", "]", "cell_attributes", "=", "self", ".", "grid", ".", "code_array", ".", "cell_attributes", "string_data", "=", "self", ".", "grid", ".", "main_window", ".", "clipboard", ".", "get_clipboard", "(", ")", "format_data", "=", "ast", ".", "literal_eval", "(", "string_data", ")", "ca", "=", "format_data", "[", "\"cell_attributes\"", "]", "rh", "=", "format_data", "[", "\"row_heights\"", "]", "cw", "=", "format_data", "[", "\"col_widths\"", "]", "assert", "isinstance", "(", "ca", ",", "types", ".", "ListType", ")", "assert", "isinstance", "(", "rh", ",", "types", ".", "DictType", ")", "assert", "isinstance", "(", "cw", ",", "types", ".", "DictType", ")", "# Cell attributes", "for", "selection_params", ",", "tab", ",", "attrs", "in", "ca", ":", "base_selection", "=", "Selection", "(", "*", "selection_params", ")", "shifted_selection", "=", "base_selection", ".", "shifted", "(", "row", ",", "col", ")", "if", "\"merge_area\"", "not", "in", "attrs", ":", "# Do not paste merge areas because this may have", "# inintended consequences for existing merge areas", "new_cell_attribute", "=", "shifted_selection", ",", "tab", ",", "attrs", "cell_attributes", ".", "append", "(", "new_cell_attribute", ")", "# Row heights", "row_heights", "=", "self", ".", "grid", ".", "code_array", ".", "row_heights", "for", "__row", ",", "__tab", "in", "rh", ":", "row_heights", "[", "__row", "+", "row", ",", "tab", "]", "=", "rh", "[", "__row", ",", "__tab", "]", "# Column widths", "col_widths", "=", "self", ".", "grid", ".", "code_array", ".", "col_widths", "for", "__col", ",", "__tab", "in", "cw", ":", "col_widths", "[", "__col", "+", "col", ",", "tab", "]", "=", "cw", "[", "(", "__col", ",", "__tab", ")", "]" ]

[ "def", "determine_master", "(", "port", "=", "4000", ")", ":", "if", "os", ".", "environ", ".", "get", "(", "'SPARK_LOCAL_IP'", ")", ":", "return", "os", ".", "environ", "[", "'SPARK_LOCAL_IP'", "]", "+", "\":\"", "+", "str", "(", "port", ")", "else", ":", "return", "gethostbyname", "(", "gethostname", "(", ")", ")", "+", "\":\"", "+", "str", "(", "port", ")" ]

[ "async", "def", "parse_response", "(", "self", ")", ":", "code", ",", "rest", "=", "await", "self", ".", "parse_line", "(", ")", "info", "=", "[", "rest", "]", "curr_code", "=", "code", "while", "rest", ".", "startswith", "(", "\"-\"", ")", "or", "not", "curr_code", ".", "isdigit", "(", ")", ":", "curr_code", ",", "rest", "=", "await", "self", ".", "parse_line", "(", ")", "if", "curr_code", ".", "isdigit", "(", ")", ":", "info", ".", "append", "(", "rest", ")", "if", "curr_code", "!=", "code", ":", "raise", "errors", ".", "StatusCodeError", "(", "code", ",", "curr_code", ",", "info", ")", "else", ":", "info", ".", "append", "(", "curr_code", "+", "rest", ")", "return", "code", ",", "info" ]

[ "def", "add_requirement", "(", "self", ",", "install_req", ",", "# type: InstallRequirement", "parent_req_name", "=", "None", ",", "# type: Optional[str]", "extras_requested", "=", "None", "# type: Optional[Iterable[str]]", ")", ":", "# type: (...) -> Tuple[List[InstallRequirement], Optional[InstallRequirement]] # noqa: E501", "name", "=", "install_req", ".", "name", "# If the markers do not match, ignore this requirement.", "if", "not", "install_req", ".", "match_markers", "(", "extras_requested", ")", ":", "logger", ".", "info", "(", "\"Ignoring %s: markers '%s' don't match your environment\"", ",", "name", ",", "install_req", ".", "markers", ",", ")", "return", "[", "]", ",", "None", "# If the wheel is not supported, raise an error.", "# Should check this after filtering out based on environment markers to", "# allow specifying different wheels based on the environment/OS, in a", "# single requirements file.", "if", "install_req", ".", "link", "and", "install_req", ".", "link", ".", "is_wheel", ":", "wheel", "=", "Wheel", "(", "install_req", ".", "link", ".", "filename", ")", "if", "self", ".", "check_supported_wheels", "and", "not", "wheel", ".", "supported", "(", ")", ":", "raise", "InstallationError", "(", "\"%s is not a supported wheel on this platform.\"", "%", "wheel", ".", "filename", ")", "# This next bit is really a sanity check.", "assert", "install_req", ".", "is_direct", "==", "(", "parent_req_name", "is", "None", ")", ",", "(", "\"a direct req shouldn't have a parent and also, \"", "\"a non direct req should have a parent\"", ")", "# Unnamed requirements are scanned again and the requirement won't be", "# added as a dependency until after scanning.", "if", "not", "name", ":", "# url or path requirement w/o an egg fragment", "self", ".", "unnamed_requirements", ".", "append", "(", "install_req", ")", "return", "[", "install_req", "]", ",", "None", "try", ":", "existing_req", "=", "self", ".", "get_requirement", "(", "name", ")", "except", "KeyError", ":", "existing_req", "=", "None", "has_conflicting_requirement", "=", "(", "parent_req_name", "is", "None", "and", "existing_req", "and", "not", "existing_req", ".", "constraint", "and", "existing_req", ".", "extras", "==", "install_req", ".", "extras", "and", "existing_req", ".", "req", ".", "specifier", "!=", "install_req", ".", "req", ".", "specifier", ")", "if", "has_conflicting_requirement", ":", "raise", "InstallationError", "(", "\"Double requirement given: %s (already in %s, name=%r)\"", "%", "(", "install_req", ",", "existing_req", ",", "name", ")", ")", "# When no existing requirement exists, add the requirement as a", "# dependency and it will be scanned again after.", "if", "not", "existing_req", ":", "self", ".", "requirements", "[", "name", "]", "=", "install_req", "# FIXME: what about other normalizations? E.g., _ vs. -?", "if", "name", ".", "lower", "(", ")", "!=", "name", ":", "self", ".", "requirement_aliases", "[", "name", ".", "lower", "(", ")", "]", "=", "name", "# We'd want to rescan this requirements later", "return", "[", "install_req", "]", ",", "install_req", "# Assume there's no need to scan, and that we've already", "# encountered this for scanning.", "if", "install_req", ".", "constraint", "or", "not", "existing_req", ".", "constraint", ":", "return", "[", "]", ",", "existing_req", "does_not_satisfy_constraint", "=", "(", "install_req", ".", "link", "and", "not", "(", "existing_req", ".", "link", "and", "install_req", ".", "link", ".", "path", "==", "existing_req", ".", "link", ".", "path", ")", ")", "if", "does_not_satisfy_constraint", ":", "self", ".", "reqs_to_cleanup", ".", "append", "(", "install_req", ")", "raise", "InstallationError", "(", "\"Could not satisfy constraints for '%s': \"", "\"installation from path or url cannot be \"", "\"constrained to a version\"", "%", "name", ",", ")", "# If we're now installing a constraint, mark the existing", "# object for real installation.", "existing_req", ".", "constraint", "=", "False", "existing_req", ".", "extras", "=", "tuple", "(", "sorted", "(", "set", "(", "existing_req", ".", "extras", ")", "|", "set", "(", "install_req", ".", "extras", ")", ")", ")", "logger", ".", "debug", "(", "\"Setting %s extras to: %s\"", ",", "existing_req", ",", "existing_req", ".", "extras", ",", ")", "# Return the existing requirement for addition to the parent and", "# scanning again.", "return", "[", "existing_req", "]", ",", "existing_req" ]

[ "def", "find_item_in_path_by_type", "(", "self", ",", "si", ",", "path", ",", "obj_type", ")", ":", "if", "obj_type", "is", "None", ":", "return", "None", "search_index", "=", "si", ".", "content", ".", "searchIndex", "sub_folder", "=", "si", ".", "content", ".", "rootFolder", "if", "path", "is", "None", "or", "not", "path", ":", "return", "sub_folder", "paths", "=", "path", ".", "split", "(", "\"/\"", ")", "for", "currPath", "in", "paths", ":", "if", "currPath", "is", "None", "or", "not", "currPath", ":", "continue", "manage", "=", "search_index", ".", "FindChild", "(", "sub_folder", ",", "currPath", ")", "if", "isinstance", "(", "manage", ",", "obj_type", ")", ":", "return", "manage", "return", "None" ]

[ "def", "align_two_alignments", "(", "aln1", ",", "aln2", ",", "moltype", ",", "params", "=", "None", ")", ":", "#create SequenceCollection object from seqs", "aln1", "=", "Alignment", "(", "aln1", ",", "MolType", "=", "moltype", ")", "#Create mapping between abbreviated IDs and full IDs", "aln1_int_map", ",", "aln1_int_keys", "=", "aln1", ".", "getIntMap", "(", ")", "#Create SequenceCollection from int_map.", "aln1_int_map", "=", "Alignment", "(", "aln1_int_map", ",", "MolType", "=", "moltype", ")", "#create Alignment object from aln", "aln2", "=", "Alignment", "(", "aln2", ",", "MolType", "=", "moltype", ")", "#Create mapping between abbreviated IDs and full IDs", "aln2_int_map", ",", "aln2_int_keys", "=", "aln2", ".", "getIntMap", "(", "prefix", "=", "'seqn_'", ")", "#Create SequenceCollection from int_map.", "aln2_int_map", "=", "Alignment", "(", "aln2_int_map", ",", "MolType", "=", "moltype", ")", "#Update aln1_int_keys with aln2_int_keys", "aln1_int_keys", ".", "update", "(", "aln2_int_keys", ")", "#Create Mafft app.", "app", "=", "Clustalw", "(", "InputHandler", "=", "'_input_as_multiline_string'", ",", "params", "=", "params", ",", "SuppressStderr", "=", "True", ")", "app", ".", "Parameters", "[", "'-align'", "]", ".", "off", "(", ")", "app", ".", "Parameters", "[", "'-infile'", "]", ".", "off", "(", ")", "app", ".", "Parameters", "[", "'-profile'", "]", ".", "on", "(", ")", "#Add aln_int_map as profile1", "app", ".", "Parameters", "[", "'-profile1'", "]", ".", "on", "(", "app", ".", "_tempfile_as_multiline_string", "(", "aln1_int_map", ".", "toFasta", "(", ")", ")", ")", "#Add seq_int_map as profile2", "app", ".", "Parameters", "[", "'-profile2'", "]", ".", "on", "(", "app", ".", "_tempfile_as_multiline_string", "(", "aln2_int_map", ".", "toFasta", "(", ")", ")", ")", "#Get results using int_map as input to app", "res", "=", "app", "(", ")", "#Get alignment as dict out of results", "alignment", "=", "dict", "(", "ClustalParser", "(", "res", "[", "'Align'", "]", ".", "readlines", "(", ")", ")", ")", "#Make new dict mapping original IDs", "new_alignment", "=", "{", "}", "for", "k", ",", "v", "in", "alignment", ".", "items", "(", ")", ":", "new_alignment", "[", "aln1_int_keys", "[", "k", "]", "]", "=", "v", "#Create an Alignment object from alignment dict", "new_alignment", "=", "Alignment", "(", "new_alignment", ",", "MolType", "=", "moltype", ")", "#Clean up", "res", ".", "cleanUp", "(", ")", "remove", "(", "app", ".", "Parameters", "[", "'-profile1'", "]", ".", "Value", ")", "remove", "(", "app", ".", "Parameters", "[", "'-profile2'", "]", ".", "Value", ")", "del", "(", "aln1", ",", "aln1_int_map", ",", "aln1_int_keys", ",", "aln2", ",", "aln2_int_map", ",", "aln2_int_keys", ",", "app", ",", "res", ",", "alignment", ")", "return", "new_alignment" ]

[ "def", "run", "(", "connection", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "\"\"\"\n Process database dumps.\n\n Either download of upload a dump file to the objectstore.\n\n downloads the latest dump and uploads with envronment and date\n into given container destination\n \"\"\"", ")", "parser", ".", "add_argument", "(", "'location'", ",", "nargs", "=", "1", ",", "default", "=", "f'{DUMPFOLDER}/database.{ENV}.dump'", ",", "help", "=", "\"Dump file location\"", ")", "parser", ".", "add_argument", "(", "'objectstore'", ",", "nargs", "=", "1", ",", "default", "=", "f'{DUMPFOLDER}/database.{ENV}.dump'", ",", "help", "=", "\"Dump file objectstore location\"", ")", "parser", ".", "add_argument", "(", "'--download-db'", ",", "action", "=", "'store_true'", ",", "dest", "=", "'download'", ",", "default", "=", "False", ",", "help", "=", "'Download db'", ")", "parser", ".", "add_argument", "(", "'--upload-db'", ",", "action", "=", "'store_true'", ",", "dest", "=", "'upload'", ",", "default", "=", "False", ",", "help", "=", "'Upload db'", ")", "parser", ".", "add_argument", "(", "'--container'", ",", "action", "=", "'store_true'", ",", "dest", "=", "'container'", ",", "default", "=", "False", ",", "help", "=", "'Upload db'", ")", "parser", ".", "add_argument", "(", "'--days'", ",", "type", "=", "int", ",", "nargs", "=", "1", ",", "dest", "=", "'days'", ",", "default", "=", "0", ",", "help", "=", "'Days to keep database dumps'", ")", "args", "=", "parser", ".", "parse_args", "(", ")", "if", "args", ".", "days", ":", "LOG", ".", "debug", "(", "'Cleanup old dumps'", ")", "remove_old_dumps", "(", "connection", ",", "args", ".", "objectstore", "[", "0", "]", ",", "args", ".", "days", "[", "0", "]", ")", "elif", "args", ".", "download", ":", "download_database", "(", "connection", ",", "args", ".", "objectstore", "[", "0", "]", ",", "args", ".", "location", "[", "0", "]", ")", "elif", "args", ".", "upload", ":", "upload_database", "(", "connection", ",", "args", ".", "objectstore", "[", "0", "]", ",", "args", ".", "location", "[", "0", "]", ")", "else", ":", "parser", ".", "print_help", "(", ")" ]

[ "def", "url_for", "(", "context", ",", "__route_name", ",", "*", "*", "parts", ")", ":", "app", "=", "context", "[", "'app'", "]", "query", "=", "None", "if", "'query_'", "in", "parts", ":", "query", "=", "parts", ".", "pop", "(", "'query_'", ")", "for", "key", "in", "parts", ":", "val", "=", "parts", "[", "key", "]", "if", "isinstance", "(", "val", ",", "str", ")", ":", "# if type is inherited from str expilict cast to str makes sense", "# if type is exactly str the operation is very fast", "val", "=", "str", "(", "val", ")", "elif", "type", "(", "val", ")", "is", "int", ":", "# int inherited classes like bool are forbidden", "val", "=", "str", "(", "val", ")", "else", ":", "raise", "TypeError", "(", "\"argument value should be str or int, \"", "\"got {} -> [{}] {!r}\"", ".", "format", "(", "key", ",", "type", "(", "val", ")", ",", "val", ")", ")", "parts", "[", "key", "]", "=", "val", "url", "=", "app", ".", "router", "[", "__route_name", "]", ".", "url_for", "(", "*", "*", "parts", ")", "if", "query", ":", "url", "=", "url", ".", "with_query", "(", "query", ")", "return", "url" ]

[ "def", "complete", "(", "text", ",", "state", ")", ":", "global", "completion_results", "if", "state", "==", "0", ":", "line", "=", "readline", ".", "get_line_buffer", "(", ")", "if", "line", ".", "startswith", "(", "':'", ")", ":", "# Control command completion", "completion_results", "=", "complete_control_command", "(", "line", ",", "text", ")", "else", ":", "if", "line", ".", "startswith", "(", "'!'", ")", "and", "text", "and", "line", ".", "startswith", "(", "text", ")", ":", "dropped_exclam", "=", "True", "text", "=", "text", "[", "1", ":", "]", "else", ":", "dropped_exclam", "=", "False", "completion_results", "=", "[", "]", "# Complete local paths", "completion_results", "+=", "complete_local_path", "(", "text", ")", "# Complete from history", "l", "=", "len", "(", "text", ")", "completion_results", "+=", "[", "w", "+", "' '", "for", "w", "in", "history_words", "if", "len", "(", "w", ")", ">", "l", "and", "w", ".", "startswith", "(", "text", ")", "]", "if", "readline", ".", "get_begidx", "(", ")", "==", "0", ":", "# Completing first word from $PATH", "completion_results", "+=", "[", "w", "+", "' '", "for", "w", "in", "user_commands_in_path", "if", "len", "(", "w", ")", ">", "l", "and", "w", ".", "startswith", "(", "text", ")", "]", "completion_results", "=", "remove_dupes", "(", "completion_results", ")", "if", "dropped_exclam", ":", "completion_results", "=", "[", "'!'", "+", "r", "for", "r", "in", "completion_results", "]", "if", "state", "<", "len", "(", "completion_results", ")", ":", "return", "completion_results", "[", "state", "]", "completion_results", "=", "None", "return", "None" ]

[ "def", "_get_rev", "(", "self", ",", "fpath", ")", ":", "rev", "=", "None", "try", ":", "cmd", "=", "[", "\"git\"", ",", "\"log\"", ",", "\"-n1\"", ",", "\"--pretty=format:\\\"%h\\\"\"", ",", "fpath", "]", "rev", "=", "Popen", "(", "cmd", ",", "stdout", "=", "PIPE", ",", "stderr", "=", "PIPE", ")", ".", "communicate", "(", ")", "[", "0", "]", "except", ":", "pass", "if", "not", "rev", ":", "try", ":", "cmd", "=", "[", "\"svn\"", ",", "\"info\"", ",", "fpath", "]", "svninfo", "=", "Popen", "(", "cmd", ",", "stdout", "=", "PIPE", ",", "stderr", "=", "PIPE", ")", ".", "stdout", ".", "readlines", "(", ")", "for", "info", "in", "svninfo", ":", "tokens", "=", "info", ".", "split", "(", "\":\"", ")", "if", "tokens", "[", "0", "]", ".", "strip", "(", ")", "==", "\"Last Changed Rev\"", ":", "rev", "=", "tokens", "[", "1", "]", ".", "strip", "(", ")", "except", ":", "pass", "return", "rev" ]

[ "def", "newline", "(", "self", ",", "copy_margin", "=", "True", ")", ":", "if", "copy_margin", ":", "self", ".", "insert_text", "(", "'\\n'", "+", "self", ".", "document", ".", "leading_whitespace_in_current_line", ")", "else", ":", "self", ".", "insert_text", "(", "'\\n'", ")" ]

[ "def", "Produce_Predictions", "(", "FileName", ",", "train", ",", "test", ")", ":", "TestFileName", "=", "test", "TrainFileName", "=", "train", "trainDF", "=", "pd", ".", "read_csv", "(", "train", ")", "train", "=", "Feature_Engineering", "(", "train", ",", "trainDF", ")", "test", "=", "Feature_Engineering", "(", "test", ",", "trainDF", ")", "MLA", "=", "Create_Random_Forest", "(", "TrainFileName", ")", "predictions", "=", "MLA", ".", "predict", "(", "test", ")", "predictions", "=", "pd", ".", "DataFrame", "(", "predictions", ",", "columns", "=", "[", "'Survived'", "]", ")", "test", "=", "pd", ".", "read_csv", "(", "TestFileName", ")", "predictions", "=", "pd", ".", "concat", "(", "(", "test", ".", "iloc", "[", ":", ",", "0", "]", ",", "predictions", ")", ",", "axis", "=", "1", ")", "predictions", ".", "to_csv", "(", "FileName", ",", "sep", "=", "\",\"", ",", "index", "=", "False", ")" ]

[ "def", "get_dir_walker", "(", "recursive", ",", "topdown", "=", "True", ",", "followlinks", "=", "False", ")", ":", "if", "recursive", ":", "walk", "=", "partial", "(", "os", ".", "walk", ",", "topdown", "=", "topdown", ",", "followlinks", "=", "followlinks", ")", "else", ":", "def", "walk", "(", "path", ",", "topdown", "=", "topdown", ",", "followlinks", "=", "followlinks", ")", ":", "try", ":", "yield", "next", "(", "os", ".", "walk", "(", "path", ",", "topdown", "=", "topdown", ",", "followlinks", "=", "followlinks", ")", ")", "except", "NameError", ":", "yield", "os", ".", "walk", "(", "path", ",", "topdown", "=", "topdown", ",", "followlinks", "=", "followlinks", ")", ".", "next", "(", ")", "#IGNORE:E1101", "return", "walk" ]

[ "def", "close", "(", "self", ")", ":", "self", ".", "_outfile", ".", "write", "(", "struct", ".", "pack", "(", "'>2h'", ",", "4", ",", "0x0400", ")", ")", "if", "self", ".", "_close", ":", "self", ".", "_outfile", ".", "close", "(", ")" ]

[ "def", "preferred_height", "(", "self", ",", "cli", ",", "width", ",", "max_available_height", ",", "wrap_lines", ")", ":", "complete_state", "=", "cli", ".", "current_buffer", ".", "complete_state", "column_width", "=", "self", ".", "_get_column_width", "(", "complete_state", ")", "column_count", "=", "max", "(", "1", ",", "(", "width", "-", "self", ".", "_required_margin", ")", "//", "column_width", ")", "return", "int", "(", "math", ".", "ceil", "(", "len", "(", "complete_state", ".", "current_completions", ")", "/", "float", "(", "column_count", ")", ")", ")" ]

[ "def", "cli", "(", ")", ":", "args", "=", "docopt", ".", "docopt", "(", "__doc__", ",", "version", "=", "__VERSION__", ")", "secure", "=", "args", "[", "'--secure'", "]", "numberofwords", "=", "int", "(", "args", "[", "'<numberofwords>'", "]", ")", "dictpath", "=", "args", "[", "'--dict'", "]", "if", "dictpath", "is", "not", "None", ":", "dictfile", "=", "open", "(", "dictpath", ")", "else", ":", "dictfile", "=", "load_stream", "(", "'words.txt'", ")", "with", "dictfile", ":", "wordlist", "=", "read_wordlist", "(", "dictfile", ")", "words", "=", "generate_words", "(", "numberofwords", ",", "wordlist", ",", "secure", "=", "secure", ")", "print", "(", "' '", ".", "join", "(", "words", ")", ")" ]

[ "def", "infer_returned_object", "(", "pyfunction", ",", "args", ")", ":", "object_info", "=", "pyfunction", ".", "pycore", ".", "object_info", "result", "=", "object_info", ".", "get_exact_returned", "(", "pyfunction", ",", "args", ")", "if", "result", "is", "not", "None", ":", "return", "result", "result", "=", "_infer_returned", "(", "pyfunction", ",", "args", ")", "if", "result", "is", "not", "None", ":", "if", "args", "and", "pyfunction", ".", "get_module", "(", ")", ".", "get_resource", "(", ")", "is", "not", "None", ":", "params", "=", "args", ".", "get_arguments", "(", "pyfunction", ".", "get_param_names", "(", "special_args", "=", "False", ")", ")", "object_info", ".", "function_called", "(", "pyfunction", ",", "params", ",", "result", ")", "return", "result", "result", "=", "object_info", ".", "get_returned", "(", "pyfunction", ",", "args", ")", "if", "result", "is", "not", "None", ":", "return", "result", "hint_return", "=", "get_type_hinting_factory", "(", "pyfunction", ".", "pycore", ".", "project", ")", ".", "make_return_provider", "(", ")", "type_", "=", "hint_return", "(", "pyfunction", ")", "if", "type_", "is", "not", "None", ":", "return", "rope", ".", "base", ".", "pyobjects", ".", "PyObject", "(", "type_", ")" ]

[ "def", "_parsed_pkg_info", "(", "self", ")", ":", "try", ":", "return", "self", ".", "_pkg_info", "except", "AttributeError", ":", "from", "email", ".", "parser", "import", "Parser", "self", ".", "_pkg_info", "=", "Parser", "(", ")", ".", "parsestr", "(", "self", ".", "get_metadata", "(", "self", ".", "PKG_INFO", ")", ")", "return", "self", ".", "_pkg_info" ]

[ "def", "delete", "(", "self", ",", "accountId", ")", ":", "acct", "=", "BaseAccount", ".", "get", "(", "accountId", ")", "if", "not", "acct", ":", "raise", "Exception", "(", "'No such account found'", ")", "acct", ".", "delete", "(", ")", "auditlog", "(", "event", "=", "'account.delete'", ",", "actor", "=", "session", "[", "'user'", "]", ".", "username", ",", "data", "=", "{", "'accountId'", ":", "accountId", "}", ")", "return", "self", ".", "make_response", "(", "'Account deleted'", ")" ]

[ "def", "recipe", "(", "recipe", ")", ":", "env", ".", "host_string", "=", "lib", ".", "get_env_host_string", "(", ")", "lib", ".", "print_header", "(", "\"Applying recipe '{0}' on node {1}\"", ".", "format", "(", "recipe", ",", "env", ".", "host_string", ")", ")", "# Create configuration and sync node", "data", "=", "lib", ".", "get_node", "(", "env", ".", "host_string", ")", "data", "[", "\"run_list\"", "]", "=", "[", "\"recipe[{0}]\"", ".", "format", "(", "recipe", ")", "]", "if", "not", "__testing__", ":", "if", "env", ".", "autodeploy_chef", "and", "not", "chef", ".", "chef_test", "(", ")", ":", "deploy_chef", "(", "ask", "=", "\"no\"", ")", "chef", ".", "sync_node", "(", "data", ")" ]

[ "def", "get_stakes", "(", "self", ")", ":", "query", "=", "\"\"\"\n query {\n user {\n stakeTxs {\n confidence\n insertedAt\n roundNumber\n tournamentId\n soc\n staker\n status\n txHash\n value\n }\n }\n }\n \"\"\"", "data", "=", "self", ".", "raw_query", "(", "query", ",", "authorization", "=", "True", ")", "[", "'data'", "]", "stakes", "=", "data", "[", "'user'", "]", "[", "'stakeTxs'", "]", "# convert strings to python objects", "for", "s", "in", "stakes", ":", "utils", ".", "replace", "(", "s", ",", "\"insertedAt\"", ",", "utils", ".", "parse_datetime_string", ")", "utils", ".", "replace", "(", "s", ",", "\"soc\"", ",", "utils", ".", "parse_float_string", ")", "utils", ".", "replace", "(", "s", ",", "\"confidence\"", ",", "utils", ".", "parse_float_string", ")", "utils", ".", "replace", "(", "s", ",", "\"value\"", ",", "utils", ".", "parse_float_string", ")", "return", "stakes" ]

[ "def", "time", "(", "self", ")", ":", "if", "(", "(", "self", ".", "_ccore_sync_dynamic_pointer", "is", "not", "None", ")", "and", "(", "(", "self", ".", "_time", "is", "None", ")", "or", "(", "len", "(", "self", ".", "_time", ")", "==", "0", ")", ")", ")", ":", "self", ".", "_time", "=", "wrapper", ".", "sync_dynamic_get_time", "(", "self", ".", "_ccore_sync_dynamic_pointer", ")", "return", "self", ".", "_time" ]

[ "def", "xyplot", "(", "points", ",", "title", "=", "\"\"", ",", "c", "=", "\"b\"", ",", "corner", "=", "1", ",", "lines", "=", "False", ")", ":", "c", "=", "vc", ".", "getColor", "(", "c", ")", "# allow different codings", "array_x", "=", "vtk", ".", "vtkFloatArray", "(", ")", "array_y", "=", "vtk", ".", "vtkFloatArray", "(", ")", "array_x", ".", "SetNumberOfTuples", "(", "len", "(", "points", ")", ")", "array_y", ".", "SetNumberOfTuples", "(", "len", "(", "points", ")", ")", "for", "i", ",", "p", "in", "enumerate", "(", "points", ")", ":", "array_x", ".", "InsertValue", "(", "i", ",", "p", "[", "0", "]", ")", "array_y", ".", "InsertValue", "(", "i", ",", "p", "[", "1", "]", ")", "field", "=", "vtk", ".", "vtkFieldData", "(", ")", "field", ".", "AddArray", "(", "array_x", ")", "field", ".", "AddArray", "(", "array_y", ")", "data", "=", "vtk", ".", "vtkDataObject", "(", ")", "data", ".", "SetFieldData", "(", "field", ")", "plot", "=", "vtk", ".", "vtkXYPlotActor", "(", ")", "plot", ".", "AddDataObjectInput", "(", "data", ")", "plot", ".", "SetDataObjectXComponent", "(", "0", ",", "0", ")", "plot", ".", "SetDataObjectYComponent", "(", "0", ",", "1", ")", "plot", ".", "SetXValuesToValue", "(", ")", "plot", ".", "SetXTitle", "(", "title", ")", "plot", ".", "SetYTitle", "(", "\"\"", ")", "plot", ".", "ExchangeAxesOff", "(", ")", "plot", ".", "PlotPointsOn", "(", ")", "if", "not", "lines", ":", "plot", ".", "PlotLinesOff", "(", ")", "plot", ".", "GetProperty", "(", ")", ".", "SetPointSize", "(", "5", ")", "plot", ".", "GetProperty", "(", ")", ".", "SetLineWidth", "(", "2", ")", "plot", ".", "SetNumberOfXLabels", "(", "3", ")", "# not working", "plot", ".", "GetProperty", "(", ")", ".", "SetColor", "(", "0", ",", "0", ",", "0", ")", "plot", ".", "GetProperty", "(", ")", ".", "SetOpacity", "(", "0.7", ")", "plot", ".", "SetPlotColor", "(", "0", ",", "c", "[", "0", "]", ",", "c", "[", "1", "]", ",", "c", "[", "2", "]", ")", "tprop", "=", "plot", ".", "GetAxisLabelTextProperty", "(", ")", "tprop", ".", "SetColor", "(", "0", ",", "0", ",", "0", ")", "tprop", ".", "SetOpacity", "(", "0.7", ")", "tprop", ".", "SetFontFamily", "(", "0", ")", "tprop", ".", "BoldOff", "(", ")", "tprop", ".", "ItalicOff", "(", ")", "tprop", ".", "ShadowOff", "(", ")", "tprop", ".", "SetFontSize", "(", "3", ")", "# not working", "plot", ".", "SetAxisTitleTextProperty", "(", "tprop", ")", "plot", ".", "SetAxisLabelTextProperty", "(", "tprop", ")", "plot", ".", "SetTitleTextProperty", "(", "tprop", ")", "if", "corner", "==", "1", ":", "plot", ".", "GetPositionCoordinate", "(", ")", ".", "SetValue", "(", "0.0", ",", "0.8", ",", "0", ")", "if", "corner", "==", "2", ":", "plot", ".", "GetPositionCoordinate", "(", ")", ".", "SetValue", "(", "0.7", ",", "0.8", ",", "0", ")", "if", "corner", "==", "3", ":", "plot", ".", "GetPositionCoordinate", "(", ")", ".", "SetValue", "(", "0.0", ",", "0.0", ",", "0", ")", "if", "corner", "==", "4", ":", "plot", ".", "GetPositionCoordinate", "(", ")", ".", "SetValue", "(", "0.7", ",", "0.0", ",", "0", ")", "plot", ".", "GetPosition2Coordinate", "(", ")", ".", "SetValue", "(", "0.3", ",", "0.2", ",", "0", ")", "return", "plot" ]

[ "def", "all_nonperiodic_features", "(", "times", ",", "mags", ",", "errs", ",", "magsarefluxes", "=", "False", ",", "stetson_weightbytimediff", "=", "True", ")", ":", "# remove nans first", "finiteind", "=", "npisfinite", "(", "times", ")", "&", "npisfinite", "(", "mags", ")", "&", "npisfinite", "(", "errs", ")", "ftimes", ",", "fmags", ",", "ferrs", "=", "times", "[", "finiteind", "]", ",", "mags", "[", "finiteind", "]", ",", "errs", "[", "finiteind", "]", "# remove zero errors", "nzind", "=", "npnonzero", "(", "ferrs", ")", "ftimes", ",", "fmags", ",", "ferrs", "=", "ftimes", "[", "nzind", "]", ",", "fmags", "[", "nzind", "]", ",", "ferrs", "[", "nzind", "]", "xfeatures", "=", "nonperiodic_lightcurve_features", "(", "times", ",", "mags", ",", "errs", ",", "magsarefluxes", "=", "magsarefluxes", ")", "stetj", "=", "stetson_jindex", "(", "ftimes", ",", "fmags", ",", "ferrs", ",", "weightbytimediff", "=", "stetson_weightbytimediff", ")", "stetk", "=", "stetson_kindex", "(", "fmags", ",", "ferrs", ")", "xfeatures", ".", "update", "(", "{", "'stetsonj'", ":", "stetj", ",", "'stetsonk'", ":", "stetk", "}", ")", "return", "xfeatures" ]

[ "def", "dumps", "(", "obj", ",", "protocol", "=", "None", ")", ":", "file", "=", "StringIO", "(", ")", "try", ":", "cp", "=", "CloudPickler", "(", "file", ",", "protocol", "=", "protocol", ")", "cp", ".", "dump", "(", "obj", ")", "return", "file", ".", "getvalue", "(", ")", "finally", ":", "file", ".", "close", "(", ")" ]

[ "def", "__process_node", "(", "self", ",", "node", ":", "yaml", ".", "Node", ",", "expected_type", ":", "Type", ")", "->", "yaml", ".", "Node", ":", "logger", ".", "info", "(", "'Processing node {} expecting type {}'", ".", "format", "(", "node", ",", "expected_type", ")", ")", "# figure out how to interpret this node", "recognized_types", ",", "message", "=", "self", ".", "__recognizer", ".", "recognize", "(", "node", ",", "expected_type", ")", "if", "len", "(", "recognized_types", ")", "!=", "1", ":", "raise", "RecognitionError", "(", "message", ")", "recognized_type", "=", "recognized_types", "[", "0", "]", "# remove syntactic sugar", "logger", ".", "debug", "(", "'Savorizing node {}'", ".", "format", "(", "node", ")", ")", "if", "recognized_type", "in", "self", ".", "_registered_classes", ".", "values", "(", ")", ":", "node", "=", "self", ".", "__savorize", "(", "node", ",", "recognized_type", ")", "logger", ".", "debug", "(", "'Savorized, now {}'", ".", "format", "(", "node", ")", ")", "# process subnodes", "logger", ".", "debug", "(", "'Recursing into subnodes'", ")", "if", "is_generic_list", "(", "recognized_type", ")", ":", "if", "node", ".", "tag", "!=", "'tag:yaml.org,2002:seq'", ":", "raise", "RecognitionError", "(", "'{}{}Expected a {} here'", ".", "format", "(", "node", ".", "start_mark", ",", "os", ".", "linesep", ",", "type_to_desc", "(", "expected_type", ")", ")", ")", "for", "item", "in", "node", ".", "value", ":", "self", ".", "__process_node", "(", "item", ",", "generic_type_args", "(", "recognized_type", ")", "[", "0", "]", ")", "elif", "is_generic_dict", "(", "recognized_type", ")", ":", "if", "node", ".", "tag", "!=", "'tag:yaml.org,2002:map'", ":", "raise", "RecognitionError", "(", "'{}{}Expected a {} here'", ".", "format", "(", "node", ".", "start_mark", ",", "os", ".", "linesep", ",", "type_to_desc", "(", "expected_type", ")", ")", ")", "for", "_", ",", "value_node", "in", "node", ".", "value", ":", "self", ".", "__process_node", "(", "value_node", ",", "generic_type_args", "(", "recognized_type", ")", "[", "1", "]", ")", "elif", "recognized_type", "in", "self", ".", "_registered_classes", ".", "values", "(", ")", ":", "if", "(", "not", "issubclass", "(", "recognized_type", ",", "enum", ".", "Enum", ")", "and", "not", "issubclass", "(", "recognized_type", ",", "str", ")", "and", "not", "issubclass", "(", "recognized_type", ",", "UserString", ")", ")", ":", "for", "attr_name", ",", "type_", ",", "_", "in", "class_subobjects", "(", "recognized_type", ")", ":", "cnode", "=", "Node", "(", "node", ")", "if", "cnode", ".", "has_attribute", "(", "attr_name", ")", ":", "subnode", "=", "cnode", ".", "get_attribute", "(", "attr_name", ")", "new_subnode", "=", "self", ".", "__process_node", "(", "subnode", ".", "yaml_node", ",", "type_", ")", "cnode", ".", "set_attribute", "(", "attr_name", ",", "new_subnode", ")", "else", ":", "logger", ".", "debug", "(", "'Not a generic class or a user-defined class, not'", "' recursing'", ")", "node", ".", "tag", "=", "self", ".", "__type_to_tag", "(", "recognized_type", ")", "logger", ".", "debug", "(", "'Finished processing node {}'", ".", "format", "(", "node", ")", ")", "return", "node" ]

[ "def", "kallisto_table", "(", "kallisto_dir", ",", "index", ")", ":", "quant_dir", "=", "os", ".", "path", ".", "join", "(", "kallisto_dir", ",", "\"quant\"", ")", "out_file", "=", "os", ".", "path", ".", "join", "(", "quant_dir", ",", "\"matrix.csv\"", ")", "if", "file_exists", "(", "out_file", ")", ":", "return", "out_file", "tsvfile", "=", "os", ".", "path", ".", "join", "(", "quant_dir", ",", "\"matrix.tsv\"", ")", "ecfile", "=", "os", ".", "path", ".", "join", "(", "quant_dir", ",", "\"matrix.ec\"", ")", "cellsfile", "=", "os", ".", "path", ".", "join", "(", "quant_dir", ",", "\"matrix.cells\"", ")", "fastafile", "=", "os", ".", "path", ".", "splitext", "(", "index", ")", "[", "0", "]", "+", "\".fa\"", "fasta_names", "=", "fasta", ".", "sequence_names", "(", "fastafile", ")", "ec_names", "=", "get_ec_names", "(", "ecfile", ",", "fasta_names", ")", "df", "=", "pd", ".", "read_table", "(", "tsvfile", ",", "header", "=", "None", ",", "names", "=", "[", "\"ec\"", ",", "\"cell\"", ",", "\"count\"", "]", ")", "df", "[", "\"ec\"", "]", "=", "[", "ec_names", "[", "x", "]", "for", "x", "in", "df", "[", "\"ec\"", "]", "]", "df", "=", "df", ".", "pivot", "(", "index", "=", "'ec'", ",", "columns", "=", "'cell'", ",", "values", "=", "'count'", ")", "cellnames", "=", "get_cell_names", "(", "cellsfile", ")", "colnames", "=", "[", "cellnames", "[", "x", "]", "for", "x", "in", "df", ".", "columns", "]", "df", ".", "columns", "=", "colnames", "df", ".", "to_csv", "(", "out_file", ")", "return", "out_file" ]

[ "def", "_parse_00", "(", "ofile", ")", ":", "with", "open", "(", "ofile", ")", "as", "infile", ":", "## read in the results summary from the end of the outfile", "arr", "=", "np", ".", "array", "(", "[", "\" \"", "]", "+", "infile", ".", "read", "(", ")", ".", "split", "(", "\"Summary of MCMC results\\n\\n\\n\"", ")", "[", "1", ":", "]", "[", "0", "]", ".", "strip", "(", ")", ".", "split", "(", ")", ")", "## reshape array ", "rows", "=", "12", "cols", "=", "(", "arr", ".", "shape", "[", "0", "]", "+", "1", ")", "/", "rows", "arr", "=", "arr", ".", "reshape", "(", "rows", ",", "cols", ")", "## make into labeled data frame", "df", "=", "pd", ".", "DataFrame", "(", "data", "=", "arr", "[", "1", ":", ",", "1", ":", "]", ",", "columns", "=", "arr", "[", "0", ",", "1", ":", "]", ",", "index", "=", "arr", "[", "1", ":", ",", "0", "]", ",", ")", ".", "T", "return", "df" ]

[ "def", "query_cached_package_list", "(", "self", ")", ":", "if", "self", ".", "debug", ":", "self", ".", "logger", ".", "debug", "(", "\"DEBUG: reading pickled cache file\"", ")", "return", "cPickle", ".", "load", "(", "open", "(", "self", ".", "pkg_cache_file", ",", "\"r\"", ")", ")" ]

[ "def", "network_del_notif", "(", "self", ",", "tenant_id", ",", "tenant_name", ",", "net_id", ")", ":", "if", "not", "self", ".", "fw_init", ":", "return", "self", ".", "network_delete_notif", "(", "tenant_id", ",", "tenant_name", ",", "net_id", ")" ]

[ "def", "_printTraceback", "(", "self", ",", "test", ",", "err", ")", ":", "# Don't bind third item to a local var; that can create", "# circular refs which are expensive to collect. See the", "# sys.exc_info() docs.", "exception_type", ",", "exception_value", "=", "err", "[", ":", "2", "]", "# TODO: In Python 3, the traceback is attached to the exception", "# instance through the __traceback__ attribute. If the instance", "# is saved in a local variable that persists outside the except", "# block, the traceback will create a reference cycle with the", "# current frame and its dictionary of local variables. This will", "# delay reclaiming dead resources until the next cyclic garbage", "# collection pass.", "extracted_tb", "=", "extract_relevant_tb", "(", "err", "[", "2", "]", ",", "exception_type", ",", "exception_type", "is", "test", ".", "failureException", ")", "test_frame_index", "=", "index_of_test_frame", "(", "extracted_tb", ",", "exception_type", ",", "exception_value", ",", "test", ")", "if", "test_frame_index", ":", "# We have a good guess at which frame is the test, so", "# trim everything until that. We don't care to see test", "# framework frames.", "extracted_tb", "=", "extracted_tb", "[", "test_frame_index", ":", "]", "with", "self", ".", "bar", ".", "dodging", "(", ")", ":", "self", ".", "stream", ".", "write", "(", "''", ".", "join", "(", "format_traceback", "(", "extracted_tb", ",", "exception_type", ",", "exception_value", ",", "self", ".", "_cwd", ",", "self", ".", "_term", ",", "self", ".", "_options", ".", "function_color", ",", "self", ".", "_options", ".", "dim_color", ",", "self", ".", "_options", ".", "editor", ",", "self", ".", "_options", ".", "editor_shortcut_template", ")", ")", ")" ]

[ "def", "_advapi32_encrypt", "(", "cipher", ",", "key", ",", "data", ",", "iv", ",", "padding", ")", ":", "context_handle", "=", "None", "key_handle", "=", "None", "try", ":", "context_handle", ",", "key_handle", "=", "_advapi32_create_handles", "(", "cipher", ",", "key", ",", "iv", ")", "out_len", "=", "new", "(", "advapi32", ",", "'DWORD *'", ",", "len", "(", "data", ")", ")", "res", "=", "advapi32", ".", "CryptEncrypt", "(", "key_handle", ",", "null", "(", ")", ",", "True", ",", "0", ",", "null", "(", ")", ",", "out_len", ",", "0", ")", "handle_error", "(", "res", ")", "buffer_len", "=", "deref", "(", "out_len", ")", "buffer", "=", "buffer_from_bytes", "(", "buffer_len", ")", "write_to_buffer", "(", "buffer", ",", "data", ")", "pointer_set", "(", "out_len", ",", "len", "(", "data", ")", ")", "res", "=", "advapi32", ".", "CryptEncrypt", "(", "key_handle", ",", "null", "(", ")", ",", "True", ",", "0", ",", "buffer", ",", "out_len", ",", "buffer_len", ")", "handle_error", "(", "res", ")", "output", "=", "bytes_from_buffer", "(", "buffer", ",", "deref", "(", "out_len", ")", ")", "# Remove padding when not required. CryptoAPI doesn't support this, so", "# we just manually remove it.", "if", "cipher", "==", "'aes'", "and", "not", "padding", ":", "if", "output", "[", "-", "16", ":", "]", "!=", "(", "b'\\x10'", "*", "16", ")", ":", "raise", "ValueError", "(", "'Invalid padding generated by OS crypto library'", ")", "output", "=", "output", "[", ":", "-", "16", "]", "return", "output", "finally", ":", "if", "key_handle", ":", "advapi32", ".", "CryptDestroyKey", "(", "key_handle", ")", "if", "context_handle", ":", "close_context_handle", "(", "context_handle", ")" ]

[ "def", "add", "(", "self", ",", "bounds1", ",", "label1", ",", "bounds2", ",", "label2", ",", "bin3", ",", "label3", ",", "data_label", ")", ":", "# TODO Update for 2.7 compatability.", "if", "isinstance", "(", "data_label", ",", "str", ")", ":", "data_label", "=", "[", "data_label", ",", "]", "elif", "not", "isinstance", "(", "data_label", ",", "collections", ".", "Sequence", ")", ":", "raise", "ValueError", "(", "\"Please pass data_label as a string or \"", "\"collection of strings.\"", ")", "# Modeled after pysat.ssnl.median2D", "# Make bin boundaries.", "# y: values at label3", "# z: *data_labels", "biny", "=", "np", ".", "linspace", "(", "bin3", "[", "0", "]", ",", "bin3", "[", "1", "]", ",", "bin3", "[", "2", "]", "+", "1", ")", "numy", "=", "len", "(", "biny", ")", "-", "1", "numz", "=", "len", "(", "data_label", ")", "# Ranges", "yarr", ",", "zarr", "=", "map", "(", "np", ".", "arange", ",", "(", "numy", ",", "numz", ")", ")", "# Store data here.", "ans", "=", "[", "[", "[", "collections", ".", "deque", "(", ")", "]", "for", "j", "in", "yarr", "]", "for", "k", "in", "zarr", "]", "# Filter data by bounds and bin it.", "# Idiom for loading all of the data in an instrument's bounds.", "for", "inst", "in", "self", ":", "for", "inst", "in", "inst", ":", "if", "len", "(", "inst", ".", "data", ")", "!=", "0", ":", "# Select indicies for each piece of data we're interest in.", "# Not all of this data is in bounds on label3 but we'll", "# sort this later.", "min1", ",", "max1", "=", "bounds1", "min2", ",", "max2", "=", "bounds2", "data1", "=", "inst", ".", "data", "[", "label1", "]", "data2", "=", "inst", ".", "data", "[", "label2", "]", "in_bounds", ",", "=", "np", ".", "where", "(", "(", "min1", "<=", "data1", ")", "&", "(", "data1", "<", "max1", ")", "&", "(", "min2", "<=", "data2", ")", "&", "(", "data2", "<", "max2", ")", ")", "# Grab the data in bounds on data1, data2.", "data_considered", "=", "inst", ".", "data", ".", "iloc", "[", "in_bounds", "]", "y_indexes", "=", "np", ".", "digitize", "(", "data_considered", "[", "label3", "]", ",", "biny", ")", "-", "1", "# Iterate over the bins along y", "for", "yj", "in", "yarr", ":", "# Indicies of data in this bin", "yindex", ",", "=", "np", ".", "where", "(", "y_indexes", "==", "yj", ")", "# If there's data in this bin", "if", "len", "(", "yindex", ")", ">", "0", ":", "# For each data label, add the points.", "for", "zk", "in", "zarr", ":", "ans", "[", "zk", "]", "[", "yj", "]", "[", "0", "]", ".", "extend", "(", "data_considered", ".", "ix", "[", "yindex", ",", "data_label", "[", "zk", "]", "]", ".", "tolist", "(", ")", ")", "# Now for the averaging.", "# Let's, try .. packing the answers for the 2d function.", "numx", "=", "1", "xarr", "=", "np", ".", "arange", "(", "numx", ")", "binx", "=", "None", "# TODO modify output", "out_2d", "=", "_calc_2d_median", "(", "ans", ",", "data_label", ",", "binx", ",", "biny", ",", "xarr", ",", "yarr", ",", "zarr", ",", "numx", ",", "numy", ",", "numz", ")", "# Transform output", "output", "=", "{", "}", "for", "i", ",", "label", "in", "enumerate", "(", "data_label", ")", ":", "median", "=", "[", "r", "[", "0", "]", "for", "r", "in", "out_2d", "[", "label", "]", "[", "'median'", "]", "]", "count", "=", "[", "r", "[", "0", "]", "for", "r", "in", "out_2d", "[", "label", "]", "[", "'count'", "]", "]", "dev", "=", "[", "r", "[", "0", "]", "for", "r", "in", "out_2d", "[", "label", "]", "[", "'avg_abs_dev'", "]", "]", "output", "[", "label", "]", "=", "{", "'median'", ":", "median", ",", "'count'", ":", "count", ",", "'avg_abs_dev'", ":", "dev", ",", "'bin'", ":", "out_2d", "[", "label", "]", "[", "'bin_y'", "]", "}", "return", "output" ]

[ "def", "_analyze", "(", "self", ")", ":", "if", "not", "self", ".", "analysis", ":", "for", "dseries", "in", "self", ".", "data_series", ":", "# Count number of non-NaN rows", "dseries_count", "=", "self", ".", "df", "[", "dseries", "]", ".", "count", "(", ")", "assert", "(", "len", "(", "self", ".", "df_pruned", ")", "<=", "dseries_count", "<=", "len", "(", "self", ".", "df", ")", "or", "dseries_count", ")", "self", ".", "analysis", "[", "dseries", "]", "=", "dict", "(", "partial", "=", "None", ",", "full", "=", "None", ",", ")", "# Compute the statistics for the common records", "stats", "=", "get_xy_dataset_statistics_pandas", "(", "self", ".", "df_pruned", ",", "self", ".", "reference_series", ",", "dseries", ",", "fcorrect_x_cutoff", "=", "1.0", ",", "fcorrect_y_cutoff", "=", "1.0", ",", "bootstrap_data", "=", "False", ",", "x_fuzzy_range", "=", "0.1", ",", "y_scalar", "=", "1.0", ",", "ignore_null_values", "=", "True", ")", "if", "(", "len", "(", "self", ".", "df_pruned", ")", "==", "len", "(", "self", ".", "df", ")", ")", ":", "# There are no pruned records so these are actually the full stats", "self", ".", "analysis", "[", "dseries", "]", "[", "'full'", "]", "=", "dict", "(", "data", "=", "stats", ",", "description", "=", "format_stats", "(", "stats", ",", "floating_point_format", "=", "'%0.3f'", ",", "sci_notation_format", "=", "'%.2E'", ",", "return_string", "=", "True", ")", ")", "else", ":", "# Store the results for the partial dataset", "self", ".", "analysis", "[", "dseries", "]", "[", "'partial'", "]", "=", "dict", "(", "data", "=", "stats", ",", "description", "=", "format_stats", "(", "stats", ",", "floating_point_format", "=", "'%0.3f'", ",", "sci_notation_format", "=", "'%.2E'", ",", "return_string", "=", "True", ")", ")", "if", "dseries_count", ">", "len", "(", "self", ".", "df_pruned", ")", ":", "# This dataset has records which are not in the pruned dataset", "stats", "=", "get_xy_dataset_statistics_pandas", "(", "self", ".", "df", ",", "self", ".", "reference_series", ",", "dseries", ",", "fcorrect_x_cutoff", "=", "1.0", ",", "fcorrect_y_cutoff", "=", "1.0", ",", "bootstrap_data", "=", "False", ",", "x_fuzzy_range", "=", "0.1", ",", "y_scalar", "=", "1.0", ",", "ignore_null_values", "=", "True", ")", "self", ".", "analysis", "[", "dseries", "]", "[", "'full'", "]", "=", "dict", "(", "data", "=", "stats", ",", "description", "=", "format_stats", "(", "stats", ",", "floating_point_format", "=", "'%0.3f'", ",", "sci_notation_format", "=", "'%.2E'", ",", "return_string", "=", "True", ")", ")", "return", "self", ".", "analysis" ]

[ "def", "to_dict", "(", "self", ",", "*", "*", "kw", ")", ":", "_", ",", "value", "=", "helpers", ".", "etree_to_dict", "(", "self", ".", "_xml", ",", "*", "*", "kw", ")", ".", "popitem", "(", ")", "return", "value" ]

[ "def", "networkBibCoupling", "(", "self", ",", "weighted", "=", "True", ",", "fullInfo", "=", "False", ",", "addCR", "=", "False", ")", ":", "progArgs", "=", "(", "0", ",", "\"Make a citation network for coupling\"", ")", "if", "metaknowledge", ".", "VERBOSE_MODE", ":", "progKwargs", "=", "{", "'dummy'", ":", "False", "}", "else", ":", "progKwargs", "=", "{", "'dummy'", ":", "True", "}", "with", "_ProgressBar", "(", "*", "progArgs", ",", "*", "*", "progKwargs", ")", "as", "PBar", ":", "citeGrph", "=", "self", ".", "networkCitation", "(", "weighted", "=", "False", ",", "directed", "=", "True", ",", "detailedCore", "=", "True", ",", "fullInfo", "=", "fullInfo", ",", "count", "=", "False", ",", "nodeInfo", "=", "True", ",", "addCR", "=", "addCR", ",", "_quiet", "=", "True", ")", "pcount", "=", "0", "pmax", "=", "len", "(", "citeGrph", ")", "PBar", ".", "updateVal", "(", ".2", ",", "\"Starting to classify nodes\"", ")", "workingGrph", "=", "nx", ".", "Graph", "(", ")", "couplingSet", "=", "set", "(", ")", "for", "n", ",", "d", "in", "citeGrph", ".", "nodes", "(", "data", "=", "True", ")", ":", "pcount", "+=", "1", "PBar", ".", "updateVal", "(", ".2", "+", ".4", "*", "(", "pcount", "/", "pmax", ")", ",", "\"Classifying: {}\"", ".", "format", "(", "n", ")", ")", "if", "d", "[", "'inCore'", "]", ":", "workingGrph", ".", "add_node", "(", "n", ",", "*", "*", "d", ")", "if", "citeGrph", ".", "in_degree", "(", "n", ")", ">", "0", ":", "couplingSet", ".", "add", "(", "n", ")", "pcount", "=", "0", "pmax", "=", "len", "(", "couplingSet", ")", "for", "n", "in", "couplingSet", ":", "PBar", ".", "updateVal", "(", ".6", "+", ".4", "*", "(", "pcount", "/", "pmax", ")", ",", "\"Coupling: {}\"", ".", "format", "(", "n", ")", ")", "citesLst", "=", "list", "(", "citeGrph", ".", "in_edges", "(", "n", ")", ")", "for", "i", ",", "edgeOuter", "in", "enumerate", "(", "citesLst", ")", ":", "outerNode", "=", "edgeOuter", "[", "0", "]", "for", "edgeInner", "in", "citesLst", "[", "i", "+", "1", ":", "]", ":", "innerNode", "=", "edgeInner", "[", "0", "]", "if", "weighted", "and", "workingGrph", ".", "has_edge", "(", "outerNode", ",", "innerNode", ")", ":", "workingGrph", ".", "edges", "[", "outerNode", ",", "innerNode", "]", "[", "'weight'", "]", "+=", "1", "elif", "weighted", ":", "workingGrph", ".", "add_edge", "(", "outerNode", ",", "innerNode", ",", "weight", "=", "1", ")", "else", ":", "workingGrph", ".", "add_edge", "(", "outerNode", ",", "innerNode", ")", "PBar", ".", "finish", "(", "\"Done making a bib-coupling network from {}\"", ".", "format", "(", "self", ")", ")", "return", "workingGrph" ]

[ "def", "put", "(", "self", ")", ":", "cred_payload", "=", "utils", ".", "uni_to_str", "(", "json", ".", "loads", "(", "request", ".", "get_data", "(", ")", ")", ")", "return", "self", ".", "manager", ".", "update_credential", "(", "cred_payload", ")" ]

[ "def", "publish_collated_document", "(", "cursor", ",", "model", ",", "parent_model", ")", ":", "html", "=", "bytes", "(", "cnxepub", ".", "DocumentContentFormatter", "(", "model", ")", ")", "sha1", "=", "hashlib", ".", "new", "(", "'sha1'", ",", "html", ")", ".", "hexdigest", "(", ")", "cursor", ".", "execute", "(", "\"SELECT fileid FROM files WHERE sha1 = %s\"", ",", "(", "sha1", ",", ")", ")", "try", ":", "fileid", "=", "cursor", ".", "fetchone", "(", ")", "[", "0", "]", "except", "TypeError", ":", "file_args", "=", "{", "'media_type'", ":", "'text/html'", ",", "'data'", ":", "psycopg2", ".", "Binary", "(", "html", ")", ",", "}", "cursor", ".", "execute", "(", "\"\"\"\\\n INSERT INTO files (file, media_type)\n VALUES (%(data)s, %(media_type)s)\n RETURNING fileid\"\"\"", ",", "file_args", ")", "fileid", "=", "cursor", ".", "fetchone", "(", ")", "[", "0", "]", "args", "=", "{", "'module_ident_hash'", ":", "model", ".", "ident_hash", ",", "'parent_ident_hash'", ":", "parent_model", ".", "ident_hash", ",", "'fileid'", ":", "fileid", ",", "}", "stmt", "=", "\"\"\"\\\nINSERT INTO collated_file_associations (context, item, fileid)\nVALUES\n ((SELECT module_ident FROM modules\n WHERE ident_hash(uuid, major_version, minor_version)\n = %(parent_ident_hash)s),\n (SELECT module_ident FROM modules\n WHERE ident_hash(uuid, major_version, minor_version)\n = %(module_ident_hash)s),\n %(fileid)s)\"\"\"", "cursor", ".", "execute", "(", "stmt", ",", "args", ")" ]

[ "def", "get_config", "(", "self", ",", "force", "=", "False", ")", ":", "if", "not", "force", "and", "not", "self", ".", "has_config", "(", ")", ":", "raise", "Exception", "(", "'No config file'", ")", "configxml", "=", "os", ".", "path", ".", "join", "(", "self", ".", "dir", ",", "'etc'", ",", "'grid'", ",", "'config.xml'", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "configxml", ")", ":", "raise", "Exception", "(", "'No config file'", ")", "try", ":", "# Attempt to open config.xml read-only, though this flag is not", "# present in early versions of OMERO 5.0", "c", "=", "self", ".", "_omero", ".", "config", ".", "ConfigXml", "(", "configxml", ",", "exclusive", "=", "False", ",", "read_only", "=", "True", ")", "except", "TypeError", ":", "c", "=", "self", ".", "_omero", ".", "config", ".", "ConfigXml", "(", "configxml", ",", "exclusive", "=", "False", ")", "try", ":", "return", "c", ".", "as_map", "(", ")", "finally", ":", "c", ".", "close", "(", ")" ]

[ "def", "chop", "(", "self", ",", "bits", "=", "1", ")", ":", "s", "=", "len", "(", "self", ")", "if", "s", "%", "bits", "!=", "0", ":", "raise", "ValueError", "(", "\"expression length (%d) should be a multiple of 'bits' (%d)\"", "%", "(", "len", "(", "self", ")", ",", "bits", ")", ")", "elif", "s", "==", "bits", ":", "return", "[", "self", "]", "else", ":", "return", "list", "(", "reversed", "(", "[", "self", "[", "(", "n", "+", "1", ")", "*", "bits", "-", "1", ":", "n", "*", "bits", "]", "for", "n", "in", "range", "(", "0", ",", "s", "//", "bits", ")", "]", ")", ")" ]

[ "def", "getCall", "(", "self", ",", "n", ")", ":", "#pylint: disable=invalid-name", "call_list", "=", "super", "(", "SinonSpy", ",", "self", ")", ".", "_get_wrapper", "(", ")", ".", "call_list", "if", "n", ">=", "0", "and", "n", "<", "len", "(", "call_list", ")", ":", "call", "=", "call_list", "[", "n", "]", "call", ".", "proxy", "=", "weakref", ".", "proxy", "(", "self", ")", "return", "call", "else", ":", "return", "None" ]

[ "def", "get_access_token", "(", "self", ")", ":", "if", "(", "self", ".", "token", "is", "None", ")", "or", "(", "datetime", ".", "utcnow", "(", ")", ">", "self", ".", "reuse_token_until", ")", ":", "headers", "=", "{", "'Ocp-Apim-Subscription-Key'", ":", "self", ".", "client_secret", "}", "response", "=", "requests", ".", "post", "(", "self", ".", "base_url", ",", "headers", "=", "headers", ")", "response", ".", "raise_for_status", "(", ")", "self", ".", "token", "=", "response", ".", "content", "self", ".", "reuse_token_until", "=", "datetime", ".", "utcnow", "(", ")", "+", "timedelta", "(", "minutes", "=", "5", ")", "return", "self", ".", "token", ".", "decode", "(", "'utf-8'", ")" ]

[ "def", "_code2xls", "(", "self", ",", "worksheets", ")", ":", "code_array", "=", "self", ".", "code_array", "xls_max_shape", "=", "self", ".", "xls_max_rows", ",", "self", ".", "xls_max_cols", ",", "self", ".", "xls_max_tabs", "for", "key", "in", "code_array", ":", "if", "all", "(", "kele", "<", "mele", "for", "kele", ",", "mele", "in", "zip", "(", "key", ",", "xls_max_shape", ")", ")", ":", "# Cell lies within Excel boundaries", "row", ",", "col", ",", "tab", "=", "key", "code_str", "=", "code_array", "(", "key", ")", "if", "code_str", "is", "not", "None", ":", "style", "=", "self", ".", "_get_xfstyle", "(", "worksheets", ",", "key", ")", "worksheets", "[", "tab", "]", ".", "write", "(", "row", ",", "col", ",", "label", "=", "code_str", ",", "style", "=", "style", ")", "# Handle cell formatting in cells without code", "# Get bboxes for all cell_attributes", "max_shape", "=", "[", "min", "(", "xls_max_shape", "[", "0", "]", ",", "code_array", ".", "shape", "[", "0", "]", ")", ",", "min", "(", "xls_max_shape", "[", "1", "]", ",", "code_array", ".", "shape", "[", "1", "]", ")", "]", "# Prevent systems from blocking", "if", "max_shape", "[", "0", "]", "*", "max_shape", "[", "1", "]", ">", "1024000", ":", "# Ignore all cell attributes below row 3999", "max_shape", "[", "0", "]", "=", "4000", "cell_attributes", "=", "code_array", ".", "dict_grid", ".", "cell_attributes", "bboxes", "=", "[", "]", "for", "s", ",", "__tab", ",", "__", "in", "cell_attributes", ":", "if", "s", ":", "bboxes", ".", "append", "(", "(", "s", ".", "get_grid_bbox", "(", "code_array", ".", "shape", ")", ",", "__tab", ")", ")", "# Get bbox_cell_set from bboxes", "cells", "=", "[", "]", "for", "(", "(", "bb_top", ",", "bb_left", ")", ",", "(", "bb_bottom", ",", "bb_right", ")", ")", ",", "__tab", "in", "bboxes", ":", "__bb_bottom", "=", "min", "(", "bb_bottom", ",", "max_shape", "[", "0", "]", ")", "__bb_right", "=", "min", "(", "bb_right", ",", "max_shape", "[", "1", "]", ")", "for", "__row", ",", "__col", "in", "product", "(", "xrange", "(", "bb_top", ",", "__bb_bottom", "+", "1", ")", ",", "xrange", "(", "bb_left", ",", "__bb_right", "+", "1", ")", ")", ":", "cells", ".", "append", "(", "(", "__row", ",", "__col", ",", "__tab", ")", ")", "cell_set", "=", "set", "(", "cells", ")", "# Loop over those with non-standard attributes", "for", "key", "in", "cell_set", ":", "if", "key", "not", "in", "code_array", "and", "all", "(", "ele", ">=", "0", "for", "ele", "in", "key", ")", ":", "row", ",", "col", ",", "tab", "=", "key", "style", "=", "self", ".", "_get_xfstyle", "(", "worksheets", ",", "key", ")", "worksheets", "[", "tab", "]", ".", "write", "(", "row", ",", "col", ",", "label", "=", "\"\"", ",", "style", "=", "style", ")" ]

[ "def", "stop", "(", "self", ",", "signum", "=", "None", ",", "frame", "=", "None", ")", ":", "BackgroundProcess", ".", "objects", ".", "filter", "(", "pk", "=", "self", ".", "process_id", ")", ".", "update", "(", "pid", "=", "0", ",", "last_update", "=", "now", "(", ")", ",", "message", "=", "'stopping..'", ")", "# run the cleanup", "self", ".", "cleanup", "(", ")", "BackgroundProcess", ".", "objects", ".", "filter", "(", "pk", "=", "self", ".", "process_id", ")", ".", "update", "(", "pid", "=", "0", ",", "last_update", "=", "now", "(", ")", ",", "message", "=", "'stopped'", ")" ]

[ "def", "on_draw", "(", "self", ",", "e", ")", ":", "gloo", ".", "clear", "(", ")", "for", "visual", "in", "self", ".", "visuals", ":", "logger", ".", "log", "(", "5", ",", "\"Draw visual `%s`.\"", ",", "visual", ")", "visual", ".", "on_draw", "(", ")" ]

[ "def", "get_init_container", "(", "self", ",", "init_command", ",", "init_args", ",", "env_vars", ",", "context_mounts", ",", "persistence_outputs", ",", "persistence_data", ")", ":", "env_vars", "=", "to_list", "(", "env_vars", ",", "check_none", "=", "True", ")", "env_vars", "+=", "[", "get_env_var", "(", "name", "=", "constants", ".", "CONFIG_MAP_JOB_INFO_KEY_NAME", ",", "value", "=", "json", ".", "dumps", "(", "self", ".", "labels", ")", ")", ",", "]", "return", "client", ".", "V1Container", "(", "name", "=", "self", ".", "init_container_name", ",", "image", "=", "self", ".", "init_docker_image", ",", "image_pull_policy", "=", "self", ".", "init_docker_image_pull_policy", ",", "command", "=", "init_command", ",", "env", "=", "env_vars", ",", "args", "=", "init_args", ",", "volume_mounts", "=", "context_mounts", ")" ]

[ "def", "list", "(", "self", ",", "search_opts", "=", "None", ",", "limit", "=", "None", ",", "marker", "=", "None", ",", "sort_by", "=", "None", ",", "reverse", "=", "None", ")", ":", "query", "=", "base", ".", "get_query_string", "(", "search_opts", ",", "limit", "=", "limit", ",", "marker", "=", "marker", ",", "sort_by", "=", "sort_by", ",", "reverse", "=", "reverse", ")", "url", "=", "\"/jobs%s\"", "%", "query", "return", "self", ".", "_page", "(", "url", ",", "'jobs'", ",", "limit", ")" ]

[ "def", "next", "(", "self", ",", "start", ")", ":", "position", "=", "start", "while", "True", ":", "# skip over any non-\\xFF bytes", "position", "=", "self", ".", "_offset_of_next_ff_byte", "(", "start", "=", "position", ")", "# skip over any \\xFF padding bytes", "position", ",", "byte_", "=", "self", ".", "_next_non_ff_byte", "(", "start", "=", "position", "+", "1", ")", "# 'FF 00' sequence is not a marker, start over if found", "if", "byte_", "==", "b'\\x00'", ":", "continue", "# this is a marker, gather return values and break out of scan", "marker_code", ",", "segment_offset", "=", "byte_", ",", "position", "+", "1", "break", "return", "marker_code", ",", "segment_offset" ]

[ "def", "minimal_residual", "(", "A", ",", "b", ",", "x0", "=", "None", ",", "tol", "=", "1e-5", ",", "maxiter", "=", "None", ",", "xtype", "=", "None", ",", "M", "=", "None", ",", "callback", "=", "None", ",", "residuals", "=", "None", ")", ":", "A", ",", "M", ",", "x", ",", "b", ",", "postprocess", "=", "make_system", "(", "A", ",", "M", ",", "x0", ",", "b", ")", "# Ensure that warnings are always reissued from this function", "import", "warnings", "warnings", ".", "filterwarnings", "(", "'always'", ",", "module", "=", "'pyamg\\.krylov\\._minimal_residual'", ")", "# determine maxiter", "if", "maxiter", "is", "None", ":", "maxiter", "=", "int", "(", "len", "(", "b", ")", ")", "elif", "maxiter", "<", "1", ":", "raise", "ValueError", "(", "'Number of iterations must be positive'", ")", "# setup method", "r", "=", "M", "*", "(", "b", "-", "A", "*", "x", ")", "normr", "=", "norm", "(", "r", ")", "# store initial residual", "if", "residuals", "is", "not", "None", ":", "residuals", "[", ":", "]", "=", "[", "normr", "]", "# Check initial guess ( scaling by b, if b != 0,", "# must account for case when norm(b) is very small)", "normb", "=", "norm", "(", "b", ")", "if", "normb", "==", "0.0", ":", "normb", "=", "1.0", "if", "normr", "<", "tol", "*", "normb", ":", "return", "(", "postprocess", "(", "x", ")", ",", "0", ")", "# Scale tol by ||r_0||_M", "if", "normr", "!=", "0.0", ":", "tol", "=", "tol", "*", "normr", "# How often should r be recomputed", "recompute_r", "=", "50", "iter", "=", "0", "while", "True", ":", "iter", "=", "iter", "+", "1", "p", "=", "M", "*", "(", "A", "*", "r", ")", "rMAr", "=", "np", ".", "inner", "(", "p", ".", "conjugate", "(", ")", ",", "r", ")", "# check curvature of M^-1 A", "if", "rMAr", "<", "0.0", ":", "warn", "(", "\"\\nIndefinite matrix detected in minimal residual,\\\n aborting\\n\"", ")", "return", "(", "postprocess", "(", "x", ")", ",", "-", "1", ")", "alpha", "=", "rMAr", "/", "np", ".", "inner", "(", "p", ".", "conjugate", "(", ")", ",", "p", ")", "x", "=", "x", "+", "alpha", "*", "r", "if", "np", ".", "mod", "(", "iter", ",", "recompute_r", ")", "and", "iter", ">", "0", ":", "r", "=", "M", "*", "(", "b", "-", "A", "*", "x", ")", "else", ":", "r", "=", "r", "-", "alpha", "*", "p", "normr", "=", "norm", "(", "r", ")", "if", "residuals", "is", "not", "None", ":", "residuals", ".", "append", "(", "normr", ")", "if", "callback", "is", "not", "None", ":", "callback", "(", "x", ")", "if", "normr", "<", "tol", ":", "return", "(", "postprocess", "(", "x", ")", ",", "0", ")", "if", "iter", "==", "maxiter", ":", "return", "(", "postprocess", "(", "x", ")", ",", "iter", ")" ]

[ "def", "autodiscover", "(", "path", "=", "None", ",", "plugin_prefix", "=", "'intake_'", ")", ":", "plugins", "=", "{", "}", "for", "importer", ",", "name", ",", "ispkg", "in", "pkgutil", ".", "iter_modules", "(", "path", "=", "path", ")", ":", "if", "name", ".", "startswith", "(", "plugin_prefix", ")", ":", "t", "=", "time", ".", "time", "(", ")", "new_plugins", "=", "load_plugins_from_module", "(", "name", ")", "for", "plugin_name", ",", "plugin", "in", "new_plugins", ".", "items", "(", ")", ":", "if", "plugin_name", "in", "plugins", ":", "orig_path", "=", "inspect", ".", "getfile", "(", "plugins", "[", "plugin_name", "]", ")", "new_path", "=", "inspect", ".", "getfile", "(", "plugin", ")", "warnings", ".", "warn", "(", "'Plugin name collision for \"%s\" from'", "'\\n %s'", "'\\nand'", "'\\n %s'", "'\\nKeeping plugin from first location.'", "%", "(", "plugin_name", ",", "orig_path", ",", "new_path", ")", ")", "else", ":", "plugins", "[", "plugin_name", "]", "=", "plugin", "logger", ".", "debug", "(", "\"Import %s took: %7.2f s\"", "%", "(", "name", ",", "time", ".", "time", "(", ")", "-", "t", ")", ")", "return", "plugins" ]

[ "def", "_compile_control_flow_expression", "(", "self", ",", "expr", ":", "Expression", ",", "scope", ":", "Dict", "[", "str", ",", "TensorFluent", "]", ",", "batch_size", ":", "Optional", "[", "int", "]", "=", "None", ",", "noise", ":", "Optional", "[", "List", "[", "tf", ".", "Tensor", "]", "]", "=", "None", ")", "->", "TensorFluent", ":", "etype", "=", "expr", ".", "etype", "args", "=", "expr", ".", "args", "if", "etype", "[", "1", "]", "==", "'if'", ":", "condition", "=", "self", ".", "_compile_expression", "(", "args", "[", "0", "]", ",", "scope", ",", "batch_size", ",", "noise", ")", "true_case", "=", "self", ".", "_compile_expression", "(", "args", "[", "1", "]", ",", "scope", ",", "batch_size", ",", "noise", ")", "false_case", "=", "self", ".", "_compile_expression", "(", "args", "[", "2", "]", ",", "scope", ",", "batch_size", ",", "noise", ")", "fluent", "=", "TensorFluent", ".", "if_then_else", "(", "condition", ",", "true_case", ",", "false_case", ")", "else", ":", "raise", "ValueError", "(", "'Invalid control flow expression:\\n{}'", ".", "format", "(", "expr", ")", ")", "return", "fluent" ]

[ "def", "objwalk", "(", "obj", ",", "path", "=", "(", ")", ",", "memo", "=", "None", ")", ":", "if", "len", "(", "path", ")", ">", "MAX_DEPTH", "+", "1", ":", "yield", "path", ",", "obj", "# Truncate it!", "if", "memo", "is", "None", ":", "memo", "=", "set", "(", ")", "iterator", "=", "None", "if", "isinstance", "(", "obj", ",", "Mapping", ")", ":", "iterator", "=", "iteritems", "elif", "isinstance", "(", "obj", ",", "(", "Sequence", ",", "Set", ")", ")", "and", "not", "isinstance", "(", "obj", ",", "string_types", ")", ":", "iterator", "=", "enumerate", "elif", "hasattr", "(", "obj", ",", "'__class__'", ")", "and", "hasattr", "(", "obj", ",", "'__dict__'", ")", "and", "type", "(", "obj", ")", "not", "in", "primitives", ":", "# If type(obj) == <instance>", "iterator", "=", "class_iterator", "elif", "hasattr", "(", "obj", ",", "'__iter__'", ")", "or", "isinstance", "(", "obj", ",", "types", ".", "GeneratorType", ")", ":", "obj", "=", "[", "o", "for", "o", "in", "obj", "]", "else", ":", "pass", "if", "iterator", ":", "if", "id", "(", "obj", ")", "not", "in", "memo", ":", "memo", ".", "add", "(", "id", "(", "obj", ")", ")", "for", "path_component", ",", "value", "in", "iterator", "(", "obj", ")", ":", "for", "result", "in", "objwalk", "(", "value", ",", "path", "+", "(", "path_component", ",", ")", ",", "memo", ")", ":", "yield", "result", "memo", ".", "remove", "(", "id", "(", "obj", ")", ")", "else", ":", "yield", "path", ",", "obj" ]

[ "def", "open_file", "(", "orig_file_path", ")", ":", "unquoted", "=", "unquote", "(", "orig_file_path", ")", "paths", "=", "[", "convert_to_platform_safe", "(", "orig_file_path", ")", ",", "\"%s/index.html\"", "%", "(", "convert_to_platform_safe", "(", "orig_file_path", ")", ")", ",", "orig_file_path", ",", "\"%s/index.html\"", "%", "orig_file_path", ",", "convert_to_platform_safe", "(", "unquoted", ")", ",", "\"%s/index.html\"", "%", "(", "convert_to_platform_safe", "(", "unquoted", ")", ")", ",", "unquoted", ",", "\"%s/index.html\"", "%", "unquoted", ",", "]", "file_path", "=", "None", "handle", "=", "None", "for", "path", "in", "paths", ":", "try", ":", "file_path", "=", "path", "handle", "=", "open", "(", "path", ",", "\"rb\"", ")", "break", "except", "IOError", ":", "pass", "return", "handle" ]

[ "def", "connect_callbacks", "(", "self", ",", "callbacks_bag", ")", ":", "notconnected", "=", "[", "]", "for", "wname", ",", "builderobj", "in", "self", ".", "objects", ".", "items", "(", ")", ":", "missing", "=", "builderobj", ".", "connect_commands", "(", "callbacks_bag", ")", "if", "missing", "is", "not", "None", ":", "notconnected", ".", "extend", "(", "missing", ")", "missing", "=", "builderobj", ".", "connect_bindings", "(", "callbacks_bag", ")", "if", "missing", "is", "not", "None", ":", "notconnected", ".", "extend", "(", "missing", ")", "if", "notconnected", ":", "notconnected", "=", "list", "(", "set", "(", "notconnected", ")", ")", "msg", "=", "'Missing callbacks for commands: {}'", ".", "format", "(", "notconnected", ")", "logger", ".", "warning", "(", "msg", ")", "return", "notconnected", "else", ":", "return", "None" ]

[ "def", "validate_intervals", "(", "intervals", ")", ":", "# Validate interval shape", "if", "intervals", ".", "ndim", "!=", "2", "or", "intervals", ".", "shape", "[", "1", "]", "!=", "2", ":", "raise", "ValueError", "(", "'Intervals should be n-by-2 numpy ndarray, '", "'but shape={}'", ".", "format", "(", "intervals", ".", "shape", ")", ")", "# Make sure no times are negative", "if", "(", "intervals", "<", "0", ")", ".", "any", "(", ")", ":", "raise", "ValueError", "(", "'Negative interval times found'", ")", "# Make sure all intervals have strictly positive duration", "if", "(", "intervals", "[", ":", ",", "1", "]", "<=", "intervals", "[", ":", ",", "0", "]", ")", ".", "any", "(", ")", ":", "raise", "ValueError", "(", "'All interval durations must be strictly positive'", ")" ]

[ "def", "poke_array", "(", "self", ",", "store", ",", "name", ",", "elemtype", ",", "elements", ",", "container", ",", "visited", ",", "_stack", ")", ":", "raise", "NotImplementedError" ]

[ "def", "controller_event", "(", "self", ",", "channel", ",", "contr_nr", ",", "contr_val", ")", ":", "return", "self", ".", "midi_event", "(", "CONTROLLER", ",", "channel", ",", "contr_nr", ",", "contr_val", ")" ]

[ "def", "add", "(", "data", ",", "id", ",", "medium", ",", "credentials", ")", ":", "_op", "(", "data", ",", "id", ",", "medium", ",", "tokens", ".", "Operations", ".", "ADD", ",", "credentials", ")" ]

[ "def", "_bind_key", "(", "self", ",", "key", ",", "func", ")", ":", "if", "not", "callable", "(", "func", ")", ":", "print", "u\"Trying to bind non method to keystroke:%s,%s\"", "%", "(", "key", ",", "func", ")", "raise", "ReadlineError", "(", "u\"Trying to bind non method to keystroke:%s,%s,%s,%s\"", "%", "(", "key", ",", "func", ",", "type", "(", "func", ")", ",", "type", "(", "self", ".", "_bind_key", ")", ")", ")", "keyinfo", "=", "make_KeyPress_from_keydescr", "(", "key", ".", "lower", "(", ")", ")", ".", "tuple", "(", ")", "log", "(", "u\">>>%s -> %s<<<\"", "%", "(", "keyinfo", ",", "func", ".", "__name__", ")", ")", "self", ".", "key_dispatch", "[", "keyinfo", "]", "=", "func" ]

[ "def", "mesh_other", "(", "mesh", ",", "other", ",", "samples", "=", "500", ",", "scale", "=", "False", ",", "icp_first", "=", "10", ",", "icp_final", "=", "50", ")", ":", "def", "key_points", "(", "m", ",", "count", ")", ":", "\"\"\"\n Return a combination of mesh vertices and surface samples\n with vertices chosen by likelihood to be important\n to registation.\n \"\"\"", "if", "len", "(", "m", ".", "vertices", ")", "<", "(", "count", "/", "2", ")", ":", "return", "np", ".", "vstack", "(", "(", "m", ".", "vertices", ",", "m", ".", "sample", "(", "count", "-", "len", "(", "m", ".", "vertices", ")", ")", ")", ")", "else", ":", "return", "m", ".", "sample", "(", "count", ")", "if", "not", "util", ".", "is_instance_named", "(", "mesh", ",", "'Trimesh'", ")", ":", "raise", "ValueError", "(", "'mesh must be Trimesh object!'", ")", "inverse", "=", "True", "search", "=", "mesh", "# if both are meshes use the smaller one for searching", "if", "util", ".", "is_instance_named", "(", "other", ",", "'Trimesh'", ")", ":", "if", "len", "(", "mesh", ".", "vertices", ")", ">", "len", "(", "other", ".", "vertices", ")", ":", "# do the expensive tree construction on the", "# smaller mesh and query the others points", "search", "=", "other", "inverse", "=", "False", "points", "=", "key_points", "(", "m", "=", "mesh", ",", "count", "=", "samples", ")", "points_mesh", "=", "mesh", "else", ":", "points_mesh", "=", "other", "points", "=", "key_points", "(", "m", "=", "other", ",", "count", "=", "samples", ")", "if", "points_mesh", ".", "is_volume", ":", "points_PIT", "=", "points_mesh", ".", "principal_inertia_transform", "else", ":", "points_PIT", "=", "points_mesh", ".", "bounding_box_oriented", ".", "principal_inertia_transform", "elif", "util", ".", "is_shape", "(", "other", ",", "(", "-", "1", ",", "3", ")", ")", ":", "# case where other is just points", "points", "=", "other", "points_PIT", "=", "bounds", ".", "oriented_bounds", "(", "points", ")", "[", "0", "]", "else", ":", "raise", "ValueError", "(", "'other must be mesh or (n, 3) points!'", ")", "# get the transform that aligns the search mesh principal", "# axes of inertia with the XYZ axis at the origin", "if", "search", ".", "is_volume", ":", "search_PIT", "=", "search", ".", "principal_inertia_transform", "else", ":", "search_PIT", "=", "search", ".", "bounding_box_oriented", ".", "principal_inertia_transform", "# transform that moves the principal axes of inertia", "# of the search mesh to be aligned with the best- guess", "# principal axes of the points", "search_to_points", "=", "np", ".", "dot", "(", "np", ".", "linalg", ".", "inv", "(", "points_PIT", ")", ",", "search_PIT", ")", "# permutations of cube rotations", "# the principal inertia transform has arbitrary sign", "# along the 3 major axis so try all combinations of", "# 180 degree rotations with a quick first ICP pass", "cubes", "=", "np", ".", "array", "(", "[", "np", ".", "eye", "(", "4", ")", "*", "np", ".", "append", "(", "diag", ",", "1", ")", "for", "diag", "in", "[", "[", "1", ",", "1", ",", "1", "]", ",", "[", "1", ",", "1", ",", "-", "1", "]", ",", "[", "1", ",", "-", "1", ",", "1", "]", ",", "[", "-", "1", ",", "1", ",", "1", "]", ",", "[", "-", "1", ",", "-", "1", ",", "1", "]", ",", "[", "-", "1", ",", "1", ",", "-", "1", "]", ",", "[", "1", ",", "-", "1", ",", "-", "1", "]", ",", "[", "-", "1", ",", "-", "1", ",", "-", "1", "]", "]", "]", ")", "# loop through permutations and run iterative closest point", "costs", "=", "np", ".", "ones", "(", "len", "(", "cubes", ")", ")", "*", "np", ".", "inf", "transforms", "=", "[", "None", "]", "*", "len", "(", "cubes", ")", "centroid", "=", "search", ".", "centroid", "for", "i", ",", "flip", "in", "enumerate", "(", "cubes", ")", ":", "# transform from points to search mesh", "# flipped around the centroid of search", "a_to_b", "=", "np", ".", "dot", "(", "transformations", ".", "transform_around", "(", "flip", ",", "centroid", ")", ",", "np", ".", "linalg", ".", "inv", "(", "search_to_points", ")", ")", "# run first pass ICP", "matrix", ",", "junk", ",", "cost", "=", "icp", "(", "a", "=", "points", ",", "b", "=", "search", ",", "initial", "=", "a_to_b", ",", "max_iterations", "=", "int", "(", "icp_first", ")", ",", "scale", "=", "scale", ")", "# save transform and costs from ICP", "transforms", "[", "i", "]", "=", "matrix", "costs", "[", "i", "]", "=", "cost", "# run a final ICP refinement step", "matrix", ",", "junk", ",", "cost", "=", "icp", "(", "a", "=", "points", ",", "b", "=", "search", ",", "initial", "=", "transforms", "[", "np", ".", "argmin", "(", "costs", ")", "]", ",", "max_iterations", "=", "int", "(", "icp_final", ")", ",", "scale", "=", "scale", ")", "# convert to per- point distance average", "cost", "/=", "len", "(", "points", ")", "# we picked the smaller mesh to construct the tree", "# on so we may have calculated a transform backwards", "# to save computation, so just invert matrix here", "if", "inverse", ":", "mesh_to_other", "=", "np", ".", "linalg", ".", "inv", "(", "matrix", ")", "else", ":", "mesh_to_other", "=", "matrix", "return", "mesh_to_other", ",", "cost" ]

[ "def", "csv", "(", "self", ",", "path", ",", "mode", "=", "None", ",", "compression", "=", "None", ",", "sep", "=", "None", ",", "quote", "=", "None", ",", "escape", "=", "None", ",", "header", "=", "None", ",", "nullValue", "=", "None", ",", "escapeQuotes", "=", "None", ",", "quoteAll", "=", "None", ",", "dateFormat", "=", "None", ",", "timestampFormat", "=", "None", ",", "ignoreLeadingWhiteSpace", "=", "None", ",", "ignoreTrailingWhiteSpace", "=", "None", ",", "charToEscapeQuoteEscaping", "=", "None", ",", "encoding", "=", "None", ",", "emptyValue", "=", "None", ",", "lineSep", "=", "None", ")", ":", "self", ".", "mode", "(", "mode", ")", "self", ".", "_set_opts", "(", "compression", "=", "compression", ",", "sep", "=", "sep", ",", "quote", "=", "quote", ",", "escape", "=", "escape", ",", "header", "=", "header", ",", "nullValue", "=", "nullValue", ",", "escapeQuotes", "=", "escapeQuotes", ",", "quoteAll", "=", "quoteAll", ",", "dateFormat", "=", "dateFormat", ",", "timestampFormat", "=", "timestampFormat", ",", "ignoreLeadingWhiteSpace", "=", "ignoreLeadingWhiteSpace", ",", "ignoreTrailingWhiteSpace", "=", "ignoreTrailingWhiteSpace", ",", "charToEscapeQuoteEscaping", "=", "charToEscapeQuoteEscaping", ",", "encoding", "=", "encoding", ",", "emptyValue", "=", "emptyValue", ",", "lineSep", "=", "lineSep", ")", "self", ".", "_jwrite", ".", "csv", "(", "path", ")" ]

[ "def", "_interval_to_seconds", "(", "interval", ",", "valid_units", "=", "'smhdw'", ")", ":", "if", "not", "interval", ":", "return", "None", "try", ":", "last_char", "=", "interval", "[", "-", "1", "]", "if", "last_char", "==", "'s'", "and", "'s'", "in", "valid_units", ":", "return", "str", "(", "float", "(", "interval", "[", ":", "-", "1", "]", ")", ")", "+", "'s'", "elif", "last_char", "==", "'m'", "and", "'m'", "in", "valid_units", ":", "return", "str", "(", "float", "(", "interval", "[", ":", "-", "1", "]", ")", "*", "60", ")", "+", "'s'", "elif", "last_char", "==", "'h'", "and", "'h'", "in", "valid_units", ":", "return", "str", "(", "float", "(", "interval", "[", ":", "-", "1", "]", ")", "*", "60", "*", "60", ")", "+", "'s'", "elif", "last_char", "==", "'d'", "and", "'d'", "in", "valid_units", ":", "return", "str", "(", "float", "(", "interval", "[", ":", "-", "1", "]", ")", "*", "60", "*", "60", "*", "24", ")", "+", "'s'", "elif", "last_char", "==", "'w'", "and", "'w'", "in", "valid_units", ":", "return", "str", "(", "float", "(", "interval", "[", ":", "-", "1", "]", ")", "*", "60", "*", "60", "*", "24", "*", "7", ")", "+", "'s'", "else", ":", "raise", "ValueError", "(", "'Unsupported units in interval string %s: %s'", "%", "(", "interval", ",", "last_char", ")", ")", "except", "(", "ValueError", ",", "OverflowError", ")", "as", "e", ":", "raise", "ValueError", "(", "'Unable to parse interval string %s: %s'", "%", "(", "interval", ",", "e", ")", ")" ]

[ "def", "to_unicode", "(", "s", ")", ":", "if", "not", "isinstance", "(", "s", ",", "six", ".", "string_types", ")", ":", "raise", "ValueError", "(", "\"{} must be str or unicode.\"", ".", "format", "(", "s", ")", ")", "if", "not", "isinstance", "(", "s", ",", "six", ".", "text_type", ")", ":", "s", "=", "six", ".", "text_type", "(", "s", ",", "'utf-8'", ")", "return", "s" ]

[ "def", "list", "(", "region", ",", "profile", ")", ":", "ini_data", "=", "{", "}", "environment", "=", "{", "}", "if", "region", ":", "environment", "[", "'region'", "]", "=", "region", "else", ":", "environment", "[", "'region'", "]", "=", "find_myself", "(", ")", "if", "profile", ":", "environment", "[", "'profile'", "]", "=", "profile", "ini_data", "[", "'environment'", "]", "=", "environment", "if", "start_list", "(", "ini_data", ")", ":", "sys", ".", "exit", "(", "0", ")", "else", ":", "sys", ".", "exit", "(", "1", ")" ]