Datasets:

sia-precision-education

/

pile_python

like 3

[ "Return", "the", "fingerprint", "of", "the", "master", "s", "public", "key", "on", "the", "minion", "." ]

[ "def", "finger_master", "(", "hash_type", "=", "None", ")", ":", "if", "hash_type", "is", "None", ":", "hash_type", "=", "__opts__", "[", "\"hash_type\"", "]", "return", "salt", ".", "utils", ".", "crypt", ".", "pem_finger", "(", "os", ".", "path", ".", "join", "(", "__opts__", "[", "\"pki_dir\"", "]", ",", "\"minion_master.pub\"", ")", ",", "sum_type", "=", "hash_type", ")" ]

[ "Args", ":", "primitive", ":", "The", "Statevector", "NumPy", "array", "or", "list", "which", "defines", "the", "behavior", "of", "the", "underlying", "function", ".", "coeff", ":", "A", "coefficient", "multiplying", "the", "state", "function", ".", "is_measurement", ":", "Whether", "the", "StateFn", "is", "a", "measurement", "operator" ]

[ "def", "__init__", "(", "self", ",", "primitive", ":", "Union", "[", "list", ",", "np", ".", "ndarray", ",", "Statevector", "]", "=", "None", ",", "coeff", ":", "Union", "[", "complex", ",", "ParameterExpression", "]", "=", "1.0", ",", "is_measurement", ":", "bool", "=", "False", ",", ")", "->", "None", ":", "# Lists and Numpy arrays representing statevectors are stored", "# in Statevector objects for easier handling.", "if", "isinstance", "(", "primitive", ",", "(", "np", ".", "ndarray", ",", "list", ")", ")", ":", "primitive", "=", "Statevector", "(", "primitive", ")", "super", "(", ")", ".", "__init__", "(", "primitive", ",", "coeff", "=", "coeff", ",", "is_measurement", "=", "is_measurement", ")" ]

[ "Runs", "a", "backtest", "over", "a", "given", "time", "period", "." ]

[ "def", "run_backtest", "(", "self", ",", "start", ",", "end", "=", "None", ",", "lookback", "=", "0", ",", "slippage", "=", "0.0", ",", "commission", "=", "0.0", ",", "cash", "=", "1000000", ",", "# $1,000,000", "initial_portfolio", "=", "Portfolio", "(", ")", ",", ")", ":", "# Setup", "if", "not", "end", ":", "today", "=", "dt", ".", "date", ".", "today", "(", ")", "end", "=", "dt", ".", "datetime", ".", "combine", "(", "today", ",", "dt", ".", "time", "(", ")", ")", "if", "not", "self", ".", "_order_generator", ":", "raise", "ProphetException", "(", "\"Must set an order generator by calling\"", "\"set_order_generator.\"", ")", "timestamps", "=", "trading_days", "[", "(", "trading_days", ">=", "start", ")", "&", "(", "trading_days", "<=", "end", ")", "]", "effective_start", "=", "timestamps", "[", "0", "]", "data", "=", "self", ".", "_generate_data", "(", "start", "=", "effective_start", ",", "end", "=", "end", ",", "lookback", "=", "lookback", ")", "# Run backtest", "return", "backtest", "(", "cash", "=", "cash", ",", "data", "=", "data", ",", "start", "=", "effective_start", ",", "end", "=", "end", ",", "slippage", "=", "slippage", ",", "commission", "=", "commission", ",", "portfolio", "=", "initial_portfolio", ",", "order_generator", "=", "self", ".", "_order_generator", ",", ")" ]

[ "List", "of", "extensions", ".", "RequestException", "extension", "objects", "." ]

[ "def", "get_request_extensions", "(", "self", ")", ":", "request_exts", "=", "[", "]", "return", "request_exts" ]

[ "Set", "self", ".", "base_job_name", "if", "it", "is", "not", "set", "already", "." ]

[ "def", "_ensure_base_job_name", "(", "self", ")", ":", "# honor supplied base_job_name or generate it", "if", "self", ".", "base_job_name", "is", "None", ":", "self", ".", "base_job_name", "=", "base_name_from_image", "(", "self", ".", "training_image_uri", "(", ")", ")" ]

[ "Wait", "for", "a", "task", "to", "complete", "with", "timeout" ]

[ "def", "_wait_task", "(", "self", ",", "task", ")", ":", "limit", "=", "timedelta", "(", "seconds", "=", "int", "(", "self", ".", "options_globals", ".", "timeouts", ".", "vm_state", ")", ")", "start", "=", "datetime", ".", "utcnow", "(", ")", "while", "True", ":", "if", "task", ".", "info", ".", "state", "==", "\"error\"", ":", "raise", "CuckooMachineError", "(", "\"Task error\"", ")", "if", "task", ".", "info", ".", "state", "==", "\"success\"", ":", "break", "if", "datetime", ".", "utcnow", "(", ")", "-", "start", ">", "limit", ":", "raise", "CuckooMachineError", "(", "\"Task timed out\"", ")", "time", ".", "sleep", "(", "1", ")" ]

[ "CreateClusterRequestContent", "-", "a", "model", "defined", "in", "OpenAPI" ]

[ "def", "__init__", "(", "self", ",", "cluster_name", "=", "None", ",", "cluster_configuration", "=", "None", ")", ":", "self", ".", "openapi_types", "=", "{", "\"cluster_name\"", ":", "str", ",", "\"cluster_configuration\"", ":", "str", "}", "self", ".", "attribute_map", "=", "{", "\"cluster_name\"", ":", "\"clusterName\"", ",", "\"cluster_configuration\"", ":", "\"clusterConfiguration\"", "}", "self", ".", "_cluster_name", "=", "cluster_name", "self", ".", "_cluster_configuration", "=", "cluster_configuration" ]

[ "Return", "true", "if", "vm", "is", "running" ]

[ "def", "is_running", "(", "search", ")", ":", "return", "_action", "(", "\"is_running\"", ",", "search", ",", "False", ")" ]

[ "Creates", "a", "label", "colormap", "used", "in", "ADE20K", "segmentation", "benchmark", "." ]

[ "def", "create_ade20k_label_colormap", "(", ")", ":", "return", "np", ".", "asarray", "(", "[", "[", "0", ",", "0", ",", "0", "]", ",", "[", "120", ",", "120", ",", "120", "]", ",", "[", "180", ",", "120", ",", "120", "]", ",", "[", "6", ",", "230", ",", "230", "]", ",", "[", "80", ",", "50", ",", "50", "]", ",", "[", "4", ",", "200", ",", "3", "]", ",", "[", "120", ",", "120", ",", "80", "]", ",", "[", "140", ",", "140", ",", "140", "]", ",", "[", "204", ",", "5", ",", "255", "]", ",", "[", "230", ",", "230", ",", "230", "]", ",", "[", "4", ",", "250", ",", "7", "]", ",", "[", "224", ",", "5", ",", "255", "]", ",", "[", "235", ",", "255", ",", "7", "]", ",", "[", "150", ",", "5", ",", "61", "]", ",", "[", "120", ",", "120", ",", "70", "]", ",", "[", "8", ",", "255", ",", "51", "]", ",", "[", "255", ",", "6", ",", "82", "]", ",", "[", "143", ",", "255", ",", "140", "]", ",", "[", "204", ",", "255", ",", "4", "]", ",", "[", "255", ",", "51", ",", "7", "]", ",", "[", "204", ",", "70", ",", "3", "]", ",", "[", "0", ",", "102", ",", "200", "]", ",", "[", "61", ",", "230", ",", "250", "]", ",", "[", "255", ",", "6", ",", "51", "]", ",", "[", "11", ",", "102", ",", "255", "]", ",", "[", "255", ",", "7", ",", "71", "]", ",", "[", "255", ",", "9", ",", "224", "]", ",", "[", "9", ",", "7", ",", "230", "]", ",", "[", "220", ",", "220", ",", "220", "]", ",", "[", "255", ",", "9", ",", "92", "]", ",", "[", "112", ",", "9", ",", "255", "]", ",", "[", "8", ",", "255", ",", "214", "]", ",", "[", "7", ",", "255", ",", "224", "]", ",", "[", "255", ",", "184", ",", "6", "]", ",", "[", "10", ",", "255", ",", "71", "]", ",", "[", "255", ",", "41", ",", "10", "]", ",", "[", "7", ",", "255", ",", "255", "]", ",", "[", "224", ",", "255", ",", "8", "]", ",", "[", "102", ",", "8", ",", "255", "]", ",", "[", "255", ",", "61", ",", "6", "]", ",", "[", "255", ",", "194", ",", "7", "]", ",", "[", "255", ",", "122", ",", "8", "]", ",", "[", "0", ",", "255", ",", "20", "]", ",", "[", "255", ",", "8", ",", "41", "]", ",", "[", "255", ",", "5", ",", "153", "]", ",", "[", "6", ",", "51", ",", "255", "]", ",", "[", "235", ",", "12", ",", "255", "]", ",", "[", "160", ",", "150", ",", "20", "]", ",", "[", "0", ",", "163", ",", "255", "]", ",", "[", "140", ",", "140", ",", "140", "]", ",", "[", "250", ",", "10", ",", "15", "]", ",", "[", "20", ",", "255", ",", "0", "]", ",", "[", "31", ",", "255", ",", "0", "]", ",", "[", "255", ",", "31", ",", "0", "]", ",", "[", "255", ",", "224", ",", "0", "]", ",", "[", "153", ",", "255", ",", "0", "]", ",", "[", "0", ",", "0", ",", "255", "]", ",", "[", "255", ",", "71", ",", "0", "]", ",", "[", "0", ",", "235", ",", "255", "]", ",", "[", "0", ",", "173", ",", "255", "]", ",", "[", "31", ",", "0", ",", "255", "]", ",", "[", "11", ",", "200", ",", "200", "]", ",", "[", "255", ",", "82", ",", "0", "]", ",", "[", "0", ",", "255", ",", "245", "]", ",", "[", "0", ",", "61", ",", "255", "]", ",", "[", "0", ",", "255", ",", "112", "]", ",", "[", "0", ",", "255", ",", "133", "]", ",", "[", "255", ",", "0", ",", "0", "]", ",", "[", "255", ",", "163", ",", "0", "]", ",", "[", "255", ",", "102", ",", "0", "]", ",", "[", "194", ",", "255", ",", "0", "]", ",", "[", "0", ",", "143", ",", "255", "]", ",", "[", "51", ",", "255", ",", "0", "]", ",", "[", "0", ",", "82", ",", "255", "]", ",", "[", "0", ",", "255", ",", "41", "]", ",", "[", "0", ",", "255", ",", "173", "]", ",", "[", "10", ",", "0", ",", "255", "]", ",", "[", "173", ",", "255", ",", "0", "]", ",", "[", "0", ",", "255", ",", "153", "]", ",", "[", "255", ",", "92", ",", "0", "]", ",", "[", "255", ",", "0", ",", "255", "]", ",", "[", "255", ",", "0", ",", "245", "]", ",", "[", "255", ",", "0", ",", "102", "]", ",", "[", "255", ",", "173", ",", "0", "]", ",", "[", "255", ",", "0", ",", "20", "]", ",", "[", "255", ",", "184", ",", "184", "]", ",", "[", "0", ",", "31", ",", "255", "]", ",", "[", "0", ",", "255", ",", "61", "]", ",", "[", "0", ",", "71", ",", "255", "]", ",", "[", "255", ",", "0", ",", "204", "]", ",", "[", "0", ",", "255", ",", "194", "]", ",", "[", "0", ",", "255", ",", "82", "]", ",", "[", "0", ",", "10", ",", "255", "]", ",", "[", "0", ",", "112", ",", "255", "]", ",", "[", "51", ",", "0", ",", "255", "]", ",", "[", "0", ",", "194", ",", "255", "]", ",", "[", "0", ",", "122", ",", "255", "]", ",", "[", "0", ",", "255", ",", "163", "]", ",", "[", "255", ",", "153", ",", "0", "]", ",", "[", "0", ",", "255", ",", "10", "]", ",", "[", "255", ",", "112", ",", "0", "]", ",", "[", "143", ",", "255", ",", "0", "]", ",", "[", "82", ",", "0", ",", "255", "]", ",", "[", "163", ",", "255", ",", "0", "]", ",", "[", "255", ",", "235", ",", "0", "]", ",", "[", "8", ",", "184", ",", "170", "]", ",", "[", "133", ",", "0", ",", "255", "]", ",", "[", "0", ",", "255", ",", "92", "]", ",", "[", "184", ",", "0", ",", "255", "]", ",", "[", "255", ",", "0", ",", "31", "]", ",", "[", "0", ",", "184", ",", "255", "]", ",", "[", "0", ",", "214", ",", "255", "]", ",", "[", "255", ",", "0", ",", "112", "]", ",", "[", "92", ",", "255", ",", "0", "]", ",", "[", "0", ",", "224", ",", "255", "]", ",", "[", "112", ",", "224", ",", "255", "]", ",", "[", "70", ",", "184", ",", "160", "]", ",", "[", "163", ",", "0", ",", "255", "]", ",", "[", "153", ",", "0", ",", "255", "]", ",", "[", "71", ",", "255", ",", "0", "]", ",", "[", "255", ",", "0", ",", "163", "]", ",", "[", "255", ",", "204", ",", "0", "]", ",", "[", "255", ",", "0", ",", "143", "]", ",", "[", "0", ",", "255", ",", "235", "]", ",", "[", "133", ",", "255", ",", "0", "]", ",", "[", "255", ",", "0", ",", "235", "]", ",", "[", "245", ",", "0", ",", "255", "]", ",", "[", "255", ",", "0", ",", "122", "]", ",", "[", "255", ",", "245", ",", "0", "]", ",", "[", "10", ",", "190", ",", "212", "]", ",", "[", "214", ",", "255", ",", "0", "]", ",", "[", "0", ",", "204", ",", "255", "]", ",", "[", "20", ",", "0", ",", "255", "]", ",", "[", "255", ",", "255", ",", "0", "]", ",", "[", "0", ",", "153", ",", "255", "]", ",", "[", "0", ",", "41", ",", "255", "]", ",", "[", "0", ",", "255", ",", "204", "]", ",", "[", "41", ",", "0", ",", "255", "]", ",", "[", "41", ",", "255", ",", "0", "]", ",", "[", "173", ",", "0", ",", "255", "]", ",", "[", "0", ",", "245", ",", "255", "]", ",", "[", "71", ",", "0", ",", "255", "]", ",", "[", "122", ",", "0", ",", "255", "]", ",", "[", "0", ",", "255", ",", "184", "]", ",", "[", "0", ",", "92", ",", "255", "]", ",", "[", "184", ",", "255", ",", "0", "]", ",", "[", "0", ",", "133", ",", "255", "]", ",", "[", "255", ",", "214", ",", "0", "]", ",", "[", "25", ",", "194", ",", "194", "]", ",", "[", "102", ",", "255", ",", "0", "]", ",", "[", "92", ",", "0", ",", "255", "]", ",", "]", ")" ]

[]

[ "def", "collect", "(", "self", ")", ":", "for", "stat", ",", "v", "in", "self", ".", "get_ntpq_stats", "(", ")", ":", "self", ".", "publish", "(", "stat", ",", "v", "[", "'val'", "]", ",", "precision", "=", "v", "[", "'precision'", "]", ")", "for", "stat", ",", "v", "in", "self", ".", "get_ntpdc_kerninfo_stats", "(", ")", ":", "self", ".", "publish", "(", "stat", ",", "v", "[", "'val'", "]", ",", "precision", "=", "v", "[", "'precision'", "]", ")", "for", "stat", ",", "v", "in", "self", ".", "get_ntpdc_sysinfo_stats", "(", ")", ":", "self", ".", "publish", "(", "stat", ",", "v", "[", "'val'", "]", ",", "precision", "=", "v", "[", "'precision'", "]", ")" ]

[ "Sends", "an", "OPTIONS", "request", "." ]

[ "def", "options", "(", "url", ":", "URLTypes", ",", "*", ",", "params", ":", "QueryParamTypes", "=", "None", ",", "headers", ":", "HeaderTypes", "=", "None", ",", "cookies", ":", "CookieTypes", "=", "None", ",", "auth", ":", "AuthTypes", "=", "None", ",", "allow_redirects", ":", "bool", "=", "True", ",", "cert", ":", "CertTypes", "=", "None", ",", "verify", ":", "VerifyTypes", "=", "True", ",", "timeout", ":", "TimeoutTypes", "=", "DEFAULT_TIMEOUT_CONFIG", ",", "trust_env", ":", "bool", "=", "True", ",", ")", "->", "Response", ":", "return", "request", "(", "\"OPTIONS\"", ",", "url", ",", "params", "=", "params", ",", "headers", "=", "headers", ",", "cookies", "=", "cookies", ",", "auth", "=", "auth", ",", "allow_redirects", "=", "allow_redirects", ",", "cert", "=", "cert", ",", "verify", "=", "verify", ",", "timeout", "=", "timeout", ",", "trust_env", "=", "trust_env", ",", ")" ]

[]

[ "def", "read", "(", "fname", ")", ":", "with", "open", "(", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "__file__", ")", ",", "fname", ")", ")", "as", "_in", ":", "return", "_in", ".", "read", "(", ")" ]

[ "Sets", "the", "operations", "of", "this", "V1RuleWithOperations", "." ]

[ "def", "operations", "(", "self", ",", "operations", ")", ":", "self", ".", "_operations", "=", "operations" ]

[ "Insert", "the", "arguments", "into", "the", "compiled", "MATCH", "query", "to", "form", "a", "complete", "query", "." ]

[ "def", "insert_arguments_into_match_query", "(", "compilation_result", ",", "arguments", ")", ":", "if", "compilation_result", ".", "language", "!=", "MATCH_LANGUAGE", ":", "raise", "AssertionError", "(", "\"Unexpected query output language: {}\"", ".", "format", "(", "compilation_result", ")", ")", "base_query", "=", "compilation_result", ".", "query", "argument_types", "=", "compilation_result", ".", "input_metadata", "# The arguments are assumed to have already been validated against the query.", "sanitized_arguments", "=", "{", "key", ":", "_safe_match_argument", "(", "argument_types", "[", "key", "]", ",", "value", ")", "for", "key", ",", "value", "in", "six", ".", "iteritems", "(", "arguments", ")", "}", "return", "base_query", ".", "format", "(", "*", "*", "sanitized_arguments", ")" ]

[ "Return", "the", "given", "path", "\\", "*", "atoms", "joined", "into", "a", "single", "URL", "." ]

[ "def", "urljoin", "(", "*", "atoms", ")", ":", "url", "=", "\"/\"", ".", "join", "(", "[", "x", "for", "x", "in", "atoms", "if", "x", "]", ")", "while", "\"//\"", "in", "url", ":", "url", "=", "url", ".", "replace", "(", "\"//\"", ",", "\"/\"", ")", "# Special-case the final url of \"\", and return \"/\" instead.", "return", "url", "or", "\"/\"" ]

[ "Converts", "a", "string", "to", "a", "datetime", ".", "time", "object", "." ]

[ "def", "_GetTime", "(", "time_string", ")", ":", "hourstr", ",", "minutestr", "=", "time_string", ".", "split", "(", "':'", ")", "return", "datetime", ".", "time", "(", "int", "(", "hourstr", ")", ",", "int", "(", "minutestr", ")", ")" ]

[ "Destroy", "the", "service", "or", "raise", "if", "it", "does", "not", "exist", "." ]

[ "def", "service_destroy", "(", "context", ",", "service_id", ")", ":", "return", "IMPL", ".", "service_destroy", "(", "context", ",", "service_id", ")" ]

[ "Set", "the", "value", "that", "indicates", "whether", "there", "are", "more", "pages", "of", "projects", "that", "can", "be", "loaded", "from", "the", "API" ]

[ "def", "setHasMoreProjectsToLoad", "(", "self", ",", "has_more_projects_to_load", ":", "bool", ")", "->", "None", ":", "if", "has_more_projects_to_load", "!=", "self", ".", "_has_more_projects_to_load", ":", "self", ".", "_has_more_projects_to_load", "=", "has_more_projects_to_load", "self", ".", "hasMoreProjectsToLoadChanged", ".", "emit", "(", ")" ]

[ "costume", "decorator", "to", "suppers", "debug", "messages", "from", "the", "PIL", "function", "to", "suppress", "PIl", "debug", "logging", "-", "DEBUG", ":", "PIL", ".", "PngImagePlugin", ":", "STREAM", "b", "IHDR", "16", "13" ]

[ "def", "io_image_decorate", "(", "func", ")", ":", "@", "wraps", "(", "func", ")", "def", "wrap", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "log_level", "=", "logging", ".", "getLogger", "(", ")", ".", "getEffectiveLevel", "(", ")", "logging", ".", "getLogger", "(", ")", ".", "setLevel", "(", "logging", ".", "INFO", ")", "with", "warnings", ".", "catch_warnings", "(", ")", ":", "warnings", ".", "simplefilter", "(", "\"ignore\"", ")", "response", "=", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "logging", ".", "getLogger", "(", ")", ".", "setLevel", "(", "log_level", ")", "return", "response", "return", "wrap" ]

[ "Add", "arguments", "to", "the", "command", "." ]

[ "def", "add_arguments", "(", "self", ",", "parser", ")", ":", "parser", ".", "add_argument", "(", "'check_name'", ",", "metavar", "=", "'NAME'", ",", "help", "=", "_", "(", "'The name of the check to resolve.'", ")", ")" ]

[ "Schedule", "the", "next", "monitoring", "call", "." ]

[ "def", "_setupMonitor", "(", "self", ")", ":", "from", "twisted", ".", "internet", "import", "reactor", "t", ",", "self", ".", "index", "=", "self", ".", "intervals", ".", "next", "(", ")", "self", ".", "_call", "=", "reactor", ".", "callLater", "(", "t", ",", "self", ".", "_monitor", ")" ]

[ "Connection", "watchdog", "loop", "that", "checks", "the", "communication", "channel", "to", "the", "server", ".", ":", "return", ":" ]

[ "def", "run", "(", "self", ")", ":", "# check every 5 seconds if the client is still connected", "# and the time of the last received data", "# from the server lies too far in the past", "while", "True", ":", "# wait 5 seconds before checking time of last received data", "for", "i", "in", "range", "(", "5", ")", ":", "if", "self", ".", "_exit_flag", ":", "logging", ".", "info", "(", "\"[%s]: Exiting Connection Watchdog.\"", "%", "self", ".", "_log_tag", ")", "return", "time", ".", "sleep", "(", "1", ")", "utc_timestamp", "=", "int", "(", "time", ".", "time", "(", ")", ")", "# Connect to server if communication channel is not connected anymore.", "if", "not", "self", ".", "_connection", ".", "is_connected", ":", "logging", ".", "error", "(", "\"[%s]: Connection to server has died. \"", "%", "self", ".", "_log_tag", ")", "# Reconnect to the server.", "while", "True", ":", "# Check if 5 unsuccessful attempts are made to connect", "# to the server and if smtp alert is activated", "# => send eMail alert", "if", "self", ".", "_smtp_alert", "is", "not", "None", "and", "(", "self", ".", "_connection_retries", "%", "5", ")", "==", "0", ":", "self", ".", "_smtp_alert", ".", "sendCommunicationAlert", "(", "self", ".", "_connection_retries", ")", "# try to connect to the server", "if", "self", ".", "_connection", ".", "reconnect", "(", ")", ":", "# if smtp alert is activated", "# => send email that communication problems are solved", "if", "self", ".", "_smtp_alert", "is", "not", "None", ":", "self", ".", "_smtp_alert", ".", "sendCommunicationAlertClear", "(", ")", "logging", ".", "info", "(", "\"[%s] Reconnecting successful after %d attempts.\"", "%", "(", "self", ".", "_log_tag", ",", "self", ".", "_connection_retries", ")", ")", "self", ".", "_connection_retries", "=", "1", "break", "self", ".", "_connection_retries", "+=", "1", "logging", ".", "error", "(", "\"[%s]: Reconnecting failed. Retrying in 5 seconds.\"", "%", "self", ".", "_log_tag", ")", "time", ".", "sleep", "(", "5", ")", "# Check if the time of the data last received lies too far in the", "# past => send ping to check connection", "elif", "(", "utc_timestamp", "-", "self", ".", "_connection", ".", "last_communication", ")", ">", "self", ".", "_ping_interval", ":", "logging", ".", "debug", "(", "\"[%s]: Ping interval exceeded.\"", "%", "self", ".", "_log_tag", ")", "# check if PING failed", "promise", "=", "self", ".", "_connection", ".", "send_ping", "(", ")", "# type: Promise", "# Wait for ping response to finish (in a non-blocking way since otherwise we could", "# get a deadlock in which we do not re-connect to the server anymore).", "is_finished", "=", "False", "for", "_", "in", "range", "(", "self", ".", "_ping_delay_warning", ")", ":", "if", "promise", ".", "is_finished", "(", "blocking", "=", "False", ")", ":", "is_finished", "=", "True", "break", "time", ".", "sleep", "(", "1", ")", "if", "is_finished", ":", "if", "not", "promise", ".", "was_successful", "(", ")", ":", "logging", ".", "error", "(", "\"[%s]: Connection to server has died.\"", "%", "self", ".", "_log_tag", ")", "else", ":", "logging", ".", "warning", "(", "\"[%s]: Stopped waiting for ping response after %d seconds.\"", "%", "(", "self", ".", "_log_tag", ",", "self", ".", "_ping_delay_warning", ")", ")" ]

[ "Open", "the", "file", "in", "bytes", "mode", "read", "it", "and", "close", "the", "file", "." ]

[ "def", "read_bytes", "(", "self", ")", ":", "with", "self", ".", "open", "(", "mode", "=", "'rb'", ")", "as", "f", ":", "return", "f", ".", "read", "(", ")" ]

[ "Register", "Service", "Discovery", "cache", "fetchers", "into", "given", "cache", "suite", "and", "using", "the", "stream", "provided", "." ]

[ "def", "register_disco_cache_fetchers", "(", "cache_suite", ",", "stream", ")", ":", "tmp", "=", "stream", "class", "DiscoInfoCacheFetcher", "(", "DiscoCacheFetcherBase", ")", ":", "\"\"\"Cache fetcher for DiscoInfo.\"\"\"", "stream", "=", "tmp", "disco_class", "=", "DiscoInfo", "class", "DiscoItemsCacheFetcher", "(", "DiscoCacheFetcherBase", ")", ":", "\"\"\"Cache fetcher for DiscoItems.\"\"\"", "stream", "=", "tmp", "disco_class", "=", "DiscoItems", "cache_suite", ".", "register_fetcher", "(", "DiscoInfo", ",", "DiscoInfoCacheFetcher", ")", "cache_suite", ".", "register_fetcher", "(", "DiscoItems", ",", "DiscoItemsCacheFetcher", ")" ]

[]

[ "def", "__init__", "(", "self", ",", "filepath", ")", ":", "self", ".", "_original_path", "=", "filepath", "try", ":", "self", ".", "reader", "=", "mutagen", ".", "File", "(", "filepath", ",", "easy", "=", "True", ")", "except", "Exception", ",", "e", ":", "raise", "MetadataManagerReadError", "(", "e", ".", "message", ")" ]

[ "ensure", "that", "the", "driver", "process", "terminates" ]

[ "def", "stop_framework", "(", "driver", ")", ":", "status", "=", "0", "if", "driver", ".", "run", "(", ")", "==", "mesos_pb2", ".", "DRIVER_STOPPED", "else", "1", "driver", ".", "stop", "(", ")", "sys", ".", "exit", "(", "status", ")" ]

[ "Footnotes", "hyperlink", "targets", "directives", "comments", "." ]

[ "def", "explicit_markup", "(", "self", ",", "match", ",", "context", ",", "next_state", ")", ":", "nodelist", ",", "blank_finish", "=", "self", ".", "explicit_construct", "(", "match", ")", "self", ".", "parent", "+=", "nodelist", "self", ".", "explicit_list", "(", "blank_finish", ")", "return", "[", "]", ",", "next_state", ",", "[", "]" ]

[ "Returns", "whether", "one", "path", "starts", "with", "another" ]

[ "def", "path_startswith", "(", "path", ",", "prefix", ")", ":", "if", "len", "(", "prefix", ")", ">", "len", "(", "path", ")", ":", "return", "False", "for", "i", "in", "xrange", "(", "len", "(", "prefix", ")", ")", ":", "if", "path", "[", "i", "]", "!=", "prefix", "[", "i", "]", ":", "return", "False", "return", "True" ]

[]

[ "def", "extract", "(", "self", ")", ":", "return", "pd", ".", "read_csv", "(", "self", ".", "source_url", ",", "low_memory", "=", "False", ")" ]

[ "initialization", "function", "for", "the", "module", ":", "returns", "a", "wxBitmapButton", "to", "be", "added", "to", "the", "main", "palette" ]

[ "def", "initialize", "(", ")", ":", "common", ".", "widget_classes", "[", "'EditDatePickerCtrl'", "]", "=", "EditDatePickerCtrl", "common", ".", "widgets", "[", "'EditDatePickerCtrl'", "]", "=", "builder", "common", ".", "widgets_from_xml", "[", "'EditDatePickerCtrl'", "]", "=", "xml_builder", "return", "common", ".", "make_object_button", "(", "'EditDatePickerCtrl'", ",", "'datepicker_ctrl.png'", ")" ]

[ "Turn", "competition", "mode", "on", "or", "off", "." ]

[ "def", "competition_mode", "(", "self", ",", "on", ")", ":", "pass" ]

[ "Creates", "a", "new", "_GateDefinition", "as", "a", "copy", "of", "the", "existing", "definition", "but", "with", "a", "new", "with_can_serialize_predicate", ".", "This", "is", "useful", "if", "multiple", "definitions", "exist", "for", "the", "same", "gate", "but", "with", "different", "conditions", "." ]

[ "def", "with_can_serialize_predicate", "(", "self", ",", "can_serialize_predicate", ":", "Callable", "[", "[", "cirq", ".", "Operation", "]", ",", "bool", "]", ")", "->", "'_GateDefinition'", ":", "return", "_GateDefinition", "(", "self", ".", "duration", ",", "self", ".", "target_set", ",", "self", ".", "number_of_qubits", ",", "self", ".", "is_permutation", ",", "can_serialize_predicate", ",", ")" ]

[ "Computes", "the", "precision" ]

[ "def", "accuracy", "(", "output", ",", "target", ",", "topk", "=", "(", "1", ",", ")", ")", ":", "maxk", "=", "max", "(", "topk", ")", "batch_size", "=", "target", ".", "size", "(", "0", ")", "_", ",", "pred", "=", "output", ".", "topk", "(", "maxk", ",", "1", ",", "True", ",", "True", ")", "pred", "=", "pred", ".", "t", "(", ")", "correct", "=", "pred", ".", "eq", "(", "target", ".", "view", "(", "1", ",", "-", "1", ")", ".", "expand_as", "(", "pred", ")", ")", "res", "=", "[", "]", "for", "k", "in", "topk", ":", "correct_k", "=", "correct", "[", ":", "k", "]", ".", "view", "(", "-", "1", ")", ".", "float", "(", ")", ".", "sum", "(", "0", ")", "res", ".", "append", "(", "correct_k", ".", "mul_", "(", "100.0", "/", "batch_size", ")", ")", "return", "res" ]

[ "Return", "to", "overview" ]

[ "def", "get_success_url", "(", "self", ")", ":", "return", "reverse", "(", "'gallery:images:overview'", ")" ]

[ "Set", "the", "current", "path", ".", "If", "an", "invalid", "directory", "is", "given", "the", "path", "is", "not", "changed", ".", "The", "given", "path", "can", "be", "absolute", "or", "relative", "to", "the", "current", "path", "." ]

[ "def", "set_path", "(", "self", ",", "dirname", "=", "None", ")", ":", "if", "dirname", "is", "None", "or", "not", "isinstance", "(", "dirname", ",", "str", ")", ":", "dirname", "=", "\"~\"", "if", "dirname", ".", "startswith", "(", "\"~\"", ")", ":", "dirname", "=", "os", ".", "path", ".", "expanduser", "(", "dirname", ")", "if", "not", "os", ".", "path", ".", "isabs", "(", "dirname", ")", ":", "dirname", "=", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "join", "(", "self", ".", "path", ",", "dirname", ")", ")", "# Set if valid, otherwise default to home dir", "if", "os", ".", "path", ".", "isdir", "(", "dirname", ")", ":", "self", ".", "_mutate", "(", "\"path\"", ",", "dirname", ")", "elif", "not", "self", ".", "path", ":", "self", ".", "_mutate", "(", "\"path\"", ",", "os", ".", "path", ".", "expanduser", "(", "\"~\"", ")", ")" ]

[]

[ "def", "ai_excit_idle_output_behavior", "(", "self", ")", ":", "cfunc", "=", "lib_importer", ".", "windll", ".", "DAQmxResetAIExcitIdleOutputBehavior", "if", "cfunc", ".", "argtypes", "is", "None", ":", "with", "cfunc", ".", "arglock", ":", "if", "cfunc", ".", "argtypes", "is", "None", ":", "cfunc", ".", "argtypes", "=", "[", "lib_importer", ".", "task_handle", ",", "ctypes_byte_str", "]", "error_code", "=", "cfunc", "(", "self", ".", "_handle", ",", "self", ".", "_name", ")", "check_for_error", "(", "error_code", ")" ]

[ "Return", "the", "object", "as", "a", "GNU", "header", "block", "sequence", "." ]

[ "def", "create_gnu_header", "(", "self", ",", "info", ",", "encoding", ",", "errors", ")", ":", "info", "[", "\"magic\"", "]", "=", "GNU_MAGIC", "buf", "=", "b\"\"", "if", "len", "(", "info", "[", "\"linkname\"", "]", ".", "encode", "(", "encoding", ",", "errors", ")", ")", ">", "LENGTH_LINK", ":", "buf", "+=", "self", ".", "_create_gnu_long_header", "(", "info", "[", "\"linkname\"", "]", ",", "GNUTYPE_LONGLINK", ",", "encoding", ",", "errors", ")", "if", "len", "(", "info", "[", "\"name\"", "]", ".", "encode", "(", "encoding", ",", "errors", ")", ")", ">", "LENGTH_NAME", ":", "buf", "+=", "self", ".", "_create_gnu_long_header", "(", "info", "[", "\"name\"", "]", ",", "GNUTYPE_LONGNAME", ",", "encoding", ",", "errors", ")", "return", "buf", "+", "self", ".", "_create_header", "(", "info", ",", "GNU_FORMAT", ",", "encoding", ",", "errors", ")" ]

[]

[ "def", "execute", "(", "self", ",", "context", ")", ":", "prefs", "=", "Utils", ".", "get_preferences", "(", ")", "p", "=", "prefs", ".", "csv_path", "with", "open", "(", "p", ",", "mode", "=", "'w'", ",", "encoding", "=", "'utf-8'", ")", "as", "f", ":", "f", ".", "write", "(", "\"{0}\\n\"", ".", "format", "(", "prefs", ".", "csv_first_line", ")", ")", "return", "{", "'FINISHED'", "}" ]

[ "r", "Compute", "the", "degree", "centrality", "for", "nodes", "in", "a", "bipartite", "network", "." ]

[ "def", "degree_centrality", "(", "G", ",", "nodes", ")", ":", "top", "=", "set", "(", "nodes", ")", "bottom", "=", "set", "(", "G", ")", "-", "top", "s", "=", "1.0", "/", "len", "(", "bottom", ")", "centrality", "=", "dict", "(", "(", "n", ",", "d", "*", "s", ")", "for", "n", ",", "d", "in", "G", ".", "degree", "(", "top", ")", ")", "s", "=", "1.0", "/", "len", "(", "top", ")", "centrality", ".", "update", "(", "dict", "(", "(", "n", ",", "d", "*", "s", ")", "for", "n", ",", "d", "in", "G", ".", "degree", "(", "bottom", ")", ")", ")", "return", "centrality" ]

[ "Authobject", "to", "use", "with", "PLAIN", "authentication", ".", "Requires", "self", ".", "user", "and", "self", ".", "password", "to", "be", "set", "." ]

[ "def", "auth_plain", "(", "self", ",", "challenge", "=", "None", ")", ":", "return", "\"\\0%s\\0%s\"", "%", "(", "self", ".", "user", ",", "self", ".", "password", ")" ]

[ "finalize", "what", "the", "contents", "of", "the", "dict", "should", "look", "like", "before", "output" ]

[ "def", "fix_contents", "(", "self", ")", ":", "for", "item", "in", "self", ".", "outdict", ":", "numEmpty", "=", "self", ".", "outdict", "[", "item", "]", ".", "count", "(", "''", ")", "for", "i", "in", "xrange", "(", "numEmpty", ")", ":", "self", ".", "outdict", "[", "item", "]", ".", "remove", "(", "''", ")", "if", "self", ".", "outdict", "[", "item", "]", ":", "self", ".", "outdict", "[", "item", "]", ".", "pop", "(", "0", ")" ]

[ "Returns", "the", "last", "reported", "state", "of", "a", "keyboard", "key", "for", "the", "specified", "window", "." ]

[ "def", "get_key", "(", "window", ",", "key", ")", ":", "return", "_glfw", ".", "glfwGetKey", "(", "window", ",", "key", ")" ]

[ "Constructor", "." ]

[ "def", "__init__", "(", "self", ",", "anchorwise_output", "=", "False", ",", "logit_scale", "=", "1.0", ")", ":", "self", ".", "_anchorwise_output", "=", "anchorwise_output", "self", ".", "_logit_scale", "=", "logit_scale" ]

[ "Unsets", "a", "user", "s", "authenticated", "hostmask", "." ]

[ "def", "clearAuth", "(", "self", ")", ":", "for", "(", "when", ",", "hostmask", ")", "in", "self", ".", "auth", ":", "users", ".", "invalidateCache", "(", "hostmask", "=", "hostmask", ")", "self", ".", "auth", "=", "[", "]" ]

[ "Test", "if", "this", "address", "is", "allocated", "for", "private", "networks", "." ]

[ "def", "is_private", "(", "self", ")", ":", "return", "(", "self", "in", "IPv4Network", "(", "'10.0.0.0/8'", ")", "or", "self", "in", "IPv4Network", "(", "'172.16.0.0/12'", ")", "or", "self", "in", "IPv4Network", "(", "'192.168.0.0/16'", ")", ")" ]

[ "Returns", "the", "exponent", "of", "the", "magnitude", "of", "self", "s", "MSD", "." ]

[ "def", "logb", "(", "self", ",", "context", "=", "None", ")", ":", "# logb(NaN) = NaN", "ans", "=", "self", ".", "_check_nans", "(", "context", "=", "context", ")", "if", "ans", ":", "return", "ans", "if", "context", "is", "None", ":", "context", "=", "getcontext", "(", ")", "# logb(+/-Inf) = +Inf", "if", "self", ".", "_isinfinity", "(", ")", ":", "return", "_Infinity", "# logb(0) = -Inf, DivisionByZero", "if", "not", "self", ":", "return", "context", ".", "_raise_error", "(", "DivisionByZero", ",", "'logb(0)'", ",", "1", ")", "# otherwise, simply return the adjusted exponent of self, as a", "# Decimal. Note that no attempt is made to fit the result", "# into the current context.", "ans", "=", "Decimal", "(", "self", ".", "adjusted", "(", ")", ")", "return", "ans", ".", "_fix", "(", "context", ")" ]

[ "Input", ":", "{", "uid", "[", "str", "]", "-", "portal", "identifier", "of", "the", "solution", "}" ]

[ "def", "publish_result", "(", "i", ")", ":", "# Get main configuration", "r", "=", "config", ".", "load", "(", "{", "}", ")", "if", "r", "[", "'return'", "]", ">", "0", ":", "return", "r", "cfg", "=", "r", ".", "get", "(", "'dict'", ",", "{", "}", ")", "pcfg", "=", "r", ".", "get", "(", "'path'", ",", "''", ")", "xcmd", "=", "i", ".", "get", "(", "'cmd'", ",", "''", ")", "if", "xcmd", "==", "None", ":", "xcmd", "=", "''", "xcmd", "=", "xcmd", ".", "strip", "(", ")", "cur_dir", "=", "os", ".", "getcwd", "(", ")", "# Check if Windows or Linux", "# Get platform info ", "r", "=", "get_platform_desc", "(", "i", ")", "# Pass input from init", "if", "r", "[", "'return'", "]", ">", "0", ":", "return", "r", "hos", "=", "r", "[", "'host_os_uid'", "]", "hosx", "=", "r", "[", "'host_os_uoa'", "]", "hosd", "=", "r", "[", "'host_os_dict'", "]", "hosd_extra", "=", "r", "[", "'host_desc'", "]", "tos", "=", "r", "[", "'os_uid'", "]", "tosx", "=", "r", "[", "'os_uoa'", "]", "tosd", "=", "r", "[", "'os_dict'", "]", "# Load entry with the solution", "uid", "=", "i", "[", "'uid'", "]", "r", "=", "ck", ".", "access", "(", "{", "'action'", ":", "'load'", ",", "'module_uoa'", ":", "config", ".", "CR_MODULE_UOA", ",", "'data_uoa'", ":", "uid", "}", ")", "if", "r", "[", "'return'", "]", ">", "0", ":", "return", "r", "solution_uoa", "=", "r", "[", "'data_uoa'", "]", "solution_uid", "=", "r", "[", "'data_uid'", "]", "p", "=", "r", "[", "'path'", "]", "dd", "=", "r", "[", "'dict'", "]", "# TBD: need to be checked from outside ...", "host_os", "=", "dd", ".", "get", "(", "'host_os'", ",", "''", ")", "tos", "=", "dd", ".", "get", "(", "'target_os'", ",", "''", ")", "tdid", "=", "dd", ".", "get", "(", "'device_id'", ",", "''", ")", "workflow", "=", "dd", ".", "get", "(", "'workflow'", ",", "''", ")", "workflow_cmd", "=", "dd", ".", "get", "(", "'workflow_cmd'", ",", "''", ")", "workflow_cmd_extra", "=", "dd", ".", "get", "(", "'workflow_cmd_extra'", ",", "''", ")", "workflow_input_dir", "=", "dd", ".", "get", "(", "'workflow_input_dir'", ",", "''", ")", "workflow_output_dir", "=", "dd", ".", "get", "(", "'workflow_output_dir'", ",", "''", ")", "result_file", "=", "dd", ".", "get", "(", "'result_file'", ",", "''", ")", "graphs", "=", "dd", ".", "get", "(", "'graphs'", ",", "[", "]", ")", "##############################################################", "ck", ".", "out", "(", "config", ".", "CR_LINE", ")", "ck", ".", "out", "(", "'Find path to output file '", "+", "result_file", "+", "' ...'", ")", "ck", ".", "out", "(", "''", ")", "encoding", "=", "locale", ".", "getdefaultlocale", "(", ")", "[", "1", "]", "cmd0", "=", "hosd", "[", "'change_dir'", "]", "+", "' '", "+", "hosd", "[", "'env_quotes_if_space'", "]", "+", "p", "+", "hosd", "[", "'env_quotes_if_space'", "]", "+", "'\\n'", "cmd0", "+=", "hosd", "[", "'env_set'", "]", "+", "' CK_REPOS='", "+", "hosd", "[", "'env_quotes_if_space'", "]", "+", "os", ".", "path", ".", "join", "(", "p", ",", "'CK'", ")", "+", "hosd", "[", "'env_quotes_if_space'", "]", "+", "'\\n'", "cmd0", "+=", "hosd", "[", "'env_call'", "]", "+", "' '", "+", "hosd", "[", "'env_quotes_if_space'", "]", "+", "os", ".", "path", ".", "join", "(", "p", ",", "'venv'", ",", "hosd_extra", "[", "'venv_bin'", "]", ",", "hosd_extra", "[", "'venv_activate'", "]", ")", "+", "hosd", "[", "'env_quotes_if_space'", "]", "+", "'\\n'", "cmd", "=", "cmd0", "cmd", "+=", "'ck find '", "+", "workflow", "+", "'\\n'", "ii", "=", "{", "'action'", ":", "'shell'", ",", "'module_uoa'", ":", "'os'", ",", "'cmd'", ":", "cmd", ",", "'encoding'", ":", "encoding", "}", "r", "=", "ck", ".", "access", "(", "ii", ")", "if", "r", "[", "'return'", "]", ">", "0", ":", "status", "=", "-", "1", "return", "r", "path_result", "=", "r", "[", "'stdout'", "]", ".", "strip", "(", ")", "path_result_file", "=", "os", ".", "path", ".", "join", "(", "path_result", ",", "result_file", ")", "ck", ".", "out", "(", "' Found path: '", "+", "path_result_file", ")", "# ##############################################################", "# ck.out(config.CR_LINE)", "# ck.out('Detecting complete platform info ...')", "# pinfo=os.path.join(p, 'platform-info.json')", "# if os.path.isfile(pinfo): os.remove(pinfo)", "# cmd=cmd0", "# # Need to do it from virtual env since it's the correct way for Android devices which may require specific files (adb)", "# s='ck detect platform'", "# if i.get('target_os','')!='': s+=' --target_os='+i['target_os']", "# if tdid!='': s+=' --device_id='+tdid", "# s+=' --out=json_file --out_file='+pinfo", "# cmd+=s+'\\n'", "# ii['cmd']=cmd", "# r=ck.access(ii)", "# if r['return']>0: return r", "# if not os.path.isfile(pinfo):", "# return {'return':1, 'error':'platform info file was not created'}", "# # Get some sub-info about deps and platforms", "# dinfo={}", "# if os.path.isfile(pinfo):", "# r=ck.load_json_file({'json_file':pinfo})", "# if r['return']==0:", "# dinfo=r['dict'].get('features',{})", "# for k in ['cpu_misc', 'cpu']:", "# if k in dinfo: del(dinfo[k])", "# pdeps=os.path.join(p, 'resolved-deps.json')", "# ddeps={}", "# if os.path.isfile(pdeps):", "# r=ck.load_json_file({'json_file':pdeps})", "# if r['return']==0:", "# ddeps2=r['dict']", "# r=deps_summary({'deps':ddeps2})", "# if r['return']==0:", "# ddeps=r['deps_summary']", "##############################################################", "# status management", "path_tmpSol", "=", "os", ".", "path", ".", "join", "(", "p", ",", "\"tmp\"", ")", "tmp_solStatus", "=", "os", ".", "path", ".", "join", "(", "path_tmpSol", ",", "\"status.json\"", ")", "status", "=", "0", "if", "not", "os", ".", "path", ".", "isdir", "(", "path_tmpSol", ")", ":", "os", ".", "mkdir", "(", "path_tmpSol", ")", "rdf_st", "=", "{", "}", "rx", "=", "ck", ".", "load_json_file", "(", "{", "'json_file'", ":", "tmp_solStatus", "}", ")", "if", "rx", "[", "'return'", "]", ">", "0", ":", "rx", "=", "ck", ".", "save_json_to_file", "(", "{", "'json_file'", ":", "tmp_solStatus", ",", "'dict'", ":", "{", "'status'", ":", "0", "}", "}", ")", "return", "rx", "rdf_st", "=", "rx", "[", "'dict'", "]", "status", "=", "rdf_st", ".", "get", "(", "'status'", ",", "''", ")", "if", "status", "==", "2", ":", "##############################################################", "ck", ".", "out", "(", "config", ".", "CR_LINE", ")", "ck", ".", "out", "(", "'Reading output: '", "+", "path_result_file", ")", "ck", ".", "out", "(", "''", ")", "if", "not", "os", ".", "path", ".", "isfile", "(", "path_result_file", ")", ":", "ck", ".", "out", "(", "' Error: output file not found!'", ")", "rdf_st", "[", "'status'", "]", "=", "-", "2", "rx", "=", "ck", ".", "save_json_to_file", "(", "{", "'json_file'", ":", "tmp_solStatus", ",", "'dict'", ":", "rdf_st", "}", ")", "if", "rx", "[", "'return'", "]", ">", "0", ":", "return", "rx", "else", ":", "rx", "=", "ck", ".", "load_json_file", "(", "{", "'json_file'", ":", "path_result_file", "}", ")", "if", "rx", "[", "'return'", "]", ">", "0", ":", "return", "rx", "crdf", "=", "rx", "[", "'dict'", "]", "################################################################", "if", "len", "(", "graphs", ")", ">", "0", ":", "ck", ".", "out", "(", "config", ".", "CR_LINE", ")", "ck", ".", "out", "(", "'Pushing results to graphs...'", ")", "rx", "=", "ck", ".", "gen_tmp_file", "(", "{", "'prefix'", ":", "'tmp-result-'", ",", "'suffix'", ":", "'.json'", "}", ")", "if", "rx", "[", "'return'", "]", ">", "0", ":", "return", "rx", "fn", "=", "rx", "[", "'file_name'", "]", "rx", "=", "ck", ".", "save_json_to_file", "(", "{", "'json_file'", ":", "fn", ",", "'dict'", ":", "crdf", "}", ")", "if", "rx", "[", "'return'", "]", ">", "0", ":", "return", "rx", "if", "solution_uoa", "not", "in", "graphs", ":", "graphs", ".", "append", "(", "solution_uoa", ")", "for", "gr", "in", "graphs", ":", "ck", ".", "out", "(", "''", ")", "ck", ".", "out", "(", "' * Graph: '", "+", "gr", ")", "ck", ".", "out", "(", "''", ")", "rx", "=", "graph", ".", "push", "(", "{", "'uid'", ":", "gr", ",", "'version'", ":", "'1.0.0'", ",", "'filename'", ":", "fn", "}", ")", "if", "rx", "[", "'return'", "]", ">", "0", ":", "return", "rx", "rdf_st", "[", "'status'", "]", "=", "3", "rx", "=", "ck", ".", "save_json_to_file", "(", "{", "'json_file'", ":", "tmp_solStatus", ",", "'dict'", ":", "rdf_st", "}", ")", "if", "rx", "[", "'return'", "]", ">", "0", ":", "return", "rx", "# Clean temp data file", "if", "os", ".", "path", ".", "isfile", "(", "fn", ")", ":", "os", ".", "remove", "(", "fn", ")", "################################################################", "pconv", "=", "os", ".", "path", ".", "join", "(", "p", ",", "'graph-convertor.json'", ")", "if", "os", ".", "path", ".", "isfile", "(", "pconv", ")", ":", "rx", "=", "ck", ".", "load_json_file", "(", "{", "'json_file'", ":", "pconv", "}", ")", "if", "rx", "[", "'return'", "]", "==", "0", ":", "ck", ".", "out", "(", "config", ".", "CR_LINE", ")", "ck", ".", "out", "(", "'Converting data for extra graphs ...'", ")", "dconv", "=", "rx", "[", "'dict'", "]", "for", "eg", "in", "dconv", ":", "gr", "=", "eg", "[", "'graph_id'", "]", "ck", ".", "out", "(", "''", ")", "ck", ".", "out", "(", "' * Graph: '", "+", "gr", ")", "keys", "=", "eg", "[", "'keys'", "]", "cdata", "=", "{", "}", "for", "k", "in", "keys", ":", "ok", "=", "k", "[", "'out_key'", "]", "kk", "=", "[", "k", ".", "get", "(", "'key1'", ",", "''", ")", ",", "k", ".", "get", "(", "'key2'", ",", "''", ")", ",", "k", ".", "get", "(", "'key3'", ",", "''", ")", ",", "k", ".", "get", "(", "'key4'", ",", "''", ")", "]", "vv", "=", "''", "v", "=", "k", ".", "get", "(", "'value'", ",", "''", ")", "if", "v", "!=", "''", "and", "v", "!=", "None", ":", "vv", "=", "v", "first", "=", "True", "for", "kx", "in", "kk", ":", "if", "kx", "!=", "''", ":", "if", "kx", ".", "startswith", "(", "'##'", ")", ":", "ry", "=", "ck", ".", "get_by_flat_key", "(", "{", "'dict'", ":", "crdf", ",", "'key'", ":", "kx", "}", ")", "if", "ry", "[", "'return'", "]", ">", "0", ":", "return", "ry", "v", "=", "ry", "[", "'value'", "]", "else", ":", "v", "=", "crdf", ".", "get", "(", "kx", ")", "vm", "=", "k", ".", "get", "(", "'multiply'", ",", "0", ")", "if", "vm", "!=", "0", "and", "vm", "!=", "''", "and", "vm", "!=", "None", "and", "(", "type", "(", "v", ")", "==", "float", "or", "type", "(", "v", ")", "==", "int", ")", ":", "v", "=", "v", "*", "vm", "if", "v", "!=", "''", "and", "v", "!=", "None", ":", "if", "first", ":", "first", "=", "False", "if", "type", "(", "v", ")", "==", "float", "or", "type", "(", "v", ")", "==", "int", ":", "vv", "=", "0", "else", ":", "vv", "+=", "', '", "vv", "+=", "v", "if", "vv", "!=", "''", ":", "cdata", "[", "ok", "]", "=", "vv", "rx", "=", "ck", ".", "gen_tmp_file", "(", "{", "'prefix'", ":", "'tmp-result-'", ",", "'suffix'", ":", "'.json'", "}", ")", "if", "rx", "[", "'return'", "]", ">", "0", ":", "return", "rx", "fn", "=", "rx", "[", "'file_name'", "]", "rx", "=", "ck", ".", "save_json_to_file", "(", "{", "'json_file'", ":", "fn", ",", "'dict'", ":", "cdata", "}", ")", "if", "rx", "[", "'return'", "]", ">", "0", ":", "return", "rx", "ck", ".", "out", "(", "''", ")", "rx", "=", "graph", ".", "push", "(", "{", "'uid'", ":", "gr", ",", "'version'", ":", "'1.0.0'", ",", "'filename'", ":", "fn", "}", ")", "if", "rx", "[", "'return'", "]", ">", "0", ":", "return", "rx", "# Clean temp data file", "if", "os", ".", "path", ".", "isfile", "(", "fn", ")", ":", "os", ".", "remove", "(", "fn", ")", "return", "r", "return", "{", "'return'", ":", "0", "}" ]

[]

[ "def", "__init__", "(", "self", ",", "config", ",", "modalities", ",", "num_outputs", ",", "output_num_channels", ",", "min_padding_size", "=", "2", ",", "subsampled_index_dims", "=", "None", ",", "*", "*", "decoder_kwargs", ")", ":", "super", "(", ")", ".", "__init__", "(", ")", "self", ".", "modalities", "=", "nn", ".", "ModuleDict", "(", "modalities", ")", "self", ".", "subsampled_index_dims", "=", "subsampled_index_dims", "self", ".", "min_padding_size", "=", "min_padding_size", "self", ".", "output_num_channels", "=", "output_num_channels", "self", ".", "num_outputs", "=", "num_outputs", "self", ".", "decoder", "=", "PerceiverBasicDecoder", "(", "config", ",", "output_index_dims", "=", "(", "num_outputs", ",", ")", ",", "output_num_channels", "=", "output_num_channels", ",", "position_encoding_type", "=", "\"none\"", ",", "num_channels", "=", "self", ".", "num_query_channels", ",", "*", "*", "decoder_kwargs", ",", ")", "self", ".", "padding", "=", "nn", ".", "ParameterDict", "(", "{", "modality", ":", "nn", ".", "Parameter", "(", "torch", ".", "randn", "(", "1", ",", "self", ".", "num_query_channels", "-", "decoder", ".", "num_query_channels", ")", ")", "for", "modality", ",", "decoder", "in", "modalities", ".", "items", "(", ")", "}", ")" ]

[ "Return", "any", "dependent", "axes", "(", "left", "and", "right", "by", "default", "for", "LineCharts", "although", "bar", "charts", "would", "use", "bottom", "and", "top", ")", "." ]

[ "def", "GetDependentAxes", "(", "self", ")", ":", "return", "self", ".", "_axes", "[", "AxisPosition", ".", "LEFT", "]", "+", "self", ".", "_axes", "[", "AxisPosition", ".", "RIGHT", "]" ]

[ "Validate", "that", "id", "is", "provided", "outside", "of", "test", "mode", "." ]

[ "def", "_validate_test_mode", "(", "obj", ":", "dict", ")", "->", "dict", ":", "if", "ATTR_ID", "not", "in", "obj", "and", "obj", "[", "ATTR_TRIGGER", "]", "!=", "\"test\"", ":", "raise", "vol", ".", "Invalid", "(", "\"Location id not specified\"", ")", "return", "obj" ]

[ "Fetch", "the", "TaskStatisticsInstance" ]

[ "def", "fetch", "(", "self", ")", ":", "payload", "=", "self", ".", "_version", ".", "fetch", "(", "method", "=", "'GET'", ",", "uri", "=", "self", ".", "_uri", ",", ")", "return", "TaskStatisticsInstance", "(", "self", ".", "_version", ",", "payload", ",", "assistant_sid", "=", "self", ".", "_solution", "[", "'assistant_sid'", "]", ",", "task_sid", "=", "self", ".", "_solution", "[", "'task_sid'", "]", ",", ")" ]

[ "The", "initial", "portion", "of", "the", "URL", "s", "path", "that", "was", "removed", "by", "a", "higher", "level", "(", "server", "or", "routing", "middleware", ")", "before", "the", "application", "was", "called", ".", "This", "script", "path", "is", "returned", "with", "leading", "and", "tailing", "slashes", "." ]

[ "def", "script_name", "(", "self", ")", ":", "script_name", "=", "self", ".", "environ", ".", "get", "(", "'SCRIPT_NAME'", ",", "''", ")", ".", "strip", "(", "'/'", ")", "return", "'/'", "+", "script_name", "+", "'/'", "if", "script_name", "else", "'/'" ]

[ "Handles", "the", "user", "pressing", "a", "key", "in", "the", "normal", "state", "." ]

[ "def", "normal_key_pressed", "(", "self", ",", "event", ")", ":", "if", "event", ".", "character", "==", "\"Enter\"", ":", "self", ".", "_finalize_selection", "(", ")", "self", ".", "reset", "(", ")" ]

[]

[ "def", "reg_format_value_dword", "(", "value", ")", ":", "return", "\"dword:%08x\"", "%", "(", "value", ".", "value", "(", ")", ")" ]

[ "**", "可选操作", ":", "**", "启用聊天对象的", ":", "any", ":", "puid", "<Chat", ".", "puid", ">", "属性", "::" ]

[ "def", "enable_puid", "(", "self", ",", "path", "=", "'wxpy_puid.pkl'", ",", "puid_logs", "=", "None", ")", ":", "self", ".", "puid_map", "=", "PuidMap", "(", "path", ",", "puid_logs", ")", "return", "self", ".", "puid_map" ]

[ "replace", "status", "of", "the", "specified", "PersistentVolume", "This", "method", "makes", "a", "synchronous", "HTTP", "request", "by", "default", ".", "To", "make", "an", "asynchronous", "HTTP", "request", "please", "define", "a", "callback", "function", "to", "be", "invoked", "when", "receiving", "the", "response", ".", ">>>", "def", "callback_function", "(", "response", ")", ":", ">>>", "pprint", "(", "response", ")", ">>>", ">>>", "thread", "=", "api", ".", "replace_persistent_volume_status", "(", "name", "body", "callback", "=", "callback_function", ")" ]

[ "def", "replace_persistent_volume_status", "(", "self", ",", "name", ",", "body", ",", "*", "*", "kwargs", ")", ":", "kwargs", "[", "'_return_http_data_only'", "]", "=", "True", "if", "kwargs", ".", "get", "(", "'callback'", ")", ":", "return", "self", ".", "replace_persistent_volume_status_with_http_info", "(", "name", ",", "body", ",", "*", "*", "kwargs", ")", "else", ":", "(", "data", ")", "=", "self", ".", "replace_persistent_volume_status_with_http_info", "(", "name", ",", "body", ",", "*", "*", "kwargs", ")", "return", "data" ]

[ "Checks", "if", "rank", "is", "valid", "then", "returns", "it", "." ]

[ "def", "_CheckRank", "(", "self", ",", "rank", ")", ":", "return", "_CheckInteger", "(", "rank", ",", "'rank'", ",", "upper_bound", "=", "sys", ".", "maxint", ")" ]

[ "Takes", "a", "string", "and", "a", "dictionary", "and", "interpolates", "the", "string", "using", "values", "from", "the", "dictionary", ".", "Returns", "an", "SQLQuery", "for", "the", "result", "." ]

[ "def", "reparam", "(", "string_", ",", "dictionary", ")", ":", "dictionary", "=", "dictionary", ".", "copy", "(", ")", "# eval mucks with it", "vals", "=", "[", "]", "result", "=", "[", "]", "for", "live", ",", "chunk", "in", "_interpolate", "(", "string_", ")", ":", "if", "live", ":", "v", "=", "eval", "(", "chunk", ",", "dictionary", ")", "result", ".", "append", "(", "sqlquote", "(", "v", ")", ")", "else", ":", "result", ".", "append", "(", "chunk", ")", "return", "SQLQuery", ".", "join", "(", "result", ",", "''", ")" ]

[ "Adapted", "from", "https", ":", "//", "gist", ".", "github", ".", "com", "/", "bwhite", "/", "3726239" ]

[ "def", "mean_reciprocal_rank_at_k", "(", "rs", ",", "k", ")", ":", "rs", "=", "rs", "[", ":", ",", ":", "k", "]", "rs", "=", "(", "np", ".", "asarray", "(", "r", ")", ".", "nonzero", "(", ")", "[", "0", "]", "for", "r", "in", "rs", ")", "return", "np", ".", "mean", "(", "[", "1.0", "/", "(", "r", "[", "0", "]", "+", "1", ")", "if", "r", ".", "size", "else", "0.0", "for", "r", "in", "rs", "]", ")" ]

[ "Replace", "the", "text", "between", "the", "given", "indices", "." ]

[ "def", "set_region", "(", "self", ",", "head", ",", "tail", ",", "chars", ",", "lines", ")", ":", "text", "=", "self", ".", "editwin", ".", "text", "newchars", "=", "\"\\n\"", ".", "join", "(", "lines", ")", "if", "newchars", "==", "chars", ":", "text", ".", "bell", "(", ")", "return", "text", ".", "tag_remove", "(", "\"sel\"", ",", "\"1.0\"", ",", "\"end\"", ")", "text", ".", "mark_set", "(", "\"insert\"", ",", "head", ")", "text", ".", "undo_block_start", "(", ")", "text", ".", "delete", "(", "head", ",", "tail", ")", "text", ".", "insert", "(", "head", ",", "newchars", ")", "text", ".", "undo_block_stop", "(", ")", "text", ".", "tag_add", "(", "\"sel\"", ",", "head", ",", "\"insert\"", ")" ]

[ "Test", "if", "proxies", "should", "not", "be", "used", "for", "a", "particular", "host", "." ]

[ "def", "proxy_bypass_environment", "(", "host", ",", "proxies", "=", "None", ")", ":", "if", "proxies", "is", "None", ":", "proxies", "=", "getproxies_environment", "(", ")", "# don't bypass, if no_proxy isn't specified", "try", ":", "no_proxy", "=", "proxies", "[", "'no'", "]", "except", "KeyError", ":", "return", "0", "# '*' is special case for always bypass", "if", "no_proxy", "==", "'*'", ":", "return", "1", "# strip port off host", "hostonly", ",", "port", "=", "splitport", "(", "host", ")", "# check if the host ends with any of the DNS suffixes", "no_proxy_list", "=", "[", "proxy", ".", "strip", "(", ")", "for", "proxy", "in", "no_proxy", ".", "split", "(", "','", ")", "]", "for", "name", "in", "no_proxy_list", ":", "if", "name", ":", "name", "=", "re", ".", "escape", "(", "name", ")", "pattern", "=", "r'(.+\\.)?%s$'", "%", "name", "if", "(", "re", ".", "match", "(", "pattern", ",", "hostonly", ",", "re", ".", "I", ")", "or", "re", ".", "match", "(", "pattern", ",", "host", ",", "re", ".", "I", ")", ")", ":", "return", "1", "# otherwise, don't bypass", "return", "0" ]

[ "Runs", "basic", "whitespace", "cleaning", "and", "splitting", "on", "a", "piece", "of", "text", "." ]

[ "def", "whitespace_tokenize", "(", "text", ")", ":", "text", "=", "text", ".", "strip", "(", ")", "if", "not", "text", ":", "return", "[", "]", "tokens", "=", "text", ".", "split", "(", ")", "return", "tokens" ]

[ "Flag", "supported", "features", ".", "Speed", "Only", "." ]

[ "def", "supported_features", "(", "self", ")", "->", "int", ":", "return", "SUPPORT_SET_SPEED" ]

[ "convert", "each", "element", "in", "a", "vector", "as", "float", "to", "int", "or", "int", "to", "float", "32", "-", "bit", "round", "-", "to", "-", "zero", "/", "round", "-", "to", "-", "nearest" ]

[ "def", "i_vcvt_TODO", "(", "self", ",", "op", ")", ":", "logger", ".", "warning", "(", "'%r\\t%r'", ",", "op", ",", "op", ".", "opers", ")", "logger", ".", "warning", "(", "\"complete implementing vcvt\"", ")", "if", "op", ".", "iflags", "&", "IF_ADV_SIMD", ":", "# this is an Advanced SIMD instruction", "srcwidth", "=", "op", ".", "opers", "[", "0", "]", ".", "getWidth", "(", ")", "dstwidth", "=", "op", ".", "opers", "[", "1", "]", ".", "getWidth", "(", ")", "regcnt", "=", "srcwidth", "/", "4", "if", "len", "(", "op", ".", "opers", ")", "==", "3", ":", "# 3rd operand is fbits for Fixed Point numbers", "pass", "else", ":", "# it's either Floating Point or Integer", "pass", "else", ":", "# we let the register size sort out the details for non-ADV_SIMD stuff", "if", "op", ".", "simdflags", "in", "ifs_second_F32_F64_F16", ":", "val", "=", "op", ".", "opers", "[", "1", "]", ".", "getFloatValue", "(", "self", ")", "else", ":", "val", "=", "op", ".", "opers", "[", "1", "]", ".", "getOperValue", "(", "op", ",", "self", ")", "if", "len", "(", "op", ".", "opers", ")", "==", "3", ":", "# 3rd operand is fbits for Fixed Point numbers", "pass", "else", ":", "# it's either Floating Point or Integer", "if", "op", ".", "simdflags", "in", "ifs_first_F32_F64", ":", "op", ".", "opers", "[", "0", "]", ".", "setFloatValue", "(", "self", ",", "val", ")", "else", ":", "op", ".", "opers", "[", "0", "]", ".", "setOperValue", "(", "op", ",", "self", ",", "val", ")", "firstOP", "=", "None", "if", "op", ".", "simdflags", "in", "ifs_first_F32", ":", "# get first vector element as F32", "firstOP", "=", "OP_F32", "elif", "op", ".", "simdflags", "in", "ifs_first_S32", ":", "firstOP", "=", "OP_S32", "elif", "op", ".", "simdflags", "in", "ifs_first_U32", ":", "firstOP", "=", "OP_U32", "elif", "op", ".", "simdflags", "in", "ifs_first_F64", ":", "firstOP", "=", "OP_F64", "elif", "op", ".", "simdflags", "in", "ifs_first_F16", ":", "firstOP", "=", "OP_F16", "secOP", "=", "None", "if", "op", ".", "simdflags", "in", "ifs_second_F32", ":", "# get second vector element as F32", "secOP", "=", "OP_F32", "elif", "op", ".", "simdflags", "in", "ifs_second_S32", ":", "secOP", "=", "OP_S32", "elif", "op", ".", "simdflags", "in", "ifs_second_U32", ":", "secOP", "=", "OP_U32", "elif", "op", ".", "simdflags", "in", "ifs_second_F64", ":", "secOP", "=", "OP_F64", "elif", "op", ".", "simdflags", "in", "ifs_second_F16", ":", "secOP", "=", "OP_F16", "raise", "Exception", "(", "\"IMPLEMENT ME: i_vcvt\"", ")", "if", "len", "(", "op", ".", "opers", ")", "==", "3", ":", "for", "reg", "in", "range", "(", "regcnt", ")", ":", "#frac_bits = 64 - op.opers[2].val", "# pA8_870", "if", "op", ".", "simdflags", "==", "IFS_F32_S32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F32_U32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_S32_F32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_U32_F32", ":", "pass", "# pA8_872", "elif", "op", ".", "simdflags", "==", "IFS_U16_F32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_S16_F32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_U32_F32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_S32_F32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_U16_F64", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_S16_F64", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_U32_F64", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_S32_F64", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F32_U16", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F32_S16", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F32_U32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F32_S32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F64_U16", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F64_S16", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F64_U32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F64_S32", ":", "pass", "elif", "len", "(", "op", ".", "opers", ")", "==", "2", ":", "for", "reg", "in", "range", "(", "regcnt", ")", ":", "#frac_bits = 64 - op.opers[1].val", "# pA8_866 (868?)", "if", "op", ".", "simdflags", "==", "IFS_F32_S32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F32_U32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_S32_F32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_U32_F32", ":", "pass", "# pA8-868 (870?)", "elif", "op", ".", "simdflags", "==", "IFS_F64_S32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F64_U32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_S32_F64", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_U32_F64", ":", "pass", "# pA8-874", "elif", "op", ".", "simdflags", "==", "IFS_F64_F32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F32_F64", ":", "pass", "# pA8-876", "elif", "op", ".", "simdflags", "==", "IFS_F16_F32", ":", "pass", "elif", "op", ".", "simdflags", "==", "IFS_F32_F16", ":", "pass", "else", ":", "raise", "Exception", "(", "\"i_vcvt with strange number of opers: %r\"", "%", "op", ".", "opers", ")" ]

[ "Register", "a", "validator", "to", "check", "directory", "flags", ".", "Args", ":", "flag_names", ":", "An", "iterable", "of", "strings", "containing", "the", "names", "of", "flags", "to", "be", "checked", "." ]

[ "def", "require_cloud_storage", "(", "flag_names", ")", ":", "msg", "=", "\"TPU requires GCS path for {}\"", ".", "format", "(", "\", \"", ".", "join", "(", "flag_names", ")", ")", "@", "flags", ".", "multi_flags_validator", "(", "[", "\"tpu\"", "]", "+", "flag_names", ",", "message", "=", "msg", ")", "def", "_path_check", "(", "flag_values", ")", ":", "# pylint: disable=missing-docstring", "if", "flag_values", "[", "\"tpu\"", "]", "is", "None", ":", "return", "True", "valid_flags", "=", "True", "for", "key", "in", "flag_names", ":", "if", "not", "flag_values", "[", "key", "]", ".", "startswith", "(", "\"gs://\"", ")", ":", "tf", ".", "logging", ".", "error", "(", "\"{} must be a GCS path.\"", ".", "format", "(", "key", ")", ")", "valid_flags", "=", "False", "return", "valid_flags" ]

[ "Will", "get", "a", "pointer", "to", "pointer", "to", "the", "given", "API", "name", "in", "the", "IAT", "of", "the", "selected", "modules", "Arguments", ":", "apiname", ":", "the", "name", "of", "the", "function", "modulecriteria", "&", "criteria", ":", "module", "/", "pointer", "criteria", "Returns", ":", "a", "pointer", "(", "integer", "value", "0", "if", "no", "pointer", "was", "found", ")", "text", "(", "with", "optional", "info", ")" ]

[ "def", "getRopFuncPtr", "(", "apiname", ",", "modulecriteria", ",", "criteria", ",", "mode", ",", "objprogressfile", ",", "progressfile", ")", ":", "global", "silent", "oldsilent", "=", "silent", "silent", "=", "True", "global", "ptr_to_get", "ptr_to_get", "=", "-", "1", "rfuncsearch", "=", "apiname", ".", "lower", "(", ")", "selectedmodules", "=", "False", "if", "\"modules\"", "in", "modulecriteria", ":", "if", "len", "(", "modulecriteria", "[", "\"modules\"", "]", ")", ">", "0", ":", "selectedmodules", "=", "True", "arrfuncsearch", "=", "[", "rfuncsearch", "]", "if", "rfuncsearch", "==", "\"virtualloc\"", ":", "arrfuncsearch", ".", "append", "(", "\"virtuallocstub\"", ")", "ropfuncptr", "=", "0", "ropfuncoffsets", "=", "{", "}", "ropfunctext", "=", "\"ptr to &\"", "+", "apiname", "+", "\"()\"", "objprogressfile", ".", "write", "(", "\" * Ropfunc - Looking for %s (IAT) - modulecriteria: %s\"", "%", "(", "ropfunctext", ",", "modulecriteria", ")", ",", "progressfile", ")", "if", "mode", "==", "\"iat\"", ":", "if", "rfuncsearch", "!=", "\"\"", ":", "ropfuncs", ",", "ropfuncoffsets", "=", "findROPFUNC", "(", "modulecriteria", ",", "criteria", ",", "[", "rfuncsearch", "]", ")", "else", ":", "ropfuncs", ",", "ropfuncoffsets", "=", "findROPFUNC", "(", "modulecriteria", ")", "silent", "=", "oldsilent", "#first look for good one", "objprogressfile", ".", "write", "(", "\" * Ropfunc - Found %d pointers\"", "%", "len", "(", "ropfuncs", ")", ",", "progressfile", ")", "for", "ropfunctypes", "in", "ropfuncs", ":", "#dbg.log(\"Ropfunc - %s %s\" % (ropfunctypes, rfuncsearch))", "if", "ropfunctypes", ".", "lower", "(", ")", ".", "find", "(", "rfuncsearch", ")", ">", "-", "1", "and", "ropfunctypes", ".", "lower", "(", ")", ".", "find", "(", "\"rebased\"", ")", "==", "-", "1", ":", "ropfuncptr", "=", "ropfuncs", "[", "ropfunctypes", "]", "[", "0", "]", "break", "if", "ropfuncptr", "==", "0", ":", "for", "ropfunctypes", "in", "ropfuncs", ":", "if", "ropfunctypes", ".", "lower", "(", ")", ".", "find", "(", "rfuncsearch", ")", ">", "-", "1", ":", "ropfuncptr", "=", "ropfuncs", "[", "ropfunctypes", "]", "[", "0", "]", "break", "#dbg.log(\"Ropfunc - Selected pointer: 0x%08x\" % ropfuncptr)", "#haven't found pointer, and you were looking at specific modules only? remove module restriction, but still exclude ASLR/rebase", "if", "(", "ropfuncptr", "==", "0", ")", "and", "selectedmodules", ":", "objprogressfile", ".", "write", "(", "\" * Ropfunc - No results yet, expanding search to all non ASLR/rebase modules\"", ",", "progressfile", ")", "oldsilent", "=", "silent", "silent", "=", "True", "limitedmodulecriteria", "=", "{", "}", "limitedmodulecriteria", "[", "\"aslr\"", "]", "=", "False", "limitedmodulecriteria", "[", "\"rebase\"", "]", "=", "False", "limitedmodulecriteria", "[", "\"os\"", "]", "=", "False", "ropfuncs", ",", "ropfuncoffsets", "=", "findROPFUNC", "(", "limitedmodulecriteria", ",", "criteria", ")", "silent", "=", "oldsilent", "for", "ropfunctypes", "in", "ropfuncs", ":", "#dbg.log(\"Ropfunc - %s %s\" % (ropfunctypes, rfuncsearch))", "if", "ropfunctypes", ".", "lower", "(", ")", ".", "find", "(", "rfuncsearch", ")", ">", "-", "1", "and", "ropfunctypes", ".", "lower", "(", ")", ".", "find", "(", "\"rebased\"", ")", "==", "-", "1", ":", "ropfuncptr", "=", "ropfuncs", "[", "ropfunctypes", "]", "[", "0", "]", "break", "#still haven't found ? clear out modulecriteria, include ASLR/rebase modules (but not OS modules)", "if", "(", "ropfuncptr", "==", "0", ")", "and", "not", "selectedmodules", ":", "objprogressfile", ".", "write", "(", "\" * Ropfunc - Still no results, now going to search in all application modules\"", ",", "progressfile", ")", "oldsilent", "=", "silent", "silent", "=", "True", "limitedmodulecriteria", "=", "{", "}", "# search in anything except known OS modules - bad idea anyway", "limitedmodulecriteria", "[", "\"os\"", "]", "=", "False", "ropfuncs2", ",", "ropfuncoffsets2", "=", "findROPFUNC", "(", "limitedmodulecriteria", ",", "criteria", ")", "silent", "=", "oldsilent", "for", "ropfunctypes", "in", "ropfuncs2", ":", "if", "ropfunctypes", ".", "lower", "(", ")", ".", "find", "(", "rfuncsearch", ")", ">", "-", "1", "and", "ropfunctypes", ".", "lower", "(", ")", ".", "find", "(", "\"rebased\"", ")", "==", "-", "1", ":", "ropfuncptr", "=", "ropfuncs2", "[", "ropfunctypes", "]", "[", "0", "]", "ropfunctext", "+=", "\" (skipped module criteria, check if pointer is reliable !)\"", "break", "if", "ropfuncptr", "==", "0", ":", "ropfunctext", "=", "\"[-] Unable to find ptr to &\"", "+", "apiname", "+", "\"()\"", "else", ":", "ropfptrmodname", "=", "MnPointer", "(", "ropfuncptr", ")", ".", "belongsTo", "(", ")", "tmod", "=", "MnModule", "(", "ropfptrmodname", ")", "ropfptrmodinfo", "=", "getGadgetAddressInfo", "(", "ropfuncptr", ")", "ropfunctext", "+=", "\" [IAT \"", "+", "ropfptrmodname", "+", "\"]\"", "+", "ropfptrmodinfo", "else", ":", "# read EAT", "modulestosearch", "=", "getModulesToQuery", "(", "modulecriteria", ")", "for", "mod", "in", "modulestosearch", ":", "tmod", "=", "MnModule", "(", "mod", ")", "funcs", "=", "tmod", ".", "getEAT", "(", ")", "for", "func", "in", "funcs", ":", "funcname", "=", "funcs", "[", "func", "]", ".", "lower", "(", ")", "if", "funcname", ".", "find", "(", "rfuncsearch", ")", ">", "-", "1", ":", "ropfuncptr", "=", "func", "break", "if", "ropfuncptr", "==", "0", ":", "ropfunctext", "=", "\"[-] Unable to find required API pointer\"", "return", "ropfuncptr", ",", "ropfunctext" ]

[]

[ "def", "Format", "(", "self", ",", "thread_info", ")", ":", "t", "=", "Template", "(", "file", "=", "\"templates/address-formatter.tmpl\"", ",", "searchList", "=", "{", "\"address\"", ":", "thread_info", "[", "\"address\"", "]", ",", "\"name\"", ":", "thread_info", "[", "\"name\"", "]", ",", "}", ")", "return", "unicode", "(", "t", ")" ]

[ "Strip", "Shadda", "from", "a", "text", "and", "return", "a", "result", "text", "." ]

[ "def", "strip_shadda", "(", "text", ")", ":", "return", "text", ".", "replace", "(", "SHADDA", ",", "\"\"", ")" ]

[ "gets", "/", "sets", "the", "globalIdFieldName" ]

[ "def", "globalIdFieldName", "(", "self", ",", "value", ")", ":", "self", ".", "_globalIdFieldName", "=", "value" ]

[ "Implements", "assignment", "of", "self", ".", "all" ]

[ "def", "all", "(", "self", ",", "config_dict", ")", ":", "self", ".", "_config", "=", "config_dict", "# Reminder: setting self.all resets defaults, so it's important", "# that it's followed up by setting self.defaults", "# TODO: Think of a better way to handle this", "self", ".", "_storages", "=", "{", "name", ":", "{", "\"default\"", ":", "{", "}", ",", "\"dirty\"", ":", "False", ",", "\"loaded\"", ":", "False", "}", "for", "name", "in", "config_dict", "}" ]

[]

[ "def", "__init__", "(", "self", ",", "help", "=", "'show program\\'s version number and exit'", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "super", "(", "PrintVersion", ",", "self", ")", ".", "__init__", "(", "nargs", "=", "0", ",", "default", "=", "argparse", ".", "SUPPRESS", ",", "help", "=", "help", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Get", "a", "Resolver", "instance", "." ]

[ "def", "getResolver", "(", ")", ":", "global", "theResolver", "if", "theResolver", "is", "None", ":", "try", ":", "theResolver", "=", "createResolver", "(", ")", "except", "ValueError", ":", "theResolver", "=", "createResolver", "(", "servers", "=", "[", "(", "'127.0.0.1'", ",", "53", ")", "]", ")", "return", "theResolver" ]

[ "Whether", "this", "track", "is", "a", "Layer", "Track" ]

[ "def", "isLayerTrack", "(", "self", ")", ":", "return", "self", ".", "track", ".", "trackType", "==", "mxs", ".", "pyhelper", ".", "namify", "(", "'layertrack'", ")" ]

[]

[ "def", "parsePattern", "(", "self", ",", "params", ",", "kind", "=", "None", ")", ":", "if", "self", ".", "match", "(", "'['", ")", ":", "pattern", "=", "self", ".", "parseArrayPattern", "(", "params", ",", "kind", ")", "elif", "self", ".", "match", "(", "'{'", ")", ":", "pattern", "=", "self", ".", "parseObjectPattern", "(", "params", ",", "kind", ")", "else", ":", "if", "self", ".", "matchKeyword", "(", "'let'", ")", "and", "(", "kind", "in", "(", "'const'", ",", "'let'", ")", ")", ":", "self", ".", "tolerateUnexpectedToken", "(", "self", ".", "lookahead", ",", "Messages", ".", "LetInLexicalBinding", ")", "params", ".", "append", "(", "self", ".", "lookahead", ")", "pattern", "=", "self", ".", "parseVariableIdentifier", "(", "kind", ")", "return", "pattern" ]

[]

[ "def", "build_url", "(", "self", ")", ":", "if", "len", "(", "self", ".", "param_map", ")", "==", "0", ":", "return", "\"\"", "encoded_param", "=", "urllib", ".", "parse", ".", "urlencode", "(", "self", ".", "param_map", ")", "return", "\"?\"", "+", "encoded_param" ]

[ "Build", "an", "instance", "of", "an", "object", "representing", "an", "audio", "file", "." ]

[ "def", "define_audio_file", "(", "self", ",", "sentence_hash", ":", "str", ")", "->", "AudioFile", ":", "audio_file", "=", "AudioFile", "(", "self", ".", "temporary_cache_dir", ",", "sentence_hash", ",", "self", ".", "audio_file_type", ")", "return", "audio_file" ]

[ "In", "cpu", "environment", "nn", ".", "SyncBatchNorm", "does", "not", "have", "kernel", "so", "use", "nn", ".", "BatchNorm2D", "instead" ]

[ "def", "SyncBatchNorm", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "paddle", ".", "get_device", "(", ")", "==", "'cpu'", "or", "os", ".", "environ", ".", "get", "(", "'PADDLESEG_EXPORT_STAGE'", ")", ":", "return", "nn", ".", "BatchNorm2D", "(", "*", "args", ",", "*", "*", "kwargs", ")", "else", ":", "return", "nn", ".", "SyncBatchNorm", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Add", "dist", "to", "the", "distribution", "map" ]

[ "def", "add", "(", "self", ",", "dist", ")", ":", "new_path", "=", "(", "dist", ".", "location", "not", "in", "self", ".", "paths", "and", "(", "dist", ".", "location", "not", "in", "self", ".", "sitedirs", "or", "# account for '.' being in PYTHONPATH", "dist", ".", "location", "==", "os", ".", "getcwd", "(", ")", ")", ")", "if", "new_path", ":", "self", ".", "paths", ".", "append", "(", "dist", ".", "location", ")", "self", ".", "dirty", "=", "True", "Environment", ".", "add", "(", "self", ",", "dist", ")" ]

[]

[ "def", "convert_tf_checkpoint_to_pytorch", "(", "tf_checkpoint_path", ",", "bert_config_file", ",", "pytorch_dump_path", ")", ":", "# Initialise PyTorch model", "config", "=", "BertConfig", ".", "from_json_file", "(", "bert_config_file", ")", "print", "(", "\"Building PyTorch model from configuration: {}\"", ".", "format", "(", "str", "(", "config", ")", ")", ")", "model", "=", "AlbertForPreTraining", "(", "config", ")", "# Load weights from tf checkpoint", "load_tf_weights_in_albert", "(", "model", ",", "config", ",", "tf_checkpoint_path", ")", "# Save pytorch-model", "print", "(", "\"Save PyTorch model to {}\"", ".", "format", "(", "pytorch_dump_path", ")", ")", "torch", ".", "save", "(", "model", ".", "state_dict", "(", ")", ",", "pytorch_dump_path", ")" ]

[ "Get", "the", "uri", "to", "this", "feed", "but", "with", "entries", "of", "the", "TagEntry", "kind", "." ]

[ "def", "GetTagsUri", "(", "self", ")", ":", "return", "self", ".", "_feedUri", "(", "'tag'", ")" ]

[ "Initializes", "the", "VersionFileStorageWrapper", "." ]

[ "def", "__init__", "(", "self", ",", "storage", ")", ":", "self", ".", "wrapped_storage", "=", "storage" ]

[ "Make", "sure", "my", "attr", "attr", "is", "the", "same", "as", "my", "parent", "s", "if", "I", "have", "one", "." ]

[ "def", "_ensure_inherited_attr", "(", "self", ",", "attr", ")", ":", "if", "self", ".", "parent", ":", "# We always set the child according to the parent rather than vice", "# versa, because we do not expose an Archived checkbox in the", "# translation UI.", "setattr", "(", "self", ",", "attr", ",", "getattr", "(", "self", ".", "parent", ",", "attr", ")", ")", "else", ":", "# An article cannot have both a parent and children.", "# Make my children the same as me:", "if", "self", ".", "id", ":", "self", ".", "translations", ".", "all", "(", ")", ".", "update", "(", "*", "*", "{", "attr", ":", "getattr", "(", "self", ",", "attr", ")", "}", ")" ]

[]

[ "def", "_create_area_light", "(", "scene", ",", "luxcore_scene", ",", "props", ",", "name", ",", "color", ",", "position", ",", "rotation_matrix", ",", "scale", ",", "visible", "=", "True", ")", ":", "mat_name", "=", "name", "+", "\"_mat\"", "mesh_name", "=", "name", "+", "\"_mesh\"", "# Material", "props", ".", "Set", "(", "pyluxcore", ".", "Property", "(", "\"scene.materials.\"", "+", "mat_name", "+", "\".type\"", ",", "[", "\"matte\"", "]", ")", ")", "props", ".", "Set", "(", "pyluxcore", ".", "Property", "(", "\"scene.materials.\"", "+", "mat_name", "+", "\".kd\"", ",", "[", "0.0", "]", "*", "3", ")", ")", "props", ".", "Set", "(", "pyluxcore", ".", "Property", "(", "\"scene.materials.\"", "+", "mat_name", "+", "\".emission\"", ",", "color", ")", ")", "# assign material to object", "props", ".", "Set", "(", "pyluxcore", ".", "Property", "(", "\"scene.objects.\"", "+", "name", "+", "\".material\"", ",", "[", "mat_name", "]", ")", ")", "props", ".", "Set", "(", "pyluxcore", ".", "Property", "(", "\"scene.objects.\"", "+", "name", "+", "\".camerainvisible\"", ",", "not", "visible", ")", ")", "scale_matrix", "=", "Matrix", "(", ")", "scale_matrix", "[", "0", "]", "[", "0", "]", "=", "scale", "scale_matrix", "[", "1", "]", "[", "1", "]", "=", "scale", "rotation_matrix", ".", "resize_4x4", "(", ")", "transform_matrix", "=", "Matrix", "(", ")", "transform_matrix", "[", "0", "]", "[", "3", "]", "=", "position", "[", "0", "]", "transform_matrix", "[", "1", "]", "[", "3", "]", "=", "position", "[", "1", "]", "transform_matrix", "[", "2", "]", "[", "3", "]", "=", "position", "[", "2", "]", "mat", "=", "transform_matrix", "@", "rotation_matrix", "@", "scale_matrix", "transform", "=", "utils", ".", "matrix_to_list", "(", "mat", ")", "# add mesh", "vertices", "=", "[", "(", "1", ",", "1", ",", "0", ")", ",", "(", "1", ",", "-", "1", ",", "0", ")", ",", "(", "-", "1", ",", "-", "1", ",", "0", ")", ",", "(", "-", "1", ",", "1", ",", "0", ")", "]", "faces", "=", "[", "(", "0", ",", "1", ",", "2", ")", ",", "(", "2", ",", "3", ",", "0", ")", "]", "luxcore_scene", ".", "DefineMesh", "(", "mesh_name", ",", "vertices", ",", "faces", ",", "None", ",", "None", ",", "None", ",", "None", ",", "transform", ")", "# assign mesh to object", "props", ".", "Set", "(", "pyluxcore", ".", "Property", "(", "\"scene.objects.\"", "+", "name", "+", "\".shape\"", ",", "[", "mesh_name", "]", ")", ")", "return", "props" ]

[ "Register", "the", "function", "*", "inputhook", "*", "as", "an", "event", "loop", "integration", "." ]

[ "def", "register", "(", "name", ",", "inputhook", ")", ":", "registered", "[", "name", "]", "=", "inputhook" ]

[ "Get", "an", "ordered", "list", "of", "layers", "according", "to", "users", "input", "." ]

[ "def", "ordered_expected_layers", "(", "self", ")", ":", "registry", "=", "QgsProject", ".", "instance", "(", ")", "layers", "=", "[", "]", "count", "=", "self", ".", "list_layers_in_map_report", ".", "count", "(", ")", "for", "i", "in", "range", "(", "count", ")", ":", "layer", "=", "self", ".", "list_layers_in_map_report", ".", "item", "(", "i", ")", "origin", "=", "layer", ".", "data", "(", "LAYER_ORIGIN_ROLE", ")", "if", "origin", "==", "FROM_ANALYSIS", "[", "'key'", "]", ":", "key", "=", "layer", ".", "data", "(", "LAYER_PURPOSE_KEY_OR_ID_ROLE", ")", "parent", "=", "layer", ".", "data", "(", "LAYER_PARENT_ANALYSIS_ROLE", ")", "layers", ".", "append", "(", "(", "FROM_ANALYSIS", "[", "'key'", "]", ",", "key", ",", "parent", ",", "None", ")", ")", "else", ":", "layer_id", "=", "layer", ".", "data", "(", "LAYER_PURPOSE_KEY_OR_ID_ROLE", ")", "layer", "=", "registry", ".", "mapLayer", "(", "layer_id", ")", "style_document", "=", "QDomDocument", "(", ")", "layer", ".", "exportNamedStyle", "(", "style_document", ")", "layers", ".", "append", "(", "(", "FROM_CANVAS", "[", "'key'", "]", ",", "layer", ".", "name", "(", ")", ",", "full_layer_uri", "(", "layer", ")", ",", "style_document", ".", "toString", "(", ")", ")", ")", "return", "layers" ]

[ "List", "of", "specs", "that", "should", "be", "loaded", "in", "the", "module", "file", "." ]

[ "def", "specs_to_load", "(", "self", ")", ":", "return", "self", ".", "_create_list_for", "(", "'autoload'", ")" ]

[ "Expressions", "are", "immutable", "and", "hashable", ".", "The", "hash", "of", "Functions", "is", "computed", "by", "respecting", "the", "structure", "of", "the", "whole", "expression", "by", "mixing", "the", "class", "name", "hash", "and", "the", "recursive", "hash", "of", "a", "frozenset", "of", "arguments", ".", "Hash", "of", "elements", "is", "based", "on", "their", "boolean", "equivalent", ".", "Hash", "of", "symbols", "is", "based", "on", "their", "object", "." ]

[ "def", "__hash__", "(", "self", ")", ":", "if", "not", "self", ".", "args", ":", "arghash", "=", "id", "(", "self", ")", "else", ":", "arghash", "=", "hash", "(", "frozenset", "(", "map", "(", "hash", ",", "self", ".", "args", ")", ")", ")", "return", "hash", "(", "self", ".", "__class__", ".", "__name__", ")", "^", "arghash" ]

[ "Called", "after", "each", "train", "update", "." ]

[ "def", "on_update_end", "(", "self", ",", "*", "*", "kwargs", ")", "->", "None", ":", "pass" ]

[ ":", "type", "head", ":", "ListNode", ":", "type", "k", ":", "int", ":", "rtype", ":", "ListNode" ]

[ "def", "reverseKGroup", "(", "self", ",", "head", ",", "k", ")", ":", "dummy", "=", "jump", "=", "ListNode", "(", "0", ")", "dummy", ".", "next", "=", "l", "=", "r", "=", "head", "while", "True", ":", "count", "=", "0", "while", "r", "and", "count", "<", "k", ":", "r", "=", "r", ".", "next", "count", "+=", "1", "if", "count", "==", "k", ":", "pre", ",", "cur", "=", "r", ",", "l", "for", "_", "in", "range", "(", "k", ")", ":", "cur", ".", "next", ",", "cur", ",", "pre", "=", "pre", ",", "cur", ".", "next", ",", "cur", "jump", ".", "next", ",", "jump", ",", "l", "=", "pre", ",", "l", ",", "r", "else", ":", "return", "dummy", ".", "next" ]

[ "Args", ":", "index", "(", "int", ")", ":", "Index" ]

[ "def", "__getitem__", "(", "self", ",", "index", ")", ":", "img_id", "=", "self", ".", "ids", "[", "index", "]", "path", "=", "self", ".", "coco", ".", "loadImgs", "(", "img_id", ")", "[", "0", "]", "[", "'file_name'", "]", "image_unpadded", "=", "Image", ".", "open", "(", "os", ".", "path", ".", "join", "(", "self", ".", "root", ",", "path", ")", ")", ".", "convert", "(", "'RGB'", ")", "ann_ids", "=", "self", ".", "coco", ".", "getAnnIds", "(", "imgIds", "=", "img_id", ")", "anns", "=", "self", ".", "coco", ".", "loadAnns", "(", "ann_ids", ")", "gt_classes", "=", "np", ".", "array", "(", "[", "self", ".", "id_to_ind", "[", "x", "[", "'category_id'", "]", "]", "for", "x", "in", "anns", "]", ",", "dtype", "=", "np", ".", "int64", ")", "if", "np", ".", "any", "(", "gt_classes", ">=", "len", "(", "self", ".", "ind_to_classes", ")", ")", ":", "raise", "ValueError", "(", "\"OH NO {}\"", ".", "format", "(", "index", ")", ")", "if", "len", "(", "anns", ")", "==", "0", ":", "raise", "ValueError", "(", "\"Annotations should not be empty\"", ")", "# gt_boxes = np.array((0, 4), dtype=np.float32)", "# else:", "gt_boxes", "=", "np", ".", "array", "(", "[", "x", "[", "'bbox'", "]", "for", "x", "in", "anns", "]", ",", "dtype", "=", "np", ".", "float32", ")", "if", "np", ".", "any", "(", "gt_boxes", "[", ":", ",", "[", "0", ",", "1", "]", "]", "<", "0", ")", ":", "raise", "ValueError", "(", "\"GT boxes empty columns\"", ")", "if", "np", ".", "any", "(", "gt_boxes", "[", ":", ",", "[", "2", ",", "3", "]", "]", "<", "0", ")", ":", "raise", "ValueError", "(", "\"GT boxes empty h/w\"", ")", "gt_boxes", "[", ":", ",", "[", "2", ",", "3", "]", "]", "+=", "gt_boxes", "[", ":", ",", "[", "0", ",", "1", "]", "]", "# Rescale so that the boxes are at BOX_SCALE", "if", "self", ".", "is_train", ":", "image_unpadded", ",", "gt_boxes", "=", "random_crop", "(", "image_unpadded", ",", "gt_boxes", "*", "BOX_SCALE", "/", "max", "(", "image_unpadded", ".", "size", ")", ",", "BOX_SCALE", ",", "round_boxes", "=", "False", ",", ")", "else", ":", "# Seems a bit silly because we won't be using GT boxes then but whatever", "gt_boxes", "=", "gt_boxes", "*", "BOX_SCALE", "/", "max", "(", "image_unpadded", ".", "size", ")", "w", ",", "h", "=", "image_unpadded", ".", "size", "box_scale_factor", "=", "BOX_SCALE", "/", "max", "(", "w", ",", "h", ")", "# Optionally flip the image if we're doing training", "flipped", "=", "self", ".", "is_train", "and", "np", ".", "random", ".", "random", "(", ")", ">", "0.5", "if", "flipped", ":", "scaled_w", "=", "int", "(", "box_scale_factor", "*", "float", "(", "w", ")", ")", "image_unpadded", "=", "image_unpadded", ".", "transpose", "(", "Image", ".", "FLIP_LEFT_RIGHT", ")", "gt_boxes", "[", ":", ",", "[", "0", ",", "2", "]", "]", "=", "scaled_w", "-", "gt_boxes", "[", ":", ",", "[", "2", ",", "0", "]", "]", "img_scale_factor", "=", "IM_SCALE", "/", "max", "(", "w", ",", "h", ")", "if", "h", ">", "w", ":", "im_size", "=", "(", "IM_SCALE", ",", "int", "(", "w", "*", "img_scale_factor", ")", ",", "img_scale_factor", ")", "elif", "h", "<", "w", ":", "im_size", "=", "(", "int", "(", "h", "*", "img_scale_factor", ")", ",", "IM_SCALE", ",", "img_scale_factor", ")", "else", ":", "im_size", "=", "(", "IM_SCALE", ",", "IM_SCALE", ",", "img_scale_factor", ")", "entry", "=", "{", "'img'", ":", "self", ".", "transform_pipeline", "(", "image_unpadded", ")", ",", "'img_size'", ":", "im_size", ",", "'gt_boxes'", ":", "gt_boxes", ",", "'gt_classes'", ":", "gt_classes", ",", "'scale'", ":", "IM_SCALE", "/", "BOX_SCALE", ",", "'index'", ":", "index", ",", "'image_id'", ":", "img_id", ",", "'flipped'", ":", "flipped", ",", "'fn'", ":", "path", ",", "}", "return", "entry" ]

[ "Close", "self", "(", "file", "-", "like", "object", ")" ]

[ "def", "close", "(", "self", ")", ":", "self", ".", "closed", "=", "True", "self", ".", "finished", "=", "1", "del", "self", ".", "fp" ]

[ "Two", "NormalDist", "objects", "are", "equal", "if", "their", "mu", "and", "sigma", "are", "both", "equal", "." ]

[ "def", "__eq__", "(", "x1", ",", "x2", ")", ":", "if", "not", "isinstance", "(", "x2", ",", "NormalDist", ")", ":", "return", "NotImplemented", "return", "x1", ".", "_mu", "==", "x2", ".", "_mu", "and", "x1", ".", "_sigma", "==", "x2", ".", "_sigma" ]

[ "Get", "commands", "." ]

[ "def", "get_cmds", "(", "self", ")", ":", "# core doit commands", "cmds", "=", "DoitMain", ".", "get_cmds", "(", "self", ")", "# load nikola commands", "for", "name", ",", "cmd", "in", "self", ".", "nikola", ".", "_commands", ".", "items", "(", ")", ":", "cmds", "[", "name", "]", "=", "cmd", "return", "cmds" ]

[]

[ "def", "_state_priority", "(", "state", ")", ":", "return", "state", ".", "history", ".", "depth" ]

[ "delete", "a", "resource" ]

[ "def", "delete", "(", "self", ",", "obj", ")", ":", "return", "self", ".", "_delete", "(", "obj", "[", "'kind'", "]", ",", "obj", "[", "'metadata'", "]", "[", "'name'", "]", ")" ]

[ "r", "Return", "a", "pretty", "print", "string", "of", "the", "tableau", "." ]

[ "def", "pp", "(", "self", ")", ":", "if", "self", ".", "parent", "(", ")", ".", "_representation", "in", "[", "'core'", ",", "'bounded'", "]", ":", "print", "(", "self", ".", "_repr_diagram", "(", ")", ")", "else", ":", "print", "(", "self", ")" ]

[ "Unwatches", "the", "value", "at", "key", "name", "or", "None", "of", "the", "key", "doesn", "t", "exist" ]

[ "def", "unwatch", "(", "self", ")", ":", "return", "self", ".", "execute_command", "(", "'UNWATCH'", ")" ]

[]

[ "def", "upload_logs_to_object_storage", "(", "waf_logs", ")", ":", "object_storage", "=", "oci", ".", "object_storage", ".", "ObjectStorageClient", "(", "config", ")", "namespace", "=", "object_storage", ".", "get_namespace", "(", ")", ".", "data", "current_datetime", "=", "datetime", ".", "now", "(", ")", "object_name", "=", "\"WafLogs-\"", "+", "str", "(", "current_datetime", ")", "print", "(", "\"Uploading new object to Object Storage - {!r}\"", ".", "format", "(", "object_name", ")", ")", "object_storage", ".", "put_object", "(", "namespace", ",", "bucket_name", ",", "object_name", ",", "bytes", "(", "str", "(", "waf_logs", ")", ",", "'utf-8'", ")", ")" ]

[ "create", "a", "file", "in", "tmp", "with", "name", "and", "contents" ]

[ "def", "create_tmp_file_from_contents", "(", "rname", ",", "data", ",", "ftype", "=", "'yaml'", ")", ":", "tmp", "=", "Utils", ".", "create_tmpfile", "(", "prefix", "=", "rname", ")", "if", "ftype", "==", "'yaml'", ":", "# AUDIT:no-member makes sense here due to ruamel.YAML/PyYAML usage", "# pylint: disable=no-member", "if", "hasattr", "(", "yaml", ",", "'RoundTripDumper'", ")", ":", "Utils", ".", "_write", "(", "tmp", ",", "yaml", ".", "dump", "(", "data", ",", "Dumper", "=", "yaml", ".", "RoundTripDumper", ")", ")", "else", ":", "Utils", ".", "_write", "(", "tmp", ",", "yaml", ".", "safe_dump", "(", "data", ",", "default_flow_style", "=", "False", ")", ")", "elif", "ftype", "==", "'json'", ":", "Utils", ".", "_write", "(", "tmp", ",", "json", ".", "dumps", "(", "data", ")", ")", "else", ":", "Utils", ".", "_write", "(", "tmp", ",", "data", ")", "# Register cleanup when module is done", "atexit", ".", "register", "(", "Utils", ".", "cleanup", ",", "[", "tmp", "]", ")", "return", "tmp" ]

[ "Pearsons", "/", "Spearmans", "correlation", "coefficients", "." ]

[ "def", "vcorrcoef", "(", "X", ",", "y", ",", "mode", "=", "\"pearsons\"", ",", "axis", "=", "-", "1", ")", ":", "if", "issparse", "(", "X", ")", ":", "X", "=", "np", ".", "array", "(", "X", ".", "A", ")", "if", "issparse", "(", "y", ")", ":", "y", "=", "np", ".", "array", "(", "y", ".", "A", ")", "if", "axis", "==", "0", ":", "if", "X", ".", "ndim", ">", "1", ":", "X", "=", "np", ".", "array", "(", "X", ".", "T", ")", "if", "y", ".", "ndim", ">", "1", ":", "y", "=", "np", ".", "array", "(", "y", ".", "T", ")", "if", "X", ".", "shape", "[", "axis", "]", "!=", "y", ".", "shape", "[", "axis", "]", ":", "X", "=", "X", ".", "T", "if", "mode", "in", "{", "\"spearmans\"", ",", "\"spearman\"", "}", ":", "from", "scipy", ".", "stats", ".", "stats", "import", "rankdata", "X", "=", "np", ".", "apply_along_axis", "(", "rankdata", ",", "axis", "=", "-", "1", ",", "arr", "=", "X", ")", "y", "=", "np", ".", "apply_along_axis", "(", "rankdata", ",", "axis", "=", "-", "1", ",", "arr", "=", "y", ")", "Xm", "=", "np", ".", "array", "(", "X", "-", "(", "np", ".", "nanmean", "(", "X", ",", "-", "1", ")", "[", ":", ",", "None", "]", "if", "X", ".", "ndim", ">", "1", "else", "np", ".", "nanmean", "(", "X", ",", "-", "1", ")", ")", ")", "ym", "=", "np", ".", "array", "(", "y", "-", "(", "np", ".", "nanmean", "(", "y", ",", "-", "1", ")", "[", ":", ",", "None", "]", "if", "y", ".", "ndim", ">", "1", "else", "np", ".", "nanmean", "(", "y", ",", "-", "1", ")", ")", ")", "corr", "=", "np", ".", "nansum", "(", "Xm", "*", "ym", ",", "-", "1", ")", "/", "np", ".", "sqrt", "(", "np", ".", "nansum", "(", "Xm", "**", "2", ",", "-", "1", ")", "*", "np", ".", "nansum", "(", "ym", "**", "2", ",", "-", "1", ")", ")", "return", "corr" ]