Datasets:

kejian

/

codesearchnet-python-pep8-full

like 1

[ "def", "get_compatible_canvas_layers", "(", "self", ",", "category", ")", ":", "# Collect compatible layers", "layers", "=", "[", "]", "for", "layer", "in", "self", ".", "iface", ".", "mapCanvas", "(", ")", ".", "layers", "(", ")", ":", "try", ":", "keywords", "=", "self", ".", "keyword_io", ".", "read_keywords", "(", "layer", ")", "if", "'layer_purpose'", "not", "in", "keywords", ":", "keywords", "=", "None", "except", "(", "HashNotFoundError", ",", "OperationalError", ",", "NoKeywordsFoundError", ",", "KeywordNotFoundError", ",", "InvalidParameterError", ",", "UnsupportedProviderError", ")", ":", "keywords", "=", "None", "if", "self", ".", "is_layer_compatible", "(", "layer", ",", "category", ",", "keywords", ")", ":", "layers", "+=", "[", "{", "'id'", ":", "layer", ".", "id", "(", ")", ",", "'name'", ":", "layer", ".", "name", "(", ")", ",", "'keywords'", ":", "keywords", "}", "]", "# Move layers without keywords to the end", "l1", "=", "[", "l", "for", "l", "in", "layers", "if", "l", "[", "'keywords'", "]", "]", "l2", "=", "[", "l", "for", "l", "in", "layers", "if", "not", "l", "[", "'keywords'", "]", "]", "layers", "=", "l1", "+", "l2", "return", "layers" ]

[ "def", "get_note_names", "(", "self", ")", ":", "res", "=", "[", "]", "for", "cont", "in", "self", ".", "bar", ":", "for", "x", "in", "cont", "[", "2", "]", ".", "get_note_names", "(", ")", ":", "if", "x", "not", "in", "res", ":", "res", ".", "append", "(", "x", ")", "return", "res" ]

[ "def", "init_app", "(", "self", ",", "app", ",", "sessionstore", "=", "None", ",", "register_blueprint", "=", "True", ")", ":", "self", ".", "make_session_permanent", "(", "app", ")", "return", "super", "(", "InvenioAccountsUI", ",", "self", ")", ".", "init_app", "(", "app", ",", "sessionstore", "=", "sessionstore", ",", "register_blueprint", "=", "register_blueprint", ")" ]

[ "def", "_expand_base_distribution_mean", "(", "self", ")", ":", "single_draw_shape", "=", "concat_vectors", "(", "self", ".", "batch_shape_tensor", "(", ")", ",", "self", ".", "event_shape_tensor", "(", ")", ")", "m", "=", "tf", ".", "reshape", "(", "self", ".", "distribution", ".", "mean", "(", ")", ",", "# A scalar.", "shape", "=", "tf", ".", "ones_like", "(", "single_draw_shape", ",", "dtype", "=", "tf", ".", "int32", ")", ")", "m", "=", "tf", ".", "tile", "(", "m", ",", "multiples", "=", "single_draw_shape", ")", "tensorshape_util", ".", "set_shape", "(", "m", ",", "tensorshape_util", ".", "concatenate", "(", "self", ".", "batch_shape", ",", "self", ".", "event_shape", ")", ")", "return", "m" ]

[ "def", "get_3d_markers_no_label", "(", "self", ",", "component_info", "=", "None", ",", "data", "=", "None", ",", "component_position", "=", "None", ")", ":", "return", "self", ".", "_get_3d_markers", "(", "RT3DMarkerPositionNoLabel", ",", "component_info", ",", "data", ",", "component_position", ")" ]

[ "def", "createPartyFromName", "(", "apps", ",", "name", ")", ":", "TransactionParty", "=", "apps", ".", "get_model", "(", "'financial'", ",", "'TransactionParty'", ")", "StaffMember", "=", "apps", ".", "get_model", "(", "'core'", ",", "'StaffMember'", ")", "User", "=", "apps", ".", "get_model", "(", "'auth'", ",", "'User'", ")", "firstName", "=", "name", ".", "split", "(", "' '", ")", "[", "0", "]", "lastName", "=", "' '", ".", "join", "(", "name", ".", "split", "(", "' '", ")", "[", "1", ":", "]", ")", "members", "=", "StaffMember", ".", "objects", ".", "filter", "(", "firstName__istartswith", "=", "firstName", ",", "lastName__istartswith", "=", "lastName", ")", "users", "=", "User", ".", "objects", ".", "filter", "(", "first_name__istartswith", "=", "firstName", ",", "last_name__istartswith", "=", "lastName", ")", "if", "members", ".", "count", "(", ")", "==", "1", ":", "this_member", "=", "members", ".", "first", "(", ")", "party", "=", "TransactionParty", ".", "objects", ".", "get_or_create", "(", "staffMember", "=", "this_member", ",", "defaults", "=", "{", "'name'", ":", "getFullName", "(", "this_member", ")", ",", "'user'", ":", "this_member", ".", "userAccount", ",", "}", ")", "[", "0", "]", "elif", "users", ".", "count", "(", ")", "==", "1", ":", "this_user", "=", "users", ".", "first", "(", ")", "party", "=", "TransactionParty", ".", "objects", ".", "get_or_create", "(", "user", "=", "this_user", ",", "defaults", "=", "{", "'name'", ":", "getFullName", "(", "this_user", ")", ",", "'staffMember'", ":", "getattr", "(", "this_user", ",", "'staffmember'", ",", "None", ")", ",", "}", ")", "[", "0", "]", "else", ":", "party", "=", "TransactionParty", ".", "objects", ".", "get_or_create", "(", "name", "=", "name", ")", "[", "0", "]", "return", "party" ]

[ "def", "_validate_config", "(", "self", ")", ":", "groups", "=", "dict", "(", "job", "=", "defaultdict", "(", "Bunch", ")", ",", "httpd", "=", "defaultdict", "(", "Bunch", ")", ",", ")", "for", "key", ",", "val", "in", "config", ".", "torque", ".", "items", "(", ")", ":", "# Auto-convert numbers and bools", "if", "val", ".", "isdigit", "(", ")", ":", "config", ".", "torque", "[", "key", "]", "=", "val", "=", "int", "(", "val", ")", "elif", "val", ".", "lower", "(", ")", "in", "(", "matching", ".", "TRUE", "|", "matching", ".", "FALSE", ")", ":", "val", "=", "matching", ".", "truth", "(", "str", "(", "val", ")", ",", "key", ")", "# Assemble grouped parameters", "stem", "=", "key", ".", "split", "(", "'.'", ",", "1", ")", "[", "0", "]", "if", "key", "==", "\"httpd.active\"", ":", "groups", "[", "stem", "]", "[", "\"active\"", "]", "=", "val", "elif", "stem", "in", "groups", ":", "try", ":", "stem", ",", "name", ",", "param", "=", "key", ".", "split", "(", "'.'", ",", "2", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "self", ".", "fatal", "(", "\"Bad %s configuration key %r (expecting %s.NAME.PARAM)\"", "%", "(", "stem", ",", "key", ",", "stem", ")", ")", "else", ":", "groups", "[", "stem", "]", "[", "name", "]", "[", "param", "]", "=", "val", "for", "key", ",", "val", "in", "groups", ".", "iteritems", "(", ")", ":", "setattr", "(", "self", ",", "key", ".", "replace", "(", "\"job\"", ",", "\"jobs\"", ")", ",", "Bunch", "(", "val", ")", ")", "# Validate httpd config", "if", "self", ".", "httpd", ".", "active", ":", "if", "self", ".", "httpd", ".", "waitress", ".", "url_scheme", "not", "in", "(", "\"http\"", ",", "\"https\"", ")", ":", "self", ".", "fatal", "(", "\"HTTP URL scheme must be either 'http' or 'https'\"", ")", "if", "not", "isinstance", "(", "self", ".", "httpd", ".", "waitress", ".", "port", ",", "int", ")", "or", "not", "(", "1024", "<=", "self", ".", "httpd", ".", "waitress", ".", "port", "<", "65536", ")", ":", "self", ".", "fatal", "(", "\"HTTP port must be a 16 bit number >= 1024\"", ")", "# Validate jobs", "for", "name", ",", "params", "in", "self", ".", "jobs", ".", "items", "(", ")", ":", "for", "key", "in", "(", "\"handler\"", ",", "\"schedule\"", ")", ":", "if", "key", "not", "in", "params", ":", "self", ".", "fatal", "(", "\"Job '%s' is missing the required 'job.%s.%s' parameter\"", "%", "(", "name", ",", "name", ",", "key", ")", ")", "bool_param", "=", "lambda", "k", ",", "default", ",", "p", "=", "params", ":", "matching", ".", "truth", "(", "p", ".", "get", "(", "k", ",", "default", ")", ",", "\"job.%s.%s\"", "%", "(", "name", ",", "k", ")", ")", "params", ".", "job_name", "=", "name", "params", ".", "dry_run", "=", "bool_param", "(", "\"dry_run\"", ",", "False", ")", "or", "self", ".", "options", ".", "dry_run", "params", ".", "active", "=", "bool_param", "(", "\"active\"", ",", "True", ")", "params", ".", "schedule", "=", "self", ".", "_parse_schedule", "(", "params", ".", "schedule", ")", "if", "params", ".", "active", ":", "try", ":", "params", ".", "handler", "=", "pymagic", ".", "import_name", "(", "params", ".", "handler", ")", "except", "ImportError", "as", "exc", ":", "self", ".", "fatal", "(", "\"Bad handler name '%s' for job '%s':\\n %s\"", "%", "(", "params", ".", "handler", ",", "name", ",", "exc", ")", ")" ]

[ "def", "list", "(", "self", ",", "policy_id", ",", "page", "=", "None", ")", ":", "filters", "=", "[", "'policy_id={0}'", ".", "format", "(", "policy_id", ")", ",", "'page={0}'", ".", "format", "(", "page", ")", "if", "page", "else", "None", "]", "return", "self", ".", "_get", "(", "url", "=", "'{0}alerts_conditions.json'", ".", "format", "(", "self", ".", "URL", ")", ",", "headers", "=", "self", ".", "headers", ",", "params", "=", "self", ".", "build_param_string", "(", "filters", ")", ")" ]

[ "def", "merge_ndx", "(", "*", "args", ")", ":", "ndxs", "=", "[", "]", "struct", "=", "None", "for", "fname", "in", "args", ":", "if", "fname", ".", "endswith", "(", "'.ndx'", ")", ":", "ndxs", ".", "append", "(", "fname", ")", "else", ":", "if", "struct", "is", "not", "None", ":", "raise", "ValueError", "(", "\"only one structure file supported\"", ")", "struct", "=", "fname", "fd", ",", "multi_ndx", "=", "tempfile", ".", "mkstemp", "(", "suffix", "=", "'.ndx'", ",", "prefix", "=", "'multi_'", ")", "os", ".", "close", "(", "fd", ")", "atexit", ".", "register", "(", "os", ".", "unlink", ",", "multi_ndx", ")", "if", "struct", ":", "make_ndx", "=", "registry", "[", "'Make_ndx'", "]", "(", "f", "=", "struct", ",", "n", "=", "ndxs", ",", "o", "=", "multi_ndx", ")", "else", ":", "make_ndx", "=", "registry", "[", "'Make_ndx'", "]", "(", "n", "=", "ndxs", ",", "o", "=", "multi_ndx", ")", "_", ",", "_", ",", "_", "=", "make_ndx", "(", "input", "=", "[", "'q'", "]", ",", "stdout", "=", "False", ",", "stderr", "=", "False", ")", "return", "multi_ndx" ]

[ "def", "split", "(", "self", ",", "data", ")", ":", "line", "=", "deepcopy", "(", "data", ")", "line_width", "=", "(", "self", ".", "width", "(", ")", "-", "1", ")", "lines", "=", "[", "]", "while", "len", "(", "line", ")", ":", "new_line", "=", "line", "[", ":", "line_width", "]", "new_line_pos", "=", "new_line", ".", "find", "(", "'\\n'", ")", "if", "new_line_pos", ">=", "0", ":", "new_line", "=", "line", "[", ":", "new_line_pos", "]", "line", "=", "line", "[", "(", "new_line_pos", "+", "1", ")", ":", "]", "else", ":", "line", "=", "line", "[", "line_width", ":", "]", "lines", ".", "append", "(", "new_line", ")", "return", "lines" ]

[ "def", "MakeRequest", "(", "self", ",", "data", ")", ":", "stats_collector_instance", ".", "Get", "(", ")", ".", "IncrementCounter", "(", "\"grr_client_sent_bytes\"", ",", "len", "(", "data", ")", ")", "# Verify the response is as it should be from the control endpoint.", "response", "=", "self", ".", "http_manager", ".", "OpenServerEndpoint", "(", "path", "=", "\"control?api=%s\"", "%", "config", ".", "CONFIG", "[", "\"Network.api\"", "]", ",", "verify_cb", "=", "self", ".", "VerifyServerControlResponse", ",", "data", "=", "data", ",", "headers", "=", "{", "\"Content-Type\"", ":", "\"binary/octet-stream\"", "}", ")", "if", "response", ".", "code", "==", "406", ":", "self", ".", "InitiateEnrolment", "(", ")", "return", "response", "if", "response", ".", "code", "==", "200", ":", "stats_collector_instance", ".", "Get", "(", ")", ".", "IncrementCounter", "(", "\"grr_client_received_bytes\"", ",", "len", "(", "response", ".", "data", ")", ")", "return", "response", "# An unspecified error occured.", "return", "response" ]

[ "def", "Filter", "(", "self", ",", "match", "=", "None", ",", "*", "*", "_", ")", ":", "arg", "=", "self", ".", "stack", ".", "pop", "(", "-", "1", ")", "# Filters can be specified as a comma separated list.", "for", "filter_name", "in", "match", ".", "group", "(", "1", ")", ".", "split", "(", "\",\"", ")", ":", "filter_object", "=", "ConfigFilter", ".", "classes_by_name", ".", "get", "(", "filter_name", ")", "if", "filter_object", "is", "None", ":", "raise", "FilterError", "(", "\"Unknown filter function %r\"", "%", "filter_name", ")", "if", "not", "filter_object", ".", "sensitive_arg", ":", "logging", ".", "debug", "(", "\"Applying filter %s for %s.\"", ",", "filter_name", ",", "arg", ")", "arg", "=", "filter_object", "(", ")", ".", "Filter", "(", "arg", ")", "precondition", ".", "AssertType", "(", "arg", ",", "Text", ")", "self", ".", "stack", "[", "-", "1", "]", "+=", "arg" ]

[ "def", "apply_T5", "(", "word", ")", ":", "WORD", "=", "_split_consonants_and_vowels", "(", "word", ")", "for", "k", ",", "v", "in", "WORD", ".", "iteritems", "(", ")", ":", "if", "len", "(", "v", ")", ">=", "3", "and", "is_vowel", "(", "v", "[", "0", "]", ")", ":", "vv", "=", "[", "v", ".", "find", "(", "i", ")", "for", "i", "in", "i_DIPHTHONGS", "if", "v", ".", "find", "(", "i", ")", ">", "0", "]", "if", "any", "(", "vv", ")", ":", "vv", "=", "vv", "[", "0", "]", "if", "vv", "==", "v", "[", "0", "]", ":", "WORD", "[", "k", "]", "=", "v", "[", ":", "2", "]", "+", "'.'", "+", "v", "[", "2", ":", "]", "else", ":", "WORD", "[", "k", "]", "=", "v", "[", ":", "vv", "]", "+", "'.'", "+", "v", "[", "vv", ":", "]", "word", "=", "_compile_dict_into_word", "(", "WORD", ")", "return", "word" ]

[ "def", "endpoint_delete", "(", "auth", "=", "None", ",", "*", "*", "kwargs", ")", ":", "cloud", "=", "get_operator_cloud", "(", "auth", ")", "kwargs", "=", "_clean_kwargs", "(", "*", "*", "kwargs", ")", "return", "cloud", ".", "delete_endpoint", "(", "*", "*", "kwargs", ")" ]

[ "def", "pingback_url", "(", "self", ",", "server_name", ",", "target_url", ")", ":", "try", ":", "server", "=", "ServerProxy", "(", "server_name", ")", "reply", "=", "server", ".", "pingback", ".", "ping", "(", "self", ".", "entry_url", ",", "target_url", ")", "except", "(", "Error", ",", "socket", ".", "error", ")", ":", "reply", "=", "'%s cannot be pinged.'", "%", "target_url", "return", "reply" ]

[ "def", "write_profile", "(", "name", ",", "repo", ",", "token", ")", ":", "make_sure_folder_exists", "(", "CONFIG_FOLDER", ")", "config", "=", "configparser", ".", "ConfigParser", "(", ")", "config", ".", "read", "(", "CONFIG_FILE", ")", "profile", "=", "{", "\"repo\"", ":", "repo", ",", "\"token\"", ":", "token", "}", "config", "[", "name", "]", "=", "profile", "with", "open", "(", "CONFIG_FILE", ",", "\"w\"", ")", "as", "configfile", ":", "config", ".", "write", "(", "configfile", ")", "return", "profile" ]

[ "def", "memoized", "(", "func", "=", "None", ",", "key_factory", "=", "equal_args", ",", "cache_factory", "=", "dict", ")", ":", "if", "func", "is", "None", ":", "# We're being applied as a decorator factory; ie: the user has supplied args, like so:", "# >>> @memoized(cache_factory=lru_cache)", "# ... def expensive_operation(user):", "# ... pass", "# So we return a decorator with the user-supplied args curried in for the python decorator", "# machinery to use to wrap the upcoming func.", "#", "# NB: This is just a tricky way to allow for both `@memoized` and `@memoized(...params...)`", "# application forms. Without this trick, ie: using a decorator class or nested decorator", "# function, the no-params application would have to be `@memoized()`. It still can, but need", "# not be and a bare `@memoized` will work as well as a `@memoized()`.", "return", "functools", ".", "partial", "(", "memoized", ",", "key_factory", "=", "key_factory", ",", "cache_factory", "=", "cache_factory", ")", "if", "not", "inspect", ".", "isfunction", "(", "func", ")", ":", "raise", "ValueError", "(", "'The @memoized decorator must be applied innermost of all decorators.'", ")", "key_func", "=", "key_factory", "or", "equal_args", "memoized_results", "=", "cache_factory", "(", ")", "if", "cache_factory", "else", "{", "}", "@", "functools", ".", "wraps", "(", "func", ")", "def", "memoize", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "key", "=", "key_func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "if", "key", "in", "memoized_results", ":", "return", "memoized_results", "[", "key", "]", "result", "=", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "memoized_results", "[", "key", "]", "=", "result", "return", "result", "@", "contextmanager", "def", "put", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "key", "=", "key_func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "yield", "functools", ".", "partial", "(", "memoized_results", ".", "__setitem__", ",", "key", ")", "memoize", ".", "put", "=", "put", "def", "forget", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "key", "=", "key_func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "if", "key", "in", "memoized_results", ":", "del", "memoized_results", "[", "key", "]", "memoize", ".", "forget", "=", "forget", "def", "clear", "(", ")", ":", "memoized_results", ".", "clear", "(", ")", "memoize", ".", "clear", "=", "clear", "return", "memoize" ]

[ "def", "extract_zipdir", "(", "zip_file", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "zip_file", ")", ":", "raise", "ValueError", "(", "'{} does not exist'", ".", "format", "(", "zip_file", ")", ")", "directory", "=", "os", ".", "path", ".", "dirname", "(", "zip_file", ")", "filename", "=", "os", ".", "path", ".", "basename", "(", "zip_file", ")", "dirpath", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "filename", ".", "replace", "(", "'.zip'", ",", "''", ")", ")", "with", "zipfile", ".", "ZipFile", "(", "zip_file", ",", "'r'", ",", "zipfile", ".", "ZIP_DEFLATED", ")", "as", "zipf", ":", "zipf", ".", "extractall", "(", "dirpath", ")", "return", "dirpath" ]

[ "def", "protocol", "(", "self", ")", ":", "if", "self", ".", "address_family", "==", "socket", ".", "AF_INET", ":", "proto", "=", "i", "(", "self", ".", "raw", "[", "9", "]", ")", "start", "=", "(", "i", "(", "self", ".", "raw", "[", "0", "]", ")", "&", "0b1111", ")", "*", "4", "elif", "self", ".", "address_family", "==", "socket", ".", "AF_INET6", ":", "proto", "=", "i", "(", "self", ".", "raw", "[", "6", "]", ")", "# skip over well-known ipv6 headers", "start", "=", "40", "while", "proto", "in", "IPV6_EXT_HEADERS", ":", "if", "start", ">=", "len", "(", "self", ".", "raw", ")", ":", "# less than two bytes left", "start", "=", "None", "proto", "=", "None", "break", "if", "proto", "==", "Protocol", ".", "FRAGMENT", ":", "hdrlen", "=", "8", "elif", "proto", "==", "Protocol", ".", "AH", ":", "hdrlen", "=", "(", "i", "(", "self", ".", "raw", "[", "start", "+", "1", "]", ")", "+", "2", ")", "*", "4", "else", ":", "# Protocol.HOPOPT, Protocol.DSTOPTS, Protocol.ROUTING", "hdrlen", "=", "(", "i", "(", "self", ".", "raw", "[", "start", "+", "1", "]", ")", "+", "1", ")", "*", "8", "proto", "=", "i", "(", "self", ".", "raw", "[", "start", "]", ")", "start", "+=", "hdrlen", "else", ":", "start", "=", "None", "proto", "=", "None", "out_of_bounds", "=", "(", "(", "proto", "==", "Protocol", ".", "TCP", "and", "start", "+", "20", ">", "len", "(", "self", ".", "raw", ")", ")", "or", "(", "proto", "==", "Protocol", ".", "UDP", "and", "start", "+", "8", ">", "len", "(", "self", ".", "raw", ")", ")", "or", "(", "proto", "in", "{", "Protocol", ".", "ICMP", ",", "Protocol", ".", "ICMPV6", "}", "and", "start", "+", "4", ">", "len", "(", "self", ".", "raw", ")", ")", ")", "if", "out_of_bounds", ":", "# special-case tcp/udp so that we can rely on .protocol for the port properties.", "start", "=", "None", "proto", "=", "None", "return", "proto", ",", "start" ]

[ "def", "power_off", "(", "self", ",", "timeout_sec", "=", "TIMEOUT_SEC", ")", ":", "# Turn off bluetooth.", "self", ".", "_powered_off", ".", "clear", "(", ")", "IOBluetoothPreferenceSetControllerPowerState", "(", "0", ")", "if", "not", "self", ".", "_powered_off", ".", "wait", "(", "timeout_sec", ")", ":", "raise", "RuntimeError", "(", "'Exceeded timeout waiting for adapter to power off!'", ")" ]

[ "def", "parse_properties", "(", "parent_index_name", ",", "parent_name", ",", "nested_path", ",", "esProperties", ")", ":", "columns", "=", "FlatList", "(", ")", "for", "name", ",", "property", "in", "esProperties", ".", "items", "(", ")", ":", "index_name", "=", "parent_index_name", "column_name", "=", "concat_field", "(", "parent_name", ",", "name", ")", "jx_name", "=", "column_name", "if", "property", ".", "type", "==", "\"nested\"", "and", "property", ".", "properties", ":", "# NESTED TYPE IS A NEW TYPE DEFINITION", "# MARKUP CHILD COLUMNS WITH THE EXTRA DEPTH", "self_columns", "=", "parse_properties", "(", "index_name", ",", "column_name", ",", "[", "column_name", "]", "+", "nested_path", ",", "property", ".", "properties", ")", "columns", ".", "extend", "(", "self_columns", ")", "columns", ".", "append", "(", "Column", "(", "name", "=", "jx_name", ",", "es_index", "=", "index_name", ",", "es_column", "=", "column_name", ",", "es_type", "=", "\"nested\"", ",", "jx_type", "=", "NESTED", ",", "last_updated", "=", "Date", ".", "now", "(", ")", ",", "nested_path", "=", "nested_path", ")", ")", "continue", "if", "property", ".", "properties", ":", "child_columns", "=", "parse_properties", "(", "index_name", ",", "column_name", ",", "nested_path", ",", "property", ".", "properties", ")", "columns", ".", "extend", "(", "child_columns", ")", "columns", ".", "append", "(", "Column", "(", "name", "=", "jx_name", ",", "es_index", "=", "index_name", ",", "es_column", "=", "column_name", ",", "es_type", "=", "\"source\"", "if", "property", ".", "enabled", "==", "False", "else", "\"object\"", ",", "jx_type", "=", "OBJECT", ",", "last_updated", "=", "Date", ".", "now", "(", ")", ",", "nested_path", "=", "nested_path", ")", ")", "if", "property", ".", "dynamic", ":", "continue", "if", "not", "property", ".", "type", ":", "continue", "cardinality", "=", "0", "if", "not", "(", "property", ".", "store", "or", "property", ".", "enabled", ")", "and", "name", "!=", "'_id'", "else", "None", "if", "property", ".", "fields", ":", "child_columns", "=", "parse_properties", "(", "index_name", ",", "column_name", ",", "nested_path", ",", "property", ".", "fields", ")", "if", "cardinality", "is", "None", ":", "for", "cc", "in", "child_columns", ":", "cc", ".", "cardinality", "=", "None", "columns", ".", "extend", "(", "child_columns", ")", "if", "property", ".", "type", "in", "es_type_to_json_type", ".", "keys", "(", ")", ":", "columns", ".", "append", "(", "Column", "(", "name", "=", "jx_name", ",", "es_index", "=", "index_name", ",", "es_column", "=", "column_name", ",", "es_type", "=", "property", ".", "type", ",", "jx_type", "=", "es_type_to_json_type", "[", "property", ".", "type", "]", ",", "cardinality", "=", "cardinality", ",", "last_updated", "=", "Date", ".", "now", "(", ")", ",", "nested_path", "=", "nested_path", ")", ")", "if", "property", ".", "index_name", "and", "name", "!=", "property", ".", "index_name", ":", "columns", ".", "append", "(", "Column", "(", "name", "=", "jx_name", ",", "es_index", "=", "index_name", ",", "es_column", "=", "column_name", ",", "es_type", "=", "property", ".", "type", ",", "jx_type", "=", "es_type_to_json_type", "[", "property", ".", "type", "]", ",", "cardinality", "=", "0", "if", "property", ".", "store", "else", "None", ",", "last_updated", "=", "Date", ".", "now", "(", ")", ",", "nested_path", "=", "nested_path", ")", ")", "elif", "property", ".", "enabled", "==", "None", "or", "property", ".", "enabled", "==", "False", ":", "columns", ".", "append", "(", "Column", "(", "name", "=", "jx_name", ",", "es_index", "=", "index_name", ",", "es_column", "=", "column_name", ",", "es_type", "=", "\"source\"", "if", "property", ".", "enabled", "==", "False", "else", "\"object\"", ",", "jx_type", "=", "OBJECT", ",", "cardinality", "=", "0", "if", "property", ".", "store", "else", "None", ",", "last_updated", "=", "Date", ".", "now", "(", ")", ",", "nested_path", "=", "nested_path", ")", ")", "else", ":", "Log", ".", "warning", "(", "\"unknown type {{type}} for property {{path}}\"", ",", "type", "=", "property", ".", "type", ",", "path", "=", "parent_name", ")", "return", "columns" ]

[ "def", "_read_content", "(", "self", ")", ":", "if", "self", ".", "_path_in_arc", ":", "with", "zipfile", ".", "ZipFile", "(", "file", "=", "str", "(", "self", ".", "_metadata_file", ")", ")", "as", "zf", ":", "self", ".", "_content", "=", "json", ".", "loads", "(", "zf", ".", "read", "(", "self", ".", "_path_in_arc", ")", ".", "decode", "(", "'utf-8'", ")", ",", "object_pairs_hook", "=", "OrderedDict", ")", "else", ":", "with", "self", ".", "_metadata_file", ".", "open", "(", "'r'", ")", "as", "mdf", ":", "self", ".", "_content", "=", "json", ".", "load", "(", "mdf", ",", "object_pairs_hook", "=", "OrderedDict", ")" ]

[ "def", "load_tags", "(", "self", ",", "max_pages", "=", "30", ")", ":", "logger", ".", "info", "(", "\"loading tags\"", ")", "# clear them all out so we don't get dupes if requested", "if", "self", ".", "purge_first", ":", "Tag", ".", "objects", ".", "filter", "(", "site_id", "=", "self", ".", "site_id", ")", ".", "delete", "(", ")", "path", "=", "\"sites/{}/tags\"", ".", "format", "(", "self", ".", "site_id", ")", "params", "=", "{", "\"number\"", ":", "1000", "}", "page", "=", "1", "response", "=", "self", ".", "get", "(", "path", ",", "params", ")", "if", "not", "response", ".", "ok", ":", "logger", ".", "warning", "(", "\"Response NOT OK! status_code=%s\\n%s\"", ",", "response", ".", "status_code", ",", "response", ".", "text", ")", "while", "response", ".", "ok", "and", "response", ".", "text", "and", "page", "<", "max_pages", ":", "logger", ".", "info", "(", "\" - page: %d\"", ",", "page", ")", "api_tags", "=", "response", ".", "json", "(", ")", ".", "get", "(", "\"tags\"", ")", "if", "not", "api_tags", ":", "# we're done here", "break", "tags", "=", "[", "]", "for", "api_tag", "in", "api_tags", ":", "# if it exists locally, update local version if anything has changed", "existing_tag", "=", "Tag", ".", "objects", ".", "filter", "(", "site_id", "=", "self", ".", "site_id", ",", "wp_id", "=", "api_tag", "[", "\"ID\"", "]", ")", ".", "first", "(", ")", "if", "existing_tag", ":", "self", ".", "update_existing_tag", "(", "existing_tag", ",", "api_tag", ")", "else", ":", "tags", ".", "append", "(", "self", ".", "get_new_tag", "(", "api_tag", ")", ")", "if", "tags", ":", "Tag", ".", "objects", ".", "bulk_create", "(", "tags", ")", "elif", "not", "self", ".", "full", ":", "# we're done here", "break", "# get next page", "page", "+=", "1", "params", "[", "\"page\"", "]", "=", "page", "response", "=", "self", ".", "get", "(", "path", ",", "params", ")", "if", "not", "response", ".", "ok", ":", "logger", ".", "warning", "(", "\"Response NOT OK! status_code=%s\\n%s\"", ",", "response", ".", "status_code", ",", "response", ".", "text", ")", "return" ]

[ "def", "check_rights", "(", "self", ",", "resources", ",", "request", "=", "None", ")", ":", "if", "not", "self", ".", "auth", ":", "return", "True", "try", ":", "if", "not", "self", ".", "auth", ".", "test_rights", "(", "resources", ",", "request", "=", "request", ")", ":", "raise", "AssertionError", "(", ")", "except", "AssertionError", ",", "e", ":", "raise", "HttpError", "(", "\"Access forbiden. {0}\"", ".", "format", "(", "e", ")", ",", "status", "=", "status", ".", "HTTP_403_FORBIDDEN", ")" ]

[ "def", "preamble", "(", ")", ":", "from", ".", "import", "__version__", "as", "version", "logger", ".", "info", "(", "'ANDES {ver} (Build {b}, Python {p} on {os})'", ".", "format", "(", "ver", "=", "version", "[", ":", "5", "]", ",", "b", "=", "version", "[", "-", "8", ":", "]", ",", "p", "=", "platform", ".", "python_version", "(", ")", ",", "os", "=", "platform", ".", "system", "(", ")", ")", ")", "try", ":", "username", "=", "os", ".", "getlogin", "(", ")", "+", "', '", "except", "OSError", ":", "username", "=", "''", "logger", ".", "info", "(", "'Session: {}{}'", ".", "format", "(", "username", ",", "strftime", "(", "\"%m/%d/%Y %I:%M:%S %p\"", ")", ")", ")", "logger", ".", "info", "(", "''", ")" ]

[ "def", "execute", "(", "self", ",", "globals_", "=", "None", ",", "_locals", "=", "None", ")", ":", "if", "globals_", "is", "None", ":", "globals_", "=", "globals", "(", ")", "if", "_locals", "is", "None", ":", "self", ".", "_locals", "=", "globals_", "else", ":", "self", ".", "_locals", "=", "_locals", "self", ".", "globals_", "=", "globals_", "if", "self", ".", "contains_op", "(", "\"YIELD_VALUE\"", ")", ":", "return", "self", ".", "iterate_instructions", "(", ")", "else", ":", "return", "self", ".", "execute_instructions", "(", ")" ]

[ "def", "safe_to_exit", "(", "self", ",", "*", "args", ",", "*", "*", "kargs", ")", ":", "if", "len", "(", "self", ".", "value", ")", "==", "self", ".", "instance_num", ":", "return", "True", "return", "False" ]

[ "def", "alltoall", "(", "self", ",", "x", ",", "mesh_axis", ",", "split_axis", ",", "concat_axis", ")", ":", "x", "=", "x", ".", "to_laid_out_tensor", "(", ")", "t", "=", "x", ".", "one_slice", "group_assignment", "=", "self", ".", "_create_group_assignment", "(", "[", "mesh_axis", "]", ")", "dtype", "=", "t", ".", "dtype", "if", "dtype", "==", "tf", ".", "float32", ":", "# There seems to be a bug with float32 alltoall.", "# Do it in bfloat16 until the bug is fixed.", "# TODO(noam): file a bug", "t", "=", "tf", ".", "to_bfloat16", "(", "t", ")", "t", "=", "tpu_ops", ".", "all_to_all", "(", "t", ",", "concat_dimension", "=", "concat_axis", ",", "split_dimension", "=", "split_axis", ",", "split_count", "=", "len", "(", "group_assignment", "[", "0", "]", ")", ",", "group_assignment", "=", "group_assignment", ")", "t", "=", "tf", ".", "cast", "(", "t", ",", "dtype", ")", "x", "=", "self", ".", "LaidOutTensor", "(", "[", "t", "]", ")", "return", "x" ]

[ "def", "publish_events", "(", "self", ",", "topic_hostname", ",", "events", ",", "custom_headers", "=", "None", ",", "raw", "=", "False", ",", "*", "*", "operation_config", ")", ":", "# Construct URL", "url", "=", "self", ".", "publish_events", ".", "metadata", "[", "'url'", "]", "path_format_arguments", "=", "{", "'topicHostname'", ":", "self", ".", "_serialize", ".", "url", "(", "\"topic_hostname\"", ",", "topic_hostname", ",", "'str'", ",", "skip_quote", "=", "True", ")", "}", "url", "=", "self", ".", "_client", ".", "format_url", "(", "url", ",", "*", "*", "path_format_arguments", ")", "# Construct parameters", "query_parameters", "=", "{", "}", "query_parameters", "[", "'api-version'", "]", "=", "self", ".", "_serialize", ".", "query", "(", "\"self.api_version\"", ",", "self", ".", "api_version", ",", "'str'", ")", "# Construct headers", "header_parameters", "=", "{", "}", "header_parameters", "[", "'Content-Type'", "]", "=", "'application/json; charset=utf-8'", "if", "custom_headers", ":", "header_parameters", ".", "update", "(", "custom_headers", ")", "# Construct body", "body_content", "=", "self", ".", "_serialize", ".", "body", "(", "events", ",", "'[EventGridEvent]'", ")", "# Construct and send request", "request", "=", "self", ".", "_client", ".", "post", "(", "url", ",", "query_parameters", ")", "response", "=", "self", ".", "_client", ".", "send", "(", "request", ",", "header_parameters", ",", "body_content", ",", "stream", "=", "False", ",", "*", "*", "operation_config", ")", "if", "response", ".", "status_code", "not", "in", "[", "200", "]", ":", "raise", "HttpOperationError", "(", "self", ".", "_deserialize", ",", "response", ")", "if", "raw", ":", "client_raw_response", "=", "ClientRawResponse", "(", "None", ",", "response", ")", "return", "client_raw_response" ]

[ "def", "hardware_version", "(", "self", ")", ":", "hardware_string", "=", "self", ".", "hardware_string", "if", "not", "isinstance", "(", "hardware_string", ",", "bytes", ")", ":", "hardware_string", "=", "self", ".", "hardware_string", ".", "encode", "(", "'utf-8'", ")", "if", "len", "(", "hardware_string", ")", ">", "10", ":", "self", ".", "_logger", ".", "warn", "(", "\"Truncating hardware string that was longer than 10 bytes: %s\"", ",", "self", ".", "hardware_string", ")", "if", "len", "(", "hardware_string", ")", "<", "10", ":", "hardware_string", "+=", "b'\\0'", "*", "(", "10", "-", "len", "(", "hardware_string", ")", ")", "return", "[", "hardware_string", "]" ]

[ "def", "demultiplex_cells", "(", "fastq", ",", "out_dir", ",", "readnumber", ",", "prefix", ",", "cb_histogram", ",", "cb_cutoff", ")", ":", "annotations", "=", "detect_fastq_annotations", "(", "fastq", ")", "re_string", "=", "construct_transformed_regex", "(", "annotations", ")", "parser_re", "=", "re", ".", "compile", "(", "re_string", ")", "readstring", "=", "\"\"", "if", "not", "readnumber", "else", "\"_R{}\"", ".", "format", "(", "readnumber", ")", "filestring", "=", "\"{prefix}{sample}{readstring}.fq\"", "cb_set", "=", "set", "(", ")", "if", "cb_histogram", ":", "cb_set", "=", "get_cb_depth_set", "(", "cb_histogram", ",", "cb_cutoff", ")", "sample_set", "=", "set", "(", ")", "batch", "=", "collections", ".", "defaultdict", "(", "list", ")", "parsed", "=", "0", "safe_makedir", "(", "out_dir", ")", "for", "read", "in", "read_fastq", "(", "fastq", ")", ":", "parsed", "+=", "1", "match", "=", "parser_re", ".", "search", "(", "read", ")", ".", "groupdict", "(", ")", "sample", "=", "match", "[", "'CB'", "]", "if", "cb_set", "and", "sample", "not", "in", "cb_set", ":", "continue", "sample_set", ".", "add", "(", "sample", ")", "batch", "[", "sample", "]", ".", "append", "(", "read", ")", "# write in batches to avoid opening up file handles repeatedly", "if", "not", "parsed", "%", "10000000", ":", "for", "sample", ",", "reads", "in", "batch", ".", "items", "(", ")", ":", "out_file", "=", "os", ".", "path", ".", "join", "(", "out_dir", ",", "filestring", ".", "format", "(", "*", "*", "locals", "(", ")", ")", ")", "with", "open", "(", "out_file", ",", "\"a\"", ")", "as", "out_handle", ":", "for", "read", "in", "reads", ":", "out_handle", ".", "write", "(", "read", ")", "batch", "=", "collections", ".", "defaultdict", "(", "list", ")", "for", "sample", ",", "reads", "in", "batch", ".", "items", "(", ")", ":", "out_file", "=", "os", ".", "path", ".", "join", "(", "out_dir", ",", "filestring", ".", "format", "(", "*", "*", "locals", "(", ")", ")", ")", "with", "open", "(", "out_file", ",", "\"a\"", ")", "as", "out_handle", ":", "for", "read", "in", "reads", ":", "out_handle", ".", "write", "(", "read", ")" ]

[ "def", "do_loop_turn", "(", "self", ")", ":", "# Begin to clean modules", "self", ".", "check_and_del_zombie_modules", "(", ")", "# Maybe the arbiter pushed a new configuration...", "if", "self", ".", "watch_for_new_conf", "(", "timeout", "=", "0.05", ")", ":", "logger", ".", "info", "(", "\"I got a new configuration...\"", ")", "# Manage the new configuration", "self", ".", "setup_new_conf", "(", ")", "# Maybe external modules raised 'objects'", "# we should get them", "_t0", "=", "time", ".", "time", "(", ")", "self", ".", "get_objects_from_from_queues", "(", ")", "statsmgr", ".", "timer", "(", "'core.get-objects-from-queues'", ",", "time", ".", "time", "(", ")", "-", "_t0", ")", "# Get external commands from the arbiters...", "_t0", "=", "time", ".", "time", "(", ")", "self", ".", "get_external_commands_from_arbiters", "(", ")", "statsmgr", ".", "timer", "(", "'external-commands.got.time'", ",", "time", ".", "time", "(", ")", "-", "_t0", ")", "statsmgr", ".", "gauge", "(", "'external-commands.got.count'", ",", "len", "(", "self", ".", "unprocessed_external_commands", ")", ")", "_t0", "=", "time", ".", "time", "(", ")", "self", ".", "push_external_commands_to_schedulers", "(", ")", "statsmgr", ".", "timer", "(", "'external-commands.pushed.time'", ",", "time", ".", "time", "(", ")", "-", "_t0", ")", "# Say to modules it's a new tick :)", "_t0", "=", "time", ".", "time", "(", ")", "self", ".", "hook_point", "(", "'tick'", ")", "statsmgr", ".", "timer", "(", "'hook.tick'", ",", "time", ".", "time", "(", ")", "-", "_t0", ")" ]

[ "def", "maps_get_default_rules_output_rules_groupname", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "maps_get_default_rules", "=", "ET", ".", "Element", "(", "\"maps_get_default_rules\"", ")", "config", "=", "maps_get_default_rules", "output", "=", "ET", ".", "SubElement", "(", "maps_get_default_rules", ",", "\"output\"", ")", "rules", "=", "ET", ".", "SubElement", "(", "output", ",", "\"rules\"", ")", "groupname", "=", "ET", ".", "SubElement", "(", "rules", ",", "\"groupname\"", ")", "groupname", ".", "text", "=", "kwargs", ".", "pop", "(", "'groupname'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

[ "def", "_send", "(", "self", ",", "data", ")", ":", "retry", "=", "self", ".", "RETRY", "# Attempt to send any data in the queue", "while", "retry", ">", "0", ":", "# Check socket", "if", "not", "self", ".", "socket", ":", "# Log Error", "self", ".", "log", ".", "error", "(", "\"StatsiteHandler: Socket unavailable.\"", ")", "# Attempt to restablish connection", "self", ".", "_connect", "(", ")", "# Decrement retry", "retry", "-=", "1", "# Try again", "continue", "try", ":", "# Send data to socket", "data", "=", "data", ".", "split", "(", ")", "data", "=", "data", "[", "0", "]", "+", "\":\"", "+", "data", "[", "1", "]", "+", "\"|kv\\n\"", "self", ".", "socket", ".", "sendall", "(", "data", ")", "# Done", "break", "except", "socket", ".", "error", "as", "e", ":", "# Log Error", "self", ".", "log", ".", "error", "(", "\"StatsiteHandler: Failed sending data. %s.\"", ",", "e", ")", "# Attempt to restablish connection", "self", ".", "_close", "(", ")", "# Decrement retry", "retry", "-=", "1", "# try again", "continue" ]

[ "def", "_redirect_complete", "(", "self", ",", "text", ":", "str", ",", "line", ":", "str", ",", "begidx", ":", "int", ",", "endidx", ":", "int", ",", "compfunc", ":", "Callable", ")", "->", "List", "[", "str", "]", ":", "if", "self", ".", "allow_redirection", ":", "# Get all tokens through the one being completed. We want the raw tokens", "# so we can tell if redirection strings are quoted and ignore them.", "_", ",", "raw_tokens", "=", "self", ".", "tokens_for_completion", "(", "line", ",", "begidx", ",", "endidx", ")", "if", "not", "raw_tokens", ":", "return", "[", "]", "if", "len", "(", "raw_tokens", ")", ">", "1", ":", "# Check if there are redirection strings prior to the token being completed", "seen_pipe", "=", "False", "has_redirection", "=", "False", "for", "cur_token", "in", "raw_tokens", "[", ":", "-", "1", "]", ":", "if", "cur_token", "in", "constants", ".", "REDIRECTION_TOKENS", ":", "has_redirection", "=", "True", "if", "cur_token", "==", "constants", ".", "REDIRECTION_PIPE", ":", "seen_pipe", "=", "True", "# Get token prior to the one being completed", "prior_token", "=", "raw_tokens", "[", "-", "2", "]", "# If a pipe is right before the token being completed, complete a shell command as the piped process", "if", "prior_token", "==", "constants", ".", "REDIRECTION_PIPE", ":", "return", "self", ".", "shell_cmd_complete", "(", "text", ",", "line", ",", "begidx", ",", "endidx", ")", "# Otherwise do path completion either as files to redirectors or arguments to the piped process", "elif", "prior_token", "in", "constants", ".", "REDIRECTION_TOKENS", "or", "seen_pipe", ":", "return", "self", ".", "path_complete", "(", "text", ",", "line", ",", "begidx", ",", "endidx", ")", "# If there were redirection strings anywhere on the command line, then we", "# are no longer tab completing for the current command", "elif", "has_redirection", ":", "return", "[", "]", "# Call the command's completer function", "return", "compfunc", "(", "text", ",", "line", ",", "begidx", ",", "endidx", ")" ]

[ "def", "imagenet_clamp_batch", "(", "batch", ",", "low", ",", "high", ")", ":", "F", ".", "clip", "(", "batch", "[", ":", ",", "0", ",", ":", ",", ":", "]", ",", "low", "-", "123.680", ",", "high", "-", "123.680", ")", "F", ".", "clip", "(", "batch", "[", ":", ",", "1", ",", ":", ",", ":", "]", ",", "low", "-", "116.779", ",", "high", "-", "116.779", ")", "F", ".", "clip", "(", "batch", "[", ":", ",", "2", ",", ":", ",", ":", "]", ",", "low", "-", "103.939", ",", "high", "-", "103.939", ")" ]

[ "def", "create_rules", "(", "self", ")", ":", "dmp", "=", "apps", ".", "get_app_config", "(", "'django_mako_plus'", ")", "# the default", "rules", "=", "[", "# files are included by default", "Rule", "(", "'*'", ",", "level", "=", "None", ",", "filetype", "=", "TYPE_FILE", ",", "score", "=", "1", ")", ",", "# files at the app level are skipped", "Rule", "(", "'*'", ",", "level", "=", "0", ",", "filetype", "=", "TYPE_FILE", ",", "score", "=", "-", "2", ")", ",", "# directories are recursed by default", "Rule", "(", "'*'", ",", "level", "=", "None", ",", "filetype", "=", "TYPE_DIRECTORY", ",", "score", "=", "1", ")", ",", "# directories at the app level are skipped", "Rule", "(", "'*'", ",", "level", "=", "0", ",", "filetype", "=", "TYPE_DIRECTORY", ",", "score", "=", "-", "2", ")", ",", "# media, scripts, styles directories are what we want to copy", "Rule", "(", "'media'", ",", "level", "=", "0", ",", "filetype", "=", "TYPE_DIRECTORY", ",", "score", "=", "6", ")", ",", "Rule", "(", "'scripts'", ",", "level", "=", "0", ",", "filetype", "=", "TYPE_DIRECTORY", ",", "score", "=", "6", ")", ",", "Rule", "(", "'styles'", ",", "level", "=", "0", ",", "filetype", "=", "TYPE_DIRECTORY", ",", "score", "=", "6", ")", ",", "# ignore the template cache directories", "Rule", "(", "dmp", ".", "options", "[", "'TEMPLATES_CACHE_DIR'", "]", ",", "level", "=", "None", ",", "filetype", "=", "TYPE_DIRECTORY", ",", "score", "=", "-", "3", ")", ",", "# ignore python cache directories", "Rule", "(", "'__pycache__'", ",", "level", "=", "None", ",", "filetype", "=", "TYPE_DIRECTORY", ",", "score", "=", "-", "3", ")", ",", "# ignore compiled python files", "Rule", "(", "'*.pyc'", ",", "level", "=", "None", ",", "filetype", "=", "TYPE_FILE", ",", "score", "=", "-", "3", ")", ",", "]", "# include rules have score of 50 because they trump all initial rules", "for", "pattern", "in", "(", "self", ".", "options", ".", "get", "(", "'include_dir'", ")", "or", "[", "]", ")", ":", "self", ".", "message", "(", "'Setting rule - recurse directories: {}'", ".", "format", "(", "pattern", ")", ",", "1", ")", "rules", ".", "append", "(", "Rule", "(", "pattern", ",", "level", "=", "None", ",", "filetype", "=", "TYPE_DIRECTORY", ",", "score", "=", "50", ")", ")", "for", "pattern", "in", "(", "self", ".", "options", ".", "get", "(", "'include_file'", ")", "or", "[", "]", ")", ":", "self", ".", "message", "(", "'Setting rule - include files: {}'", ".", "format", "(", "pattern", ")", ",", "1", ")", "rules", ".", "append", "(", "Rule", "(", "pattern", ",", "level", "=", "None", ",", "filetype", "=", "TYPE_FILE", ",", "score", "=", "50", ")", ")", "# skip rules have score of 100 because they trump everything, including the includes from the command line", "for", "pattern", "in", "(", "self", ".", "options", ".", "get", "(", "'skip_dir'", ")", "or", "[", "]", ")", ":", "self", ".", "message", "(", "'Setting rule - skip directories: {}'", ".", "format", "(", "pattern", ")", ",", "1", ")", "rules", ".", "append", "(", "Rule", "(", "pattern", ",", "level", "=", "None", ",", "filetype", "=", "TYPE_DIRECTORY", ",", "score", "=", "-", "100", ")", ")", "for", "pattern", "in", "(", "self", ".", "options", ".", "get", "(", "'skip_file'", ")", "or", "[", "]", ")", ":", "self", ".", "message", "(", "'Setting rule - skip files: {}'", ".", "format", "(", "pattern", ")", ",", "1", ")", "rules", ".", "append", "(", "Rule", "(", "pattern", ",", "level", "=", "None", ",", "filetype", "=", "TYPE_FILE", ",", "score", "=", "-", "100", ")", ")", "return", "rules" ]

[ "def", "gut_message", "(", "message", ":", "Message", ")", "->", "Message", ":", "wrapper", "=", "Message", "(", ")", "wrapper", ".", "add_header", "(", "'Content-Type'", ",", "'message/external-body'", ",", "access_type", "=", "'x-spam-deleted'", ",", "expiration", "=", "time", ".", "strftime", "(", "\"%a, %d %b %Y %H:%M:%S %z\"", ")", ",", "size", "=", "str", "(", "len", "(", "message", ".", "get_payload", "(", ")", ")", ")", ")", "message", ".", "set_payload", "(", "''", ")", "wrapper", ".", "set_payload", "(", "[", "message", "]", ")", "return", "wrapper" ]

[ "def", "pipe", "(", "self", ",", "func", ":", "Union", "[", "Callable", "[", "...", ",", "T", "]", ",", "Tuple", "[", "Callable", "[", "...", ",", "T", "]", ",", "str", "]", "]", ",", "*", "args", ",", "*", "*", "kwargs", ")", "->", "T", ":", "if", "isinstance", "(", "func", ",", "tuple", ")", ":", "func", ",", "target", "=", "func", "if", "target", "in", "kwargs", ":", "raise", "ValueError", "(", "'%s is both the pipe target and a keyword '", "'argument'", "%", "target", ")", "kwargs", "[", "target", "]", "=", "self", "return", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "else", ":", "return", "func", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "def", "get_area_code", "(", "self", ",", "ip", ")", ":", "rec", "=", "self", ".", "get_all", "(", "ip", ")", "return", "rec", "and", "rec", ".", "area_code" ]

[ "def", "error", "(", "self", ",", "msg", ",", "*", "args", ",", "*", "*", "kwargs", ")", "->", "Task", ":", "# type: ignore", "return", "self", ".", "_make_log_task", "(", "logging", ".", "ERROR", ",", "msg", ",", "args", ",", "*", "*", "kwargs", ")" ]

[ "def", "ignore", "(", "self", ",", "filename", ")", ":", "_", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "filename", ")", "return", "ext", "in", "[", "'.pyc'", ",", "'.pyo'", ",", "'.o'", ",", "'.swp'", "]" ]

[ "def", "apps", "(", "self", ")", ":", "logger", ".", "debug", "(", "\"initialize applications ...\"", ")", "enabled", "=", "None", "apps", "=", "self", ".", "args", ".", "apps", "or", "self", ".", "_config_apps", ".", "keys", "(", ")", "unknown", "=", "set", "(", "apps", ")", "-", "set", "(", "self", ".", "_config_apps", ".", "keys", "(", ")", ")", "if", "unknown", ":", "raise", "LogRaptorArgumentError", "(", "\"--apps\"", ",", "\"not found apps %r\"", "%", "list", "(", "unknown", ")", ")", "if", "apps", "or", "enabled", "is", "None", ":", "return", "{", "k", ":", "v", "for", "k", ",", "v", "in", "self", ".", "_config_apps", ".", "items", "(", ")", "if", "k", "in", "apps", "}", "else", ":", "return", "{", "k", ":", "v", "for", "k", ",", "v", "in", "self", ".", "_config_apps", ".", "items", "(", ")", "if", "k", "in", "apps", "and", "v", ".", "enabled", "==", "enabled", "}" ]

[ "def", "versions_from_trove", "(", "trove", ")", ":", "versions", "=", "set", "(", ")", "for", "classifier", "in", "trove", ":", "if", "'Programming Language :: Python ::'", "in", "classifier", ":", "ver", "=", "classifier", ".", "split", "(", "'::'", ")", "[", "-", "1", "]", "major", "=", "ver", ".", "split", "(", "'.'", ")", "[", "0", "]", ".", "strip", "(", ")", "if", "major", ":", "versions", ".", "add", "(", "major", ")", "return", "sorted", "(", "set", "(", "[", "v", "for", "v", "in", "versions", "if", "v", ".", "replace", "(", "'.'", ",", "''", ",", "1", ")", ".", "isdigit", "(", ")", "]", ")", ")" ]

[ "def", "get_line_pts", "(", "pt0i", ",", "pt0j", ",", "pt1i", ",", "pt1j", ")", ":", "assert", "len", "(", "pt0i", ")", "==", "len", "(", "pt0j", ")", "assert", "len", "(", "pt0i", ")", "==", "len", "(", "pt1i", ")", "assert", "len", "(", "pt0i", ")", "==", "len", "(", "pt1j", ")", "pt0i", "=", "np", ".", "array", "(", "pt0i", ",", "int", ")", "pt0j", "=", "np", ".", "array", "(", "pt0j", ",", "int", ")", "pt1i", "=", "np", ".", "array", "(", "pt1i", ",", "int", ")", "pt1j", "=", "np", ".", "array", "(", "pt1j", ",", "int", ")", "if", "len", "(", "pt0i", ")", "==", "0", ":", "# Return four zero-length arrays if nothing passed in", "return", "[", "np", ".", "zeros", "(", "(", "0", ",", ")", ",", "int", ")", "]", "*", "4", "#", "# The Bresenham algorithm picks the coordinate that varies the most", "# and generates one point for each step in that coordinate. Add one", "# for the start point.", "#", "diff_i", "=", "np", ".", "abs", "(", "pt0i", "-", "pt1i", ")", "diff_j", "=", "np", ".", "abs", "(", "pt0j", "-", "pt1j", ")", "count", "=", "np", ".", "maximum", "(", "diff_i", ",", "diff_j", ")", ".", "astype", "(", "int", ")", "+", "1", "#", "# The indexes of the ends of the coordinate vectors are at the", "# cumulative sum of the counts. We get to the starts by subtracting", "# the count.", "#", "index", "=", "np", ".", "cumsum", "(", "count", ")", "-", "count", "#", "# Find the step directions per coordinate pair. ", "# True = 1, False = 0", "# True * 2 - 1 = 1, False * 2 - 1 = -1", "#", "step_i", "=", "(", "pt1i", ">", "pt0i", ")", ".", "astype", "(", "int", ")", "*", "2", "-", "1", "step_j", "=", "(", "pt1j", ">", "pt0j", ")", ".", "astype", "(", "int", ")", "*", "2", "-", "1", "#", "# Make arrays to hold the results", "#", "n_pts", "=", "index", "[", "-", "1", "]", "+", "count", "[", "-", "1", "]", "i", "=", "np", ".", "zeros", "(", "n_pts", ",", "int", ")", "j", "=", "np", ".", "zeros", "(", "n_pts", ",", "int", ")", "#", "# Put pt0 into the arrays", "#", "i", "[", "index", "]", "=", "pt0i", "j", "[", "index", "]", "=", "pt0j", "#", "# # # # # # # # # #", "#", "# Do the points for which I varies most (or it's a tie).", "#", "mask", "=", "(", "diff_i", ">=", "diff_j", ")", "count_t", "=", "count", "[", "mask", "]", "if", "len", "(", "count_t", ")", ">", "0", ":", "last_n", "=", "np", ".", "max", "(", "count_t", ")", "diff_i_t", "=", "diff_i", "[", "mask", "]", "diff_j_t", "=", "diff_j", "[", "mask", "]", "remainder", "=", "diff_j_t", "*", "2", "-", "diff_i_t", "current_i", "=", "pt0i", "[", "mask", "]", "current_j", "=", "pt0j", "[", "mask", "]", "index_t", "=", "index", "[", "mask", "]", "step_i_t", "=", "step_i", "[", "mask", "]", "step_j_t", "=", "step_j", "[", "mask", "]", "for", "n", "in", "range", "(", "1", ",", "last_n", "+", "1", ")", ":", "#", "# Eliminate all points that are done", "#", "mask", "=", "(", "count_t", ">", "n", ")", "remainder", "=", "remainder", "[", "mask", "]", "current_i", "=", "current_i", "[", "mask", "]", "current_j", "=", "current_j", "[", "mask", "]", "index_t", "=", "index_t", "[", "mask", "]", "count_t", "=", "count_t", "[", "mask", "]", "diff_i_t", "=", "diff_i_t", "[", "mask", "]", "diff_j_t", "=", "diff_j_t", "[", "mask", "]", "step_i_t", "=", "step_i_t", "[", "mask", "]", "step_j_t", "=", "step_j_t", "[", "mask", "]", "#", "# Take a step in the J direction if the remainder is positive", "#", "remainder_mask", "=", "(", "remainder", ">=", "0", ")", "current_j", "[", "remainder_mask", "]", "+=", "step_j_t", "[", "remainder_mask", "]", "remainder", "[", "remainder_mask", "]", "-=", "diff_i_t", "[", "remainder_mask", "]", "*", "2", "#", "# Always take a step in the I direction", "#", "current_i", "+=", "step_i_t", "remainder", "+=", "diff_j_t", "*", "2", "i", "[", "index_t", "+", "n", "]", "=", "current_i", "j", "[", "index_t", "+", "n", "]", "=", "current_j", "#", "# # # # # # # # # #", "#", "# Do the points for which J varies most", "#", "mask", "=", "(", "diff_j", ">", "diff_i", ")", "count_t", "=", "count", "[", "mask", "]", "if", "len", "(", "count_t", ")", ">", "0", ":", "last_n", "=", "np", ".", "max", "(", "count_t", ")", "diff_i_t", "=", "diff_i", "[", "mask", "]", "diff_j_t", "=", "diff_j", "[", "mask", "]", "remainder", "=", "diff_i_t", "*", "2", "-", "diff_j_t", "current_i", "=", "pt0i", "[", "mask", "]", "current_j", "=", "pt0j", "[", "mask", "]", "index_t", "=", "index", "[", "mask", "]", "step_i_t", "=", "step_i", "[", "mask", "]", "step_j_t", "=", "step_j", "[", "mask", "]", "for", "n", "in", "range", "(", "1", ",", "last_n", "+", "1", ")", ":", "#", "# Eliminate all points that are done", "#", "mask", "=", "(", "count_t", ">", "n", ")", "remainder", "=", "remainder", "[", "mask", "]", "current_i", "=", "current_i", "[", "mask", "]", "current_j", "=", "current_j", "[", "mask", "]", "index_t", "=", "index_t", "[", "mask", "]", "count_t", "=", "count_t", "[", "mask", "]", "diff_i_t", "=", "diff_i_t", "[", "mask", "]", "diff_j_t", "=", "diff_j_t", "[", "mask", "]", "step_i_t", "=", "step_i_t", "[", "mask", "]", "step_j_t", "=", "step_j_t", "[", "mask", "]", "#", "# Take a step in the I direction if the remainder is positive", "#", "remainder_mask", "=", "(", "remainder", ">=", "0", ")", "current_i", "[", "remainder_mask", "]", "+=", "step_i_t", "[", "remainder_mask", "]", "remainder", "[", "remainder_mask", "]", "-=", "diff_j_t", "[", "remainder_mask", "]", "*", "2", "#", "# Always take a step in the J direction", "#", "current_j", "+=", "step_j_t", "remainder", "+=", "diff_i_t", "*", "2", "i", "[", "index_t", "+", "n", "]", "=", "current_i", "j", "[", "index_t", "+", "n", "]", "=", "current_j", "return", "index", ",", "count", ",", "i", ",", "j" ]

[ "def", "_distribution", "(", "gtfs", ",", "table", ",", "column", ")", ":", "cur", "=", "gtfs", ".", "conn", ".", "cursor", "(", ")", "cur", ".", "execute", "(", "'SELECT {column}, count(*) '", "'FROM {table} GROUP BY {column} '", "'ORDER BY {column}'", ".", "format", "(", "column", "=", "column", ",", "table", "=", "table", ")", ")", "return", "' '", ".", "join", "(", "'%s:%s'", "%", "(", "t", ",", "c", ")", "for", "t", ",", "c", "in", "cur", ")" ]

[ "def", "_filter_commands", "(", "ctx", ",", "commands", "=", "None", ")", ":", "lookup", "=", "getattr", "(", "ctx", ".", "command", ",", "'commands'", ",", "{", "}", ")", "if", "not", "lookup", "and", "isinstance", "(", "ctx", ".", "command", ",", "click", ".", "MultiCommand", ")", ":", "lookup", "=", "_get_lazyload_commands", "(", "ctx", ".", "command", ")", "if", "commands", "is", "None", ":", "return", "sorted", "(", "lookup", ".", "values", "(", ")", ",", "key", "=", "lambda", "item", ":", "item", ".", "name", ")", "names", "=", "[", "name", ".", "strip", "(", ")", "for", "name", "in", "commands", ".", "split", "(", "','", ")", "]", "return", "[", "lookup", "[", "name", "]", "for", "name", "in", "names", "if", "name", "in", "lookup", "]" ]

[ "def", "validate_file", "(", "parser", ",", "arg", ")", ":", "if", "not", "os", ".", "path", ".", "isfile", "(", "arg", ")", ":", "parser", ".", "error", "(", "\"%s is not a file.\"", "%", "arg", ")", "return", "arg" ]

[ "def", "parse_address", "(", "address", ":", "str", ")", "->", "str", ":", "display_name", ",", "parsed_address", "=", "email", ".", "utils", ".", "parseaddr", "(", "address", ")", "return", "parsed_address", "or", "address" ]

[ "def", "search", "(", "cls", ",", "five9", ",", "filters", ")", ":", "return", "cls", ".", "_name_search", "(", "five9", ".", "configuration", ".", "getWebConnectors", ",", "filters", ")" ]

[ "def", "hrule", "(", "n", "=", "1", ",", "width", "=", "WIDTH", ",", "linestyle", "=", "LineStyle", "(", "''", ",", "'─', ", "'", "', ''", ")", ":", "", "", "", "widths", "=", "parse_width", "(", "width", ",", "n", ")", "hrstr", "=", "linestyle", ".", "sep", ".", "join", "(", "[", "(", "'{:%s^%i}'", "%", "(", "linestyle", ".", "hline", ",", "width", ")", ")", ".", "format", "(", "''", ")", "for", "width", "in", "widths", "]", ")", "return", "linestyle", ".", "begin", "+", "hrstr", "+", "linestyle", ".", "end" ]

[ "def", "route_handler", "(", "context", ",", "content", ",", "pargs", ",", "kwargs", ")", ":", "(", "node", ",", "rule_kw", ")", "=", "node_from_uri", "(", "pargs", "[", "0", "]", ")", "if", "node", "==", "None", ":", "return", "u\"<!-- 404 '{0}' -->\"", ".", "format", "(", "pargs", "[", "0", "]", ")", "rule_kw", ".", "update", "(", "node", ")", "values", "=", "rule_kw", "values", ".", "update", "(", "request", ".", "form", ".", "to_dict", "(", "flat", "=", "True", ")", ")", "values", ".", "update", "(", "request", ".", "args", ".", "to_dict", "(", "flat", "=", "True", ")", ")", "values", "[", "'method'", "]", "=", "request", ".", "method", "noderequest", "=", "values", ".", "copy", "(", ")", "noderequest", ".", "pop", "(", "'node_id'", ")", "noderequest", ".", "pop", "(", "'name'", ")", "noderequest", ".", "pop", "(", "'value'", ")", "rendered", "=", "render_node", "(", "node", "[", "'id'", "]", ",", "noderequest", "=", "noderequest", ",", "*", "*", "values", ")", "if", "rendered", ":", "if", "not", "isinstance", "(", "rendered", ",", "(", "str", ",", "unicode", ",", "int", ",", "float", ")", ")", ":", "# return a json string", "return", "encoder", ".", "encode", "(", "rendered", ")", "return", "rendered", "# Nothing to show, so nothing found", "return", "\"<!-- 404 '{0}' -->\"", ".", "format", "(", "pargs", "[", "0", "]", ")" ]

[ "def", "_update_proxy", "(", "self", ",", "change", ")", ":", "if", "change", "[", "'type'", "]", "==", "'event'", "and", "self", ".", "proxy_is_active", ":", "self", ".", "proxy", ".", "set_opened", "(", "change", "[", "'name'", "]", "==", "'show'", ")", "else", ":", "super", "(", "ActionMenuView", ",", "self", ")", ".", "_update_proxy", "(", "change", ")" ]

[ "def", "from_fault_data", "(", "cls", ",", "fault_trace", ",", "upper_seismogenic_depth", ",", "lower_seismogenic_depth", ",", "dip", ",", "mesh_spacing", ")", ":", "cls", ".", "check_fault_data", "(", "fault_trace", ",", "upper_seismogenic_depth", ",", "lower_seismogenic_depth", ",", "dip", ",", "mesh_spacing", ")", "# Loops over points in the top edge, for each point", "# on the top edge compute corresponding point on the bottom edge, then", "# computes equally spaced points between top and bottom points.", "vdist_top", "=", "upper_seismogenic_depth", "-", "fault_trace", "[", "0", "]", ".", "depth", "vdist_bottom", "=", "lower_seismogenic_depth", "-", "fault_trace", "[", "0", "]", ".", "depth", "hdist_top", "=", "vdist_top", "/", "math", ".", "tan", "(", "math", ".", "radians", "(", "dip", ")", ")", "hdist_bottom", "=", "vdist_bottom", "/", "math", ".", "tan", "(", "math", ".", "radians", "(", "dip", ")", ")", "strike", "=", "fault_trace", "[", "0", "]", ".", "azimuth", "(", "fault_trace", "[", "-", "1", "]", ")", "azimuth", "=", "(", "strike", "+", "90.0", ")", "%", "360", "mesh", "=", "[", "]", "for", "point", "in", "fault_trace", ".", "resample", "(", "mesh_spacing", ")", ":", "top", "=", "point", ".", "point_at", "(", "hdist_top", ",", "vdist_top", ",", "azimuth", ")", "bottom", "=", "point", ".", "point_at", "(", "hdist_bottom", ",", "vdist_bottom", ",", "azimuth", ")", "mesh", ".", "append", "(", "top", ".", "equally_spaced_points", "(", "bottom", ",", "mesh_spacing", ")", ")", "# number of rows corresponds to number of points along dip", "# number of columns corresponds to number of points along strike", "surface_points", "=", "numpy", ".", "array", "(", "mesh", ")", ".", "transpose", "(", ")", ".", "tolist", "(", ")", "mesh", "=", "RectangularMesh", ".", "from_points_list", "(", "surface_points", ")", "assert", "1", "not", "in", "mesh", ".", "shape", ",", "(", "\"Mesh must have at least 2 nodes along both length and width.\"", "\" Possible cause: Mesh spacing could be too large with respect to\"", "\" the fault length and width.\"", ")", "self", "=", "cls", "(", "mesh", ")", "self", ".", "surface_nodes", "=", "[", "simple_fault_node", "(", "fault_trace", ",", "dip", ",", "upper_seismogenic_depth", ",", "lower_seismogenic_depth", ")", "]", "return", "self" ]

[ "def", "_get_values", "(", "self", ")", ":", "(", "gi", ",", "_", ")", ",", "(", "ci", ",", "_", ")", ",", "(", "si", ",", "_", ")", "=", "self", ".", "_get_dims", "(", "self", ".", "hmap", ".", "last", ")", "ndims", "=", "self", ".", "hmap", ".", "last", ".", "ndims", "dims", "=", "self", ".", "hmap", ".", "last", ".", "kdims", "dimensions", "=", "[", "]", "values", "=", "{", "}", "for", "vidx", ",", "vtype", "in", "zip", "(", "[", "gi", ",", "ci", ",", "si", "]", ",", "self", ".", "_dimensions", ")", ":", "if", "vidx", "<", "ndims", ":", "dim", "=", "dims", "[", "vidx", "]", "dimensions", ".", "append", "(", "dim", ")", "vals", "=", "self", ".", "hmap", ".", "dimension_values", "(", "dim", ".", "name", ")", "else", ":", "dimensions", ".", "append", "(", "None", ")", "vals", "=", "[", "None", "]", "values", "[", "vtype", "]", "=", "list", "(", "unique_iterator", "(", "vals", ")", ")", "return", "values", ",", "dimensions" ]

[ "def", "set_widgets", "(", "self", ")", ":", "existing_inasafe_default_values", "=", "self", ".", "parent", ".", "get_existing_keyword", "(", "'inasafe_default_values'", ")", "# Remove old container and parameter", "if", "self", ".", "parameter_container", ":", "self", ".", "default_values_grid", ".", "removeWidget", "(", "self", ".", "parameter_container", ")", "if", "self", ".", "parameters", ":", "self", ".", "parameters", "=", "[", "]", "# Iterate through all inasafe fields", "# existing_inasafe_default_values", "for", "inasafe_field", "in", "self", ".", "inasafe_fields_for_the_layer", "(", ")", ":", "# Create DefaultSelectParameter", "parameter", "=", "DefaultValueParameter", "(", ")", "parameter", ".", "guid", "=", "inasafe_field", "[", "'key'", "]", "parameter", ".", "name", "=", "inasafe_field", "[", "'name'", "]", "parameter", ".", "is_required", "=", "False", "parameter", ".", "help_text", "=", "inasafe_field", "[", "'default_value'", "]", "[", "'description'", "]", "# parameter.description = inasafe_field['default_value']", "parameter", ".", "element_type", "=", "str", "parameter", ".", "labels", "=", "get_inasafe_default_value_fields", "(", "self", ".", "parent", ".", "setting", ",", "inasafe_field", "[", "'key'", "]", ")", "[", "0", "]", "parameter", ".", "options", "=", "get_inasafe_default_value_fields", "(", "self", ".", "parent", ".", "setting", ",", "inasafe_field", "[", "'key'", "]", ")", "[", "1", "]", "if", "existing_inasafe_default_values", ":", "existing_default_value", "=", "existing_inasafe_default_values", ".", "get", "(", "inasafe_field", "[", "'key'", "]", ")", "if", "existing_default_value", ":", "parameter", ".", "default", "=", "existing_default_value", "self", ".", "parameters", ".", "append", "(", "parameter", ")", "# Create the parameter container and add to the wizard.", "self", ".", "parameter_container", "=", "ParameterContainer", "(", "self", ".", "parameters", ",", "extra_parameters", "=", "self", ".", "extra_parameters", ")", "self", ".", "parameter_container", ".", "setup_ui", "(", ")", "self", ".", "default_values_grid", ".", "addWidget", "(", "self", ".", "parameter_container", ")", "# Set default value to None", "for", "parameter_widget", "in", "self", ".", "parameter_container", ".", "get_parameter_widgets", "(", ")", ":", "parameter_widget", ".", "widget", "(", ")", ".", "set_value", "(", "None", ")", "# Set default value from existing keywords", "if", "existing_inasafe_default_values", ":", "for", "guid", ",", "default", "in", "list", "(", "existing_inasafe_default_values", ".", "items", "(", ")", ")", ":", "parameter_widget", "=", "self", ".", "parameter_container", ".", "get_parameter_widget_by_guid", "(", "guid", ")", "if", "isinstance", "(", "parameter_widget", ",", "DefaultValueParameterWidget", ")", ":", "parameter_widget", ".", "set_value", "(", "default", ")" ]

[ "def", "spin1x_from_xi1_phi_a_phi_s", "(", "xi1", ",", "phi_a", ",", "phi_s", ")", ":", "phi1", "=", "phi1_from_phi_a_phi_s", "(", "phi_a", ",", "phi_s", ")", "return", "xi1", "*", "numpy", ".", "cos", "(", "phi1", ")" ]

[ "def", "delete", "(", "self", ",", "index", ",", "doc_type", ",", "id", ",", "bulk", "=", "False", ",", "*", "*", "query_params", ")", ":", "if", "bulk", ":", "cmd", "=", "{", "\"delete\"", ":", "{", "\"_index\"", ":", "index", ",", "\"_type\"", ":", "doc_type", ",", "\"_id\"", ":", "id", "}", "}", "self", ".", "bulker", ".", "add", "(", "json", ".", "dumps", "(", "cmd", ",", "cls", "=", "self", ".", "encoder", ")", ")", "return", "self", ".", "flush_bulk", "(", ")", "path", "=", "make_path", "(", "index", ",", "doc_type", ",", "id", ")", "return", "self", ".", "_send_request", "(", "'DELETE'", ",", "path", ",", "params", "=", "query_params", ")" ]

[ "def", "runSearchVariantAnnotationSets", "(", "self", ",", "request", ")", ":", "return", "self", ".", "runSearchRequest", "(", "request", ",", "protocol", ".", "SearchVariantAnnotationSetsRequest", ",", "protocol", ".", "SearchVariantAnnotationSetsResponse", ",", "self", ".", "variantAnnotationSetsGenerator", ")" ]

[ "def", "list_upgrades", "(", "refresh", "=", "True", ",", "*", "*", "kwargs", ")", ":", "# pylint: disable=W0613", "if", "salt", ".", "utils", ".", "data", ".", "is_true", "(", "refresh", ")", ":", "refresh_db", "(", ")", "upgrades", "=", "{", "}", "lines", "=", "__salt__", "[", "'cmd.run_stdout'", "]", "(", "'/opt/csw/bin/pkgutil -A --parse'", ")", ".", "splitlines", "(", ")", "for", "line", "in", "lines", ":", "comps", "=", "line", ".", "split", "(", "'\\t'", ")", "if", "comps", "[", "2", "]", "==", "\"SAME\"", ":", "continue", "if", "comps", "[", "2", "]", "==", "\"not installed\"", ":", "continue", "upgrades", "[", "comps", "[", "0", "]", "]", "=", "comps", "[", "1", "]", "return", "upgrades" ]

[ "def", "get_platform", "(", ")", ":", "plat", "=", "platform_detect", ".", "platform_detect", "(", ")", "if", "plat", "==", "platform_detect", ".", "RASPBERRY_PI", ":", "# Check for version 1 or 2 of the pi.", "version", "=", "platform_detect", ".", "pi_version", "(", ")", "if", "version", "==", "1", ":", "from", ".", "import", "Raspberry_Pi", "return", "Raspberry_Pi", "elif", "version", "==", "2", ":", "from", ".", "import", "Raspberry_Pi_2", "return", "Raspberry_Pi_2", "elif", "version", "==", "3", ":", "\"\"\"Use Pi 2 driver even though running on Pi 3\"\"\"", "from", ".", "import", "Raspberry_Pi_2", "return", "Raspberry_Pi_2", "else", ":", "raise", "RuntimeError", "(", "'No driver for detected Raspberry Pi version available!'", ")", "elif", "plat", "==", "platform_detect", ".", "BEAGLEBONE_BLACK", ":", "from", ".", "import", "Beaglebone_Black", "return", "Beaglebone_Black", "else", ":", "raise", "RuntimeError", "(", "'Unknown platform.'", ")" ]

[ "def", "update_manual_intervention", "(", "self", ",", "manual_intervention_update_metadata", ",", "project", ",", "release_id", ",", "manual_intervention_id", ")", ":", "route_values", "=", "{", "}", "if", "project", "is", "not", "None", ":", "route_values", "[", "'project'", "]", "=", "self", ".", "_serialize", ".", "url", "(", "'project'", ",", "project", ",", "'str'", ")", "if", "release_id", "is", "not", "None", ":", "route_values", "[", "'releaseId'", "]", "=", "self", ".", "_serialize", ".", "url", "(", "'release_id'", ",", "release_id", ",", "'int'", ")", "if", "manual_intervention_id", "is", "not", "None", ":", "route_values", "[", "'manualInterventionId'", "]", "=", "self", ".", "_serialize", ".", "url", "(", "'manual_intervention_id'", ",", "manual_intervention_id", ",", "'int'", ")", "content", "=", "self", ".", "_serialize", ".", "body", "(", "manual_intervention_update_metadata", ",", "'ManualInterventionUpdateMetadata'", ")", "response", "=", "self", ".", "_send", "(", "http_method", "=", "'PATCH'", ",", "location_id", "=", "'616c46e4-f370-4456-adaa-fbaf79c7b79e'", ",", "version", "=", "'5.1-preview.1'", ",", "route_values", "=", "route_values", ",", "content", "=", "content", ")", "return", "self", ".", "_deserialize", "(", "'ManualIntervention'", ",", "response", ")" ]

[ "def", "add_replace", "(", "self", ",", "selector", ",", "replacement", ",", "upsert", "=", "False", ",", "collation", "=", "None", ")", ":", "validate_ok_for_replace", "(", "replacement", ")", "cmd", "=", "SON", "(", "[", "(", "'q'", ",", "selector", ")", ",", "(", "'u'", ",", "replacement", ")", ",", "(", "'multi'", ",", "False", ")", ",", "(", "'upsert'", ",", "upsert", ")", "]", ")", "collation", "=", "validate_collation_or_none", "(", "collation", ")", "if", "collation", "is", "not", "None", ":", "self", ".", "uses_collation", "=", "True", "cmd", "[", "'collation'", "]", "=", "collation", "self", ".", "ops", ".", "append", "(", "(", "_UPDATE", ",", "cmd", ")", ")" ]

[ "def", "segment_raised_funds_average", "(", "df", ")", ":", "grouped", "=", "df", ".", "groupby", "(", "'Segmento'", ")", "aggregated", "=", "grouped", ".", "agg", "(", "[", "'mean'", ",", "'std'", "]", ")", "aggregated", ".", "columns", "=", "aggregated", ".", "columns", ".", "droplevel", "(", "0", ")", "return", "aggregated" ]

[ "def", "select_grid_model_residential", "(", "lvgd", ")", ":", "# Load properties of LV typified model grids", "string_properties", "=", "lvgd", ".", "lv_grid", ".", "network", ".", "static_data", "[", "'LV_model_grids_strings'", "]", "# Load relational table of apartment count and strings of model grid", "apartment_string", "=", "lvgd", ".", "lv_grid", ".", "network", ".", "static_data", "[", "'LV_model_grids_strings_per_grid'", "]", "# load assumtions", "apartment_house_branch_ratio", "=", "cfg_ding0", ".", "get", "(", "\"assumptions\"", ",", "\"apartment_house_branch_ratio\"", ")", "population_per_apartment", "=", "cfg_ding0", ".", "get", "(", "\"assumptions\"", ",", "\"population_per_apartment\"", ")", "# calc count of apartments to select string types", "apartments", "=", "round", "(", "lvgd", ".", "population", "/", "population_per_apartment", ")", "if", "apartments", ">", "196", ":", "apartments", "=", "196", "# select set of strings that represent one type of model grid", "strings", "=", "apartment_string", ".", "loc", "[", "apartments", "]", "selected_strings", "=", "[", "int", "(", "s", ")", "for", "s", "in", "strings", "[", "strings", ">=", "1", "]", ".", "index", ".", "tolist", "(", ")", "]", "# slice dataframe of string parameters", "selected_strings_df", "=", "string_properties", ".", "loc", "[", "selected_strings", "]", "# add number of occurences of each branch to df", "occurence_selector", "=", "[", "str", "(", "i", ")", "for", "i", "in", "selected_strings", "]", "selected_strings_df", "[", "'occurence'", "]", "=", "strings", ".", "loc", "[", "occurence_selector", "]", ".", "tolist", "(", ")", "return", "selected_strings_df" ]

[ "def", "compute_wcs", "(", "key", ",", "challenge", ")", ":", "key", "=", "key", ".", "encode", "(", "'utf8'", ")", "challenge", "=", "challenge", ".", "encode", "(", "'utf8'", ")", "sig", "=", "hmac", ".", "new", "(", "key", ",", "challenge", ",", "hashlib", ".", "sha256", ")", ".", "digest", "(", ")", "return", "binascii", ".", "b2a_base64", "(", "sig", ")", ".", "strip", "(", ")" ]

[ "def", "_decode16", "(", "self", ",", "offset", ")", ":", "str_len", ",", "skip", "=", "self", ".", "_decode_length", "(", "offset", ",", "2", ")", "offset", "+=", "skip", "# The len is the string len in utf-16 units", "encoded_bytes", "=", "str_len", "*", "2", "data", "=", "self", ".", "m_charbuff", "[", "offset", ":", "offset", "+", "encoded_bytes", "]", "assert", "self", ".", "m_charbuff", "[", "offset", "+", "encoded_bytes", ":", "offset", "+", "encoded_bytes", "+", "2", "]", "==", "b\"\\x00\\x00\"", ",", "\"UTF-16 String is not null terminated! At offset={}\"", ".", "format", "(", "offset", ")", "return", "self", ".", "_decode_bytes", "(", "data", ",", "'utf-16'", ",", "str_len", ")" ]

[ "def", "ancestor_paths", "(", "start", "=", "None", ",", "limit", "=", "{", "}", ")", ":", "import", "utool", "as", "ut", "limit", "=", "ut", ".", "ensure_iterable", "(", "limit", ")", "limit", "=", "{", "expanduser", "(", "p", ")", "for", "p", "in", "limit", "}", ".", "union", "(", "set", "(", "limit", ")", ")", "if", "start", "is", "None", ":", "start", "=", "os", ".", "getcwd", "(", ")", "path", "=", "start", "prev", "=", "None", "while", "path", "!=", "prev", "and", "prev", "not", "in", "limit", ":", "yield", "path", "prev", "=", "path", "path", "=", "dirname", "(", "path", ")" ]

[ "def", "choices", "(", "self", ")", ":", "if", "self", ".", "_choices", "==", "None", ":", "self", ".", "_choices", "=", "[", "ExperimentChoice", "(", "self", ",", "choice_name", ")", "for", "choice_name", "in", "self", ".", "choice_names", "]", "return", "self", ".", "_choices" ]

[ "def", "calibrate", "(", "self", ",", "data", ",", "key", ")", ":", "# logger.debug('Calibration: %s' % key.calibration)", "logger", ".", "warning", "(", "'Calibration disabled!'", ")", "if", "key", ".", "calibration", "==", "'brightness_temperature'", ":", "# self._ir_calibrate(data, key)", "pass", "elif", "key", ".", "calibration", "==", "'reflectance'", ":", "# self._vis_calibrate(data, key)", "pass", "else", ":", "pass", "return", "data" ]

[ "def", "kv", "(", "d", ")", ":", "return", "(", "(", "key", ",", "value", ")", "for", "key", ",", "value", "in", "iteritems", "(", "d", ")", "if", "key", "!=", "_meta", ")" ]

[ "def", "iterateEM", "(", "self", ",", "count", ")", ":", "for", "iter", "in", "range", "(", "count", ")", ":", "countef", "=", "{", "}", "totalf", "=", "{", "}", "# set the count of the words to zero", "for", "word", "in", "self", ".", "en_words", ":", "if", "(", "word", "not", "in", "self", ".", "probs", ")", ":", "continue", "word_probs", "=", "self", ".", "probs", "[", "word", "]", "count", "=", "dict", "(", "[", "(", "w", ",", "0", ")", "for", "w", "in", "word_probs", "]", ")", "countef", "[", "word", "]", "=", "count", "totalf", "[", "word", "]", "=", "0", "self", ".", "countef", "=", "countef", "self", ".", "totalf", "=", "totalf", "# NOW iterate over each word pair", "for", "(", "es", ",", "ds", ")", "in", "self", ".", "sent_pairs", ":", "es_split", "=", "es", ".", "split", "(", ")", "ds_split", "=", "ds", ".", "split", "(", ")", "for", "d", "in", "ds_split", ":", "self", ".", "totals", "[", "d", "]", "=", "0", "for", "e", "in", "es_split", ":", "if", "(", "e", "not", "in", "self", ".", "transmissions", ")", ":", "continue", "e_trans", "=", "self", ".", "transmissions", "[", "e", "]", "if", "(", "d", "not", "in", "e_trans", ")", ":", "continue", "self", ".", "totals", "[", "d", "]", "+=", "e_trans", "[", "d", "]", "# Get count(e|f) and total(f)", "for", "e", "in", "es_split", ":", "if", "(", "e", "not", "in", "self", ".", "transmissions", ")", ":", "continue", "if", "(", "d", "not", "in", "self", ".", "transmissions", "[", "e", "]", ")", ":", "continue", "self", ".", "countef", "[", "e", "]", "[", "d", "]", "+=", "self", ".", "transmissions", "[", "e", "]", "[", "d", "]", "/", "self", ".", "totals", "[", "d", "]", "self", ".", "totalf", "[", "e", "]", "+=", "self", ".", "transmissions", "[", "e", "]", "[", "d", "]", "/", "self", ".", "totals", "[", "d", "]", "for", "e", "in", "self", ".", "en_words", ":", "if", "(", "e", "not", "in", "self", ".", "probs", ")", ":", "continue", "e_prob", "=", "self", ".", "probs", "[", "e", "]", "for", "d", "in", "e_prob", ":", "self", ".", "transmissions", "[", "e", "]", "[", "d", "]", "=", "self", ".", "countef", "[", "e", "]", "[", "d", "]", "/", "self", ".", "totalf", "[", "e", "]" ]

[ "def", "create", "(", "self", ",", "friendly_name", "=", "values", ".", "unset", ")", ":", "data", "=", "values", ".", "of", "(", "{", "'FriendlyName'", ":", "friendly_name", ",", "}", ")", "payload", "=", "self", ".", "_version", ".", "create", "(", "'POST'", ",", "self", ".", "_uri", ",", "data", "=", "data", ",", ")", "return", "AccountInstance", "(", "self", ".", "_version", ",", "payload", ",", ")" ]

[ "def", "build_backend", "(", "self", ",", "backend_node", ")", ":", "proxy_name", "=", "backend_node", ".", "backend_header", ".", "proxy_name", ".", "text", "config_block_lines", "=", "self", ".", "__build_config_block", "(", "backend_node", ".", "config_block", ")", "return", "config", ".", "Backend", "(", "name", "=", "proxy_name", ",", "config_block", "=", "config_block_lines", ")" ]

[ "def", "get_info", "(", "pdb_id", ",", "url_root", "=", "'http://www.rcsb.org/pdb/rest/describeMol?structureId='", ")", ":", "url", "=", "url_root", "+", "pdb_id", "req", "=", "urllib", ".", "request", ".", "Request", "(", "url", ")", "f", "=", "urllib", ".", "request", ".", "urlopen", "(", "req", ")", "result", "=", "f", ".", "read", "(", ")", "assert", "result", "out", "=", "xmltodict", ".", "parse", "(", "result", ",", "process_namespaces", "=", "True", ")", "return", "out" ]

[ "def", "sing", "(", "a", ",", "b", ",", "c", "=", "False", ",", "name", "=", "'yetone'", ")", ":", "print", "(", "'test0.sing: <a: {}, b: {}, c: {}> by {}'", ".", "format", "(", "a", ",", "b", ",", "c", ",", "name", ")", ")" ]

[ "async", "def", "add_ssh_key", "(", "self", ",", "user", ",", "key", ")", ":", "key_facade", "=", "client", ".", "KeyManagerFacade", ".", "from_connection", "(", "self", ".", "connection", "(", ")", ")", "return", "await", "key_facade", ".", "AddKeys", "(", "[", "key", "]", ",", "user", ")" ]

[ "def", "kfactor", "(", "R", ",", "k", "=", "2", ",", "algorithm", "=", "'COBYLA'", ")", ":", "# subfunctions", "def", "corradjusteigen", "(", "C", ")", ":", "\"\"\"Reset negative diagonal elements 'D' to +1e-308\n This trick ensures that C semipositive definite.\n \"\"\"", "D", ",", "V", "=", "np", ".", "linalg", ".", "eig", "(", "C", ")", "Dadj", "=", "np", ".", "diag", "(", "np", ".", "maximum", "(", "1e-308", ",", "D", ")", ")", "Cadj", "=", "np", ".", "dot", "(", "np", ".", "dot", "(", "V", ",", "Dadj", ")", ",", "V", ".", "T", ")", "Cadj", "=", "(", "Cadj", "+", "Cadj", ".", "T", ")", "/", "2.", "return", "Cadj", "def", "xtocorr", "(", "x", ",", "d", ",", "k", ")", ":", "\"\"\"Convert vector 'x' into <d x k> matrix 'X'\n and compute the Correlation Matrix\n \"\"\"", "X", "=", "x", ".", "reshape", "(", "d", ",", "k", ")", "xx", "=", "np", ".", "dot", "(", "X", ",", "X", ".", "T", ")", "C", "=", "np", ".", "diag", "(", "np", ".", "diag", "(", "1", "-", "xx", ")", ")", "+", "xx", "Cadj", "=", "corradjusteigen", "(", "C", ")", "return", "Cadj", ",", "X", "def", "objectivefunc", "(", "x", ",", "R", ",", "d", ",", "k", ")", ":", "\"\"\"Objective Function of the Minimization Probem.\n The Sum of Squared Diff (SSR) between the\n ill-conditioned matrix 'R' and the current\n iteration of 'C'\n \"\"\"", "C", ",", "_", "=", "xtocorr", "(", "x", ",", "d", ",", "k", ")", "f", "=", "np", ".", "sum", "(", "(", "R", "-", "C", ")", "**", "2", ")", "extra", "=", "2", "*", "d", "*", "np", ".", "sum", "(", "np", ".", "abs", "(", "np", ".", "diag", "(", "C", ")", "-", "1.0", ")", ")", "return", "f", "+", "extra", "def", "gradientfunc", "(", "x", ",", "R", ",", "d", ",", "k", ")", ":", "X", "=", "np", ".", "matrix", "(", "x", ".", "reshape", "(", "d", ",", "k", ")", ")", "G", "=", "4", "*", "(", "X", "*", "(", "X", ".", "T", "*", "X", ")", "-", "R", "*", "X", "+", "X", "-", "np", ".", "diag", "(", "np", ".", "diag", "(", "X", "*", "X", ".", "T", ")", ")", "*", "X", ")", "return", "np", ".", "array", "(", "G", ".", "reshape", "(", "G", ".", "size", ",", ")", ")", "def", "nlcon_ineq", "(", "x", ",", "d", ",", "k", ")", ":", "\"\"\"Non-Linear Constraint\n The sum of the d absolute parameter values\n for each of the k factors have to be less than 1.\n (Sum for each of the k columns is lt 1)\n \"\"\"", "X", "=", "x", ".", "reshape", "(", "d", ",", "k", ")", "return", "np", ".", "sum", "(", "X", "**", "2", ",", "axis", "=", "1", ")", "-", "1", "# check k", "if", "k", "<", "2", ":", "raise", "Exception", "(", "'k<2 is not supported'", ")", "# check eligible algorithm", "if", "algorithm", "not", "in", "(", "'COBYLA'", ",", "'SLSQP'", ")", ":", "raise", "Exception", "(", "'Optimization Algorithm not supported.'", ")", "# dimension of the correlation matrix", "d", "=", "R", ".", "shape", "[", "0", "]", "# start values of the optimization are Ones", "x0", "=", "np", ".", "ones", "(", "shape", "=", "(", "d", "*", "k", ",", ")", ")", "# simple lower (-1) and upper (+1) bounds", "bnds", "=", "[", "(", "-", "1", ",", "+", "1", ")", "for", "_", "in", "range", "(", "d", "*", "k", ")", "]", "# for each of the k factors, the sum of its d absolute params", "# values has to be less than 1", "con_ineq", "=", "{", "'type'", ":", "'ineq'", ",", "'args'", ":", "(", "d", ",", "k", ")", ",", "'fun'", ":", "nlcon_ineq", "}", "# set maxiter", "if", "algorithm", "is", "'SLSQP'", ":", "opt", "=", "{", "'ftol'", ":", "1e-12", ",", "'maxiter'", ":", "d", "*", "k", "*", "1000", ",", "'disp'", ":", "False", "}", "else", ":", "opt", "=", "{", "'tol'", ":", "1e-8", ",", "'catol'", ":", "2e-4", ",", "'maxiter'", ":", "d", "*", "k", "*", "200", ",", "'disp'", ":", "False", "}", "# run the optimization", "results", "=", "scipy", ".", "optimize", ".", "minimize", "(", "objectivefunc", ",", "x0", ",", "jac", "=", "gradientfunc", ",", "args", "=", "(", "R", ",", "d", ",", "k", ")", ",", "bounds", "=", "bnds", ",", "constraints", "=", "[", "con_ineq", "]", ",", "method", "=", "algorithm", ",", "options", "=", "opt", ")", "# convert the d*k paramter (of k factors) into the correlation matrix", "C", ",", "X", "=", "xtocorr", "(", "results", ".", "x", ",", "d", ",", "k", ")", "# for information purposes", "f", "=", "objectivefunc", "(", "results", ".", "x", ",", "R", ",", "d", ",", "k", ")", "g", "=", "gradientfunc", "(", "results", ".", "x", ",", "R", ",", "d", ",", "k", ")", "# check solution", "if", "np", ".", "any", "(", "np", ".", "linalg", ".", "eigvals", "(", "C", ")", "<", "0.0", ")", ":", "warnings", ".", "warn", "(", "\"Matrix is not positive definite\"", ")", "# done", "return", "C", ",", "X", ",", "f", ",", "g", ",", "results" ]

[ "def", "_is_txn_to_replay", "(", "self", ",", "txn_id", ",", "possible_successor", ",", "already_seen", ")", ":", "is_successor", "=", "self", ".", "_is_predecessor_of_possible_successor", "(", "txn_id", ",", "possible_successor", ")", "in_different_batch", "=", "not", "self", ".", "_is_in_same_batch", "(", "txn_id", ",", "possible_successor", ")", "has_not_been_seen", "=", "possible_successor", "not", "in", "already_seen", "return", "is_successor", "and", "in_different_batch", "and", "has_not_been_seen" ]

[ "def", "list_commands", "(", "self", ",", "ctx", ")", ":", "commands", "=", "super", "(", "LegitGroup", ",", "self", ")", ".", "list_commands", "(", "ctx", ")", "return", "[", "cmd", "for", "cmd", "in", "order_manually", "(", "commands", ")", "]" ]

[ "def", "get_sphinx_ref", "(", "self", ",", "url", ",", "label", "=", "None", ")", ":", "# Raise an exception if the initial part of url does not match", "# the base url for this object", "n", "=", "len", "(", "self", ".", "baseurl", ")", "if", "url", "[", "0", ":", "n", "]", "!=", "self", ".", "baseurl", ":", "raise", "KeyError", "(", "'base of url %s does not match base url %s'", "%", "(", "url", ",", "self", ".", "baseurl", ")", ")", "# The reverse lookup key is either the full url or the postfix", "# to the base url, depending on flag addbase", "if", "self", ".", "addbase", ":", "pstfx", "=", "url", "[", "n", ":", "]", "else", ":", "pstfx", "=", "url", "# Look up the cross-reference role and referenced object", "# name via the postfix to the base url", "role", ",", "name", "=", "self", ".", "revinv", "[", "pstfx", "]", "# If the label string is provided and is shorter than the name", "# string we have lookup up, assume it is a partial name for", "# the same object: append a '.' at the front and use it as the", "# object name in the cross-reference", "if", "label", "is", "not", "None", "and", "len", "(", "label", ")", "<", "len", "(", "name", ")", ":", "name", "=", "'.'", "+", "label", "# Construct cross-reference", "ref", "=", "':%s:`%s`'", "%", "(", "role", ",", "name", ")", "return", "ref" ]

[ "def", "setDebug", "(", "string", ")", ":", "global", "_DEBUG", "global", "_ENV_VAR_NAME", "global", "_categories", "_DEBUG", "=", "string", "debug", "(", "'log'", ",", "\"%s set to %s\"", "%", "(", "_ENV_VAR_NAME", ",", "_DEBUG", ")", ")", "# reparse all already registered category levels", "for", "category", "in", "_categories", ":", "registerCategory", "(", "category", ")" ]

[ "def", "_oauth10a_signature", "(", "consumer_token", ":", "Dict", "[", "str", ",", "Any", "]", ",", "method", ":", "str", ",", "url", ":", "str", ",", "parameters", ":", "Dict", "[", "str", ",", "Any", "]", "=", "{", "}", ",", "token", ":", "Dict", "[", "str", ",", "Any", "]", "=", "None", ",", ")", "->", "bytes", ":", "parts", "=", "urllib", ".", "parse", ".", "urlparse", "(", "url", ")", "scheme", ",", "netloc", ",", "path", "=", "parts", "[", ":", "3", "]", "normalized_url", "=", "scheme", ".", "lower", "(", ")", "+", "\"://\"", "+", "netloc", ".", "lower", "(", ")", "+", "path", "base_elems", "=", "[", "]", "base_elems", ".", "append", "(", "method", ".", "upper", "(", ")", ")", "base_elems", ".", "append", "(", "normalized_url", ")", "base_elems", ".", "append", "(", "\"&\"", ".", "join", "(", "\"%s=%s\"", "%", "(", "k", ",", "_oauth_escape", "(", "str", "(", "v", ")", ")", ")", "for", "k", ",", "v", "in", "sorted", "(", "parameters", ".", "items", "(", ")", ")", ")", ")", "base_string", "=", "\"&\"", ".", "join", "(", "_oauth_escape", "(", "e", ")", "for", "e", "in", "base_elems", ")", "key_elems", "=", "[", "escape", ".", "utf8", "(", "urllib", ".", "parse", ".", "quote", "(", "consumer_token", "[", "\"secret\"", "]", ",", "safe", "=", "\"~\"", ")", ")", "]", "key_elems", ".", "append", "(", "escape", ".", "utf8", "(", "urllib", ".", "parse", ".", "quote", "(", "token", "[", "\"secret\"", "]", ",", "safe", "=", "\"~\"", ")", "if", "token", "else", "\"\"", ")", ")", "key", "=", "b\"&\"", ".", "join", "(", "key_elems", ")", "hash", "=", "hmac", ".", "new", "(", "key", ",", "escape", ".", "utf8", "(", "base_string", ")", ",", "hashlib", ".", "sha1", ")", "return", "binascii", ".", "b2a_base64", "(", "hash", ".", "digest", "(", ")", ")", "[", ":", "-", "1", "]" ]

[ "def", "checkAuthentication", "(", ")", ":", "if", "app", ".", "oidcClient", "is", "None", ":", "return", "if", "flask", ".", "request", ".", "endpoint", "==", "'oidcCallback'", ":", "return", "key", "=", "flask", ".", "session", ".", "get", "(", "'key'", ")", "or", "flask", ".", "request", ".", "args", ".", "get", "(", "'key'", ")", "if", "key", "is", "None", "or", "not", "app", ".", "cache", ".", "get", "(", "key", ")", ":", "if", "'key'", "in", "flask", ".", "request", ".", "args", ":", "raise", "exceptions", ".", "NotAuthenticatedException", "(", ")", "else", ":", "return", "startLogin", "(", ")" ]

[ "def", "_get_all_taskpaper_files", "(", "self", ",", "workspaceRoot", ")", ":", "self", ".", "log", ".", "info", "(", "'starting the ``_get_all_taskpaper_files`` method'", ")", "theseFiles", "=", "recursive_directory_listing", "(", "log", "=", "self", ".", "log", ",", "baseFolderPath", "=", "self", ".", "workspaceRoot", ",", "whatToList", "=", "\"files\"", "# all | files | dirs", ")", "taskpaperFiles", "=", "[", "]", "taskpaperFiles", "[", ":", "]", "=", "[", "f", "for", "f", "in", "theseFiles", "if", "os", ".", "path", ".", "splitext", "(", "f", ")", "[", "1", "]", "==", "\".taskpaper\"", "and", "self", ".", "syncFolder", "not", "in", "f", "]", "self", ".", "log", ".", "info", "(", "'completed the ``_get_all_taskpaper_files`` method'", ")", "return", "taskpaperFiles" ]

[ "def", "get", "(", "*", "*", "kwargs", ")", ":", "cmd", "=", "'sysrc -v'", "if", "'file'", "in", "kwargs", ":", "cmd", "+=", "' -f '", "+", "kwargs", "[", "'file'", "]", "if", "'jail'", "in", "kwargs", ":", "cmd", "+=", "' -j '", "+", "kwargs", "[", "'jail'", "]", "if", "'name'", "in", "kwargs", ":", "cmd", "+=", "' '", "+", "kwargs", "[", "'name'", "]", "elif", "kwargs", ".", "get", "(", "'includeDefaults'", ",", "False", ")", ":", "cmd", "+=", "' -A'", "else", ":", "cmd", "+=", "' -a'", "sysrcs", "=", "__salt__", "[", "'cmd.run'", "]", "(", "cmd", ")", "if", "\"sysrc: unknown variable\"", "in", "sysrcs", ":", "# raise CommandExecutionError(sysrcs)", "return", "None", "ret", "=", "{", "}", "for", "sysrc", "in", "sysrcs", ".", "split", "(", "\"\\n\"", ")", ":", "line_components", "=", "sysrc", ".", "split", "(", "': '", ")", "rcfile", "=", "line_components", "[", "0", "]", "if", "len", "(", "line_components", ")", ">", "2", ":", "var", "=", "line_components", "[", "1", "]", "val", "=", "line_components", "[", "2", "]", "else", ":", "var", "=", "line_components", "[", "1", "]", ".", "rstrip", "(", "':'", ")", "val", "=", "''", "if", "rcfile", "not", "in", "ret", ":", "ret", "[", "rcfile", "]", "=", "{", "}", "ret", "[", "rcfile", "]", "[", "var", "]", "=", "val", "return", "ret" ]

[ "def", "get", "(", "self", ",", "key", ",", "ttl", "=", "0", ",", "quiet", "=", "None", ",", "replica", "=", "False", ",", "no_format", "=", "False", ")", ":", "return", "_Base", ".", "get", "(", "self", ",", "key", ",", "ttl", "=", "ttl", ",", "quiet", "=", "quiet", ",", "replica", "=", "replica", ",", "no_format", "=", "no_format", ")" ]

[ "def", "subtract_params", "(", "param_list_left", ",", "param_list_right", ")", ":", "res", "=", "[", "]", "for", "x", ",", "y", "in", "zip", "(", "param_list_left", ",", "param_list_right", ")", ":", "res", ".", "append", "(", "x", "-", "y", ")", "return", "res" ]

[ "def", "_on_scan_request", "(", "self", ",", "sequence", ",", "topic", ",", "message", ")", ":", "if", "messages", ".", "ProbeCommand", ".", "matches", "(", "message", ")", ":", "self", ".", "_logger", ".", "debug", "(", "\"Received probe message on topic %s, message=%s\"", ",", "topic", ",", "message", ")", "self", ".", "_loop", ".", "add_callback", "(", "self", ".", "_publish_scan_response", ",", "message", "[", "'client'", "]", ")", "else", ":", "self", ".", "_logger", ".", "warn", "(", "\"Invalid message received on topic %s, message=%s\"", ",", "topic", ",", "message", ")" ]

[ "def", "_disable", "(", "name", ",", "started", ",", "result", "=", "True", ",", "skip_verify", "=", "False", ",", "*", "*", "kwargs", ")", ":", "ret", "=", "{", "}", "if", "not", "skip_verify", ":", "# is service available?", "try", ":", "if", "not", "_available", "(", "name", ",", "ret", ")", ":", "ret", "[", "'result'", "]", "=", "True", "return", "ret", "except", "CommandExecutionError", "as", "exc", ":", "ret", "[", "'result'", "]", "=", "False", "ret", "[", "'comment'", "]", "=", "exc", ".", "strerror", "return", "ret", "# Set default expected result", "ret", "[", "'result'", "]", "=", "result", "# is enable/disable available?", "if", "'service.disable'", "not", "in", "__salt__", "or", "'service.disabled'", "not", "in", "__salt__", ":", "if", "started", "is", "True", ":", "ret", "[", "'comment'", "]", "=", "(", "'Disable is not available on this minion,'", "' service {0} started'", ")", ".", "format", "(", "name", ")", "elif", "started", "is", "None", ":", "ret", "[", "'comment'", "]", "=", "(", "'Disable is not available on this minion,'", "' service {0} is in the desired state'", ")", ".", "format", "(", "name", ")", "else", ":", "ret", "[", "'comment'", "]", "=", "(", "'Disable is not available on this minion,'", "' service {0} is dead'", ")", ".", "format", "(", "name", ")", "return", "ret", "# Service can be disabled", "if", "salt", ".", "utils", ".", "platform", ".", "is_windows", "(", ")", ":", "# service.disabled in Windows returns True for services that are set to", "# Manual start, so we need to check specifically for Disabled", "before_toggle_disable_status", "=", "__salt__", "[", "'service.info'", "]", "(", "name", ")", "[", "'StartType'", "]", "in", "[", "'Disabled'", "]", "else", ":", "before_toggle_disable_status", "=", "__salt__", "[", "'service.disabled'", "]", "(", "name", ")", "if", "before_toggle_disable_status", ":", "# Service is disabled", "if", "started", "is", "True", ":", "ret", "[", "'comment'", "]", "=", "(", "'Service {0} is already disabled,'", "' and is running'", ")", ".", "format", "(", "name", ")", "elif", "started", "is", "None", ":", "# always be sure in this case to reset the changes dict", "ret", "[", "'changes'", "]", "=", "{", "}", "ret", "[", "'comment'", "]", "=", "(", "'Service {0} is already disabled,'", "' and is in the desired state'", ")", ".", "format", "(", "name", ")", "else", ":", "ret", "[", "'comment'", "]", "=", "(", "'Service {0} is already disabled,'", "' and is dead'", ")", ".", "format", "(", "name", ")", "return", "ret", "# Service needs to be disabled", "if", "__opts__", "[", "'test'", "]", ":", "ret", "[", "'result'", "]", "=", "None", "ret", "[", "'comment'", "]", "=", "'Service {0} set to be disabled'", ".", "format", "(", "name", ")", "return", "ret", "if", "__salt__", "[", "'service.disable'", "]", "(", "name", ",", "*", "*", "kwargs", ")", ":", "# Service has been disabled", "ret", "[", "'changes'", "]", "=", "{", "}", "after_toggle_disable_status", "=", "__salt__", "[", "'service.disabled'", "]", "(", "name", ")", "# on upstart, certain services like apparmor will always return", "# False, even if correctly activated", "# do not trigger a change", "if", "before_toggle_disable_status", "!=", "after_toggle_disable_status", ":", "ret", "[", "'changes'", "]", "[", "name", "]", "=", "True", "if", "started", "is", "True", ":", "ret", "[", "'comment'", "]", "=", "(", "'Service {0} has been disabled,'", "' and is running'", ")", ".", "format", "(", "name", ")", "elif", "started", "is", "None", ":", "ret", "[", "'comment'", "]", "=", "(", "'Service {0} has been disabled,'", "' and is in the desired state'", ")", ".", "format", "(", "name", ")", "else", ":", "ret", "[", "'comment'", "]", "=", "(", "'Service {0} has been disabled,'", "' and is dead'", ")", ".", "format", "(", "name", ")", "return", "ret", "# Service failed to be disabled", "ret", "[", "'result'", "]", "=", "False", "if", "started", "is", "True", ":", "ret", "[", "'comment'", "]", "=", "(", "'Failed when setting service {0} to not start'", "' at boot, and is running'", ")", ".", "format", "(", "name", ")", "elif", "started", "is", "None", ":", "ret", "[", "'comment'", "]", "=", "(", "'Failed when setting service {0} to not start'", "' at boot, but the service was already running'", ")", ".", "format", "(", "name", ")", "else", ":", "ret", "[", "'comment'", "]", "=", "(", "'Failed when setting service {0} to not start'", "' at boot, and the service is dead'", ")", ".", "format", "(", "name", ")", "return", "ret" ]

[ "def", "password_change", "(", "self", ",", "wallet", ",", "password", ")", ":", "wallet", "=", "self", ".", "_process_value", "(", "wallet", ",", "'wallet'", ")", "payload", "=", "{", "\"wallet\"", ":", "wallet", ",", "\"password\"", ":", "password", "}", "resp", "=", "self", ".", "call", "(", "'password_change'", ",", "payload", ")", "return", "resp", "[", "'changed'", "]", "==", "'1'" ]

[ "def", "int_global_to_local_start", "(", "self", ",", "index", ",", "axis", "=", "0", ")", ":", "if", "index", ">=", "self", ".", "__mask", "[", "axis", "]", ".", "stop", "-", "self", ".", "__halos", "[", "1", "]", "[", "axis", "]", ":", "return", "None", "if", "index", "<", "self", ".", "__mask", "[", "axis", "]", ".", "start", ":", "return", "0", "return", "index", "-", "self", ".", "__mask", "[", "axis", "]", ".", "start" ]

[ "def", "post_migrate", "(", "cls", ",", "sender", "=", "None", ",", "*", "*", "kwargs", ")", ":", "ContentType", "=", "apps", ".", "get_model", "(", "'contenttypes'", ",", "'ContentType'", ")", "for", "model_name", ",", "proxy_model", "in", "sender", ".", "get_proxy_models", "(", ")", ".", "items", "(", ")", ":", "ctype", ",", "created", "=", "ContentType", ".", "objects", ".", "get_or_create", "(", "app_label", "=", "sender", ".", "label", ",", "model", "=", "model_name", ")", "if", "created", ":", "sender", ".", "grant_permissions", "(", "proxy_model", ")" ]

[ "def", "encode_to_json", "(", "history_list", ")", ":", "rowsets", "=", "[", "]", "for", "items_in_region_list", "in", "history_list", ".", "_history", ".", "values", "(", ")", ":", "region_id", "=", "items_in_region_list", ".", "region_id", "type_id", "=", "items_in_region_list", ".", "type_id", "generated_at", "=", "gen_iso_datetime_str", "(", "items_in_region_list", ".", "generated_at", ")", "rows", "=", "[", "]", "for", "entry", "in", "items_in_region_list", ".", "entries", ":", "historical_date", "=", "gen_iso_datetime_str", "(", "entry", ".", "historical_date", ")", "# The order in which these values are added is crucial. It must", "# match STANDARD_ENCODED_COLUMNS.", "rows", ".", "append", "(", "[", "historical_date", ",", "entry", ".", "num_orders", ",", "entry", ".", "total_quantity", ",", "entry", ".", "low_price", ",", "entry", ".", "high_price", ",", "entry", ".", "average_price", ",", "]", ")", "rowsets", ".", "append", "(", "dict", "(", "generatedAt", "=", "generated_at", ",", "regionID", "=", "region_id", ",", "typeID", "=", "type_id", ",", "rows", "=", "rows", ",", ")", ")", "json_dict", "=", "{", "'resultType'", ":", "'history'", ",", "'version'", ":", "'0.1'", ",", "'uploadKeys'", ":", "history_list", ".", "upload_keys", ",", "'generator'", ":", "history_list", ".", "history_generator", ",", "'currentTime'", ":", "gen_iso_datetime_str", "(", "now_dtime_in_utc", "(", ")", ")", ",", "# This must match the order of the values in the row assembling portion", "# above this.", "'columns'", ":", "STANDARD_ENCODED_COLUMNS", ",", "'rowsets'", ":", "rowsets", ",", "}", "return", "json", ".", "dumps", "(", "json_dict", ")" ]

[ "def", "transit_decrypt_data", "(", "self", ",", "name", ",", "ciphertext", ",", "context", "=", "None", ",", "nonce", "=", "None", ",", "batch_input", "=", "None", ",", "mount_point", "=", "'transit'", ")", ":", "url", "=", "'/v1/{0}/decrypt/{1}'", ".", "format", "(", "mount_point", ",", "name", ")", "params", "=", "{", "'ciphertext'", ":", "ciphertext", "}", "if", "context", "is", "not", "None", ":", "params", "[", "'context'", "]", "=", "context", "if", "nonce", "is", "not", "None", ":", "params", "[", "'nonce'", "]", "=", "nonce", "if", "batch_input", "is", "not", "None", ":", "params", "[", "'batch_input'", "]", "=", "batch_input", "return", "self", ".", "_adapter", ".", "post", "(", "url", ",", "json", "=", "params", ")", ".", "json", "(", ")" ]

[ "def", "exists", "(", "name", ",", "path", "=", "None", ")", ":", "_exists", "=", "name", "in", "ls_", "(", "path", "=", "path", ")", "# container may be just created but we did cached earlier the", "# lxc-ls results", "if", "not", "_exists", ":", "_exists", "=", "name", "in", "ls_", "(", "cache", "=", "False", ",", "path", "=", "path", ")", "return", "_exists" ]

[ "def", "Replace", "(", "self", ",", "resource", ",", "path", ",", "type", ",", "id", ",", "initial_headers", ",", "options", "=", "None", ")", ":", "if", "options", "is", "None", ":", "options", "=", "{", "}", "initial_headers", "=", "initial_headers", "or", "self", ".", "default_headers", "headers", "=", "base", ".", "GetHeaders", "(", "self", ",", "initial_headers", ",", "'put'", ",", "path", ",", "id", ",", "type", ",", "options", ")", "# Replace will use WriteEndpoint since it uses PUT operation", "request", "=", "request_object", ".", "_RequestObject", "(", "type", ",", "documents", ".", "_OperationType", ".", "Replace", ")", "result", ",", "self", ".", "last_response_headers", "=", "self", ".", "__Put", "(", "path", ",", "request", ",", "resource", ",", "headers", ")", "# update session for request mutates data on server side", "self", ".", "_UpdateSessionIfRequired", "(", "headers", ",", "result", ",", "self", ".", "last_response_headers", ")", "return", "result" ]

[ "def", "get_available_name", "(", "self", ",", "name", ")", ":", "# If the filename already exists, remove it as if it was a true file system", "if", "self", ".", "exists", "(", "name", ")", ":", "os", ".", "remove", "(", "os", ".", "path", ".", "join", "(", "settings", ".", "MEDIA_ROOT", ",", "name", ")", ")", "return", "name" ]

[ "def", "_deserialize_primitive", "(", "data", ",", "klass", ")", ":", "try", ":", "value", "=", "klass", "(", "data", ")", "except", "UnicodeEncodeError", ":", "value", "=", "unicode", "(", "data", ")", "except", "TypeError", ":", "value", "=", "data", "return", "value" ]

[ "def", "modularity_louvain_dir", "(", "W", ",", "gamma", "=", "1", ",", "hierarchy", "=", "False", ",", "seed", "=", "None", ")", ":", "rng", "=", "get_rng", "(", "seed", ")", "n", "=", "len", "(", "W", ")", "# number of nodes", "s", "=", "np", ".", "sum", "(", "W", ")", "# total weight of edges", "h", "=", "0", "# hierarchy index", "ci", "=", "[", "]", "ci", ".", "append", "(", "np", ".", "arange", "(", "n", ")", "+", "1", ")", "# hierarchical module assignments", "q", "=", "[", "]", "q", ".", "append", "(", "-", "1", ")", "# hierarchical modularity index", "n0", "=", "n", "while", "True", ":", "if", "h", ">", "300", ":", "raise", "BCTParamError", "(", "'Modularity Infinite Loop Style E. Please '", "'contact the developer with this error.'", ")", "k_o", "=", "np", ".", "sum", "(", "W", ",", "axis", "=", "1", ")", "# node in/out degrees", "k_i", "=", "np", ".", "sum", "(", "W", ",", "axis", "=", "0", ")", "km_o", "=", "k_o", ".", "copy", "(", ")", "# module in/out degrees", "km_i", "=", "k_i", ".", "copy", "(", ")", "knm_o", "=", "W", ".", "copy", "(", ")", "# node-to-module in/out degrees", "knm_i", "=", "W", ".", "copy", "(", ")", "m", "=", "np", ".", "arange", "(", "n", ")", "+", "1", "# initial module assignments", "flag", "=", "True", "# flag for within hierarchy search", "it", "=", "0", "while", "flag", ":", "it", "+=", "1", "if", "it", ">", "1000", ":", "raise", "BCTParamError", "(", "'Modularity Infinite Loop Style F. Please '", "'contact the developer with this error.'", ")", "flag", "=", "False", "# loop over nodes in random order", "for", "u", "in", "rng", ".", "permutation", "(", "n", ")", ":", "ma", "=", "m", "[", "u", "]", "-", "1", "# algorithm condition", "dq_o", "=", "(", "(", "knm_o", "[", "u", ",", ":", "]", "-", "knm_o", "[", "u", ",", "ma", "]", "+", "W", "[", "u", ",", "u", "]", ")", "-", "gamma", "*", "k_o", "[", "u", "]", "*", "(", "km_i", "-", "km_i", "[", "ma", "]", "+", "k_i", "[", "u", "]", ")", "/", "s", ")", "dq_i", "=", "(", "(", "knm_i", "[", "u", ",", ":", "]", "-", "knm_i", "[", "u", ",", "ma", "]", "+", "W", "[", "u", ",", "u", "]", ")", "-", "gamma", "*", "k_i", "[", "u", "]", "*", "(", "km_o", "-", "km_o", "[", "ma", "]", "+", "k_o", "[", "u", "]", ")", "/", "s", ")", "dq", "=", "(", "dq_o", "+", "dq_i", ")", "/", "2", "dq", "[", "ma", "]", "=", "0", "max_dq", "=", "np", ".", "max", "(", "dq", ")", "# find maximal modularity increase", "if", "max_dq", ">", "1e-10", ":", "# if maximal increase positive", "mb", "=", "np", ".", "argmax", "(", "dq", ")", "# take only one value", "knm_o", "[", ":", ",", "mb", "]", "+=", "W", "[", "u", ",", ":", "]", ".", "T", "# change node-to-module degrees", "knm_o", "[", ":", ",", "ma", "]", "-=", "W", "[", "u", ",", ":", "]", ".", "T", "knm_i", "[", ":", ",", "mb", "]", "+=", "W", "[", ":", ",", "u", "]", "knm_i", "[", ":", ",", "ma", "]", "-=", "W", "[", ":", ",", "u", "]", "km_o", "[", "mb", "]", "+=", "k_o", "[", "u", "]", "# change module out-degrees", "km_o", "[", "ma", "]", "-=", "k_o", "[", "u", "]", "km_i", "[", "mb", "]", "+=", "k_i", "[", "u", "]", "km_i", "[", "ma", "]", "-=", "k_i", "[", "u", "]", "m", "[", "u", "]", "=", "mb", "+", "1", "# reassign module", "flag", "=", "True", "_", ",", "m", "=", "np", ".", "unique", "(", "m", ",", "return_inverse", "=", "True", ")", "m", "+=", "1", "h", "+=", "1", "ci", ".", "append", "(", "np", ".", "zeros", "(", "(", "n0", ",", ")", ")", ")", "# for i,mi in enumerate(m):\t\t#loop through module assignments", "for", "i", "in", "range", "(", "n", ")", ":", "# ci[h][np.where(ci[h-1]==i)]=mi\t#assign new modules", "ci", "[", "h", "]", "[", "np", ".", "where", "(", "ci", "[", "h", "-", "1", "]", "==", "i", "+", "1", ")", "]", "=", "m", "[", "i", "]", "n", "=", "np", ".", "max", "(", "m", ")", "# new number of modules", "W1", "=", "np", ".", "zeros", "(", "(", "n", ",", "n", ")", ")", "# new weighted matrix", "for", "i", "in", "range", "(", "n", ")", ":", "for", "j", "in", "range", "(", "n", ")", ":", "# pool weights of nodes in same module", "W1", "[", "i", ",", "j", "]", "=", "np", ".", "sum", "(", "W", "[", "np", ".", "ix_", "(", "m", "==", "i", "+", "1", ",", "m", "==", "j", "+", "1", ")", "]", ")", "q", ".", "append", "(", "0", ")", "# compute modularity", "q", "[", "h", "]", "=", "np", ".", "trace", "(", "W1", ")", "/", "s", "-", "gamma", "*", "np", ".", "sum", "(", "np", ".", "dot", "(", "W1", "/", "s", ",", "W1", "/", "s", ")", ")", "if", "q", "[", "h", "]", "-", "q", "[", "h", "-", "1", "]", "<", "1e-10", ":", "# if modularity does not increase", "break", "ci", "=", "np", ".", "array", "(", "ci", ",", "dtype", "=", "int", ")", "if", "hierarchy", ":", "ci", "=", "ci", "[", "1", ":", "-", "1", "]", "q", "=", "q", "[", "1", ":", "-", "1", "]", "return", "ci", ",", "q", "else", ":", "return", "ci", "[", "h", "-", "1", "]", ",", "q", "[", "h", "-", "1", "]" ]